hl-valdemar/terebi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases Wiki Activity

fix: populate queue titles independently of playback extraction

Browse Source 
The sidebar scheduler waited for playback and used full stream extraction for titles. Use independent utility-priority title requests, native YouTube oEmbed, and metadata-only extraction for generic sites. Preserve foreground title precedence and stale row protection.

Verified: make check-youtube check-queue check-resolved check-adaptive check-stream all.
This commit is contained in:
Valdemar Høgsvig Lorenzen
2026-10-22 18:28:49 +02:00
parent 98e6dcb3c5
commit 4576080955
8 changed files with 287 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Checks/resolved-playback.swift
+67 -55
View File
@@ -117,28 +117,31 @@ struct ResolvedPlaybackCheck {
let suite = "terebi.queue-metadata-check." + UUID().uuidString
let defaults = UserDefaults(suiteName: suite)!
defer { defaults.removePersistentDomain(forName: suite) }
let urls = ["AAAAAAAAAAA", "BBBBBBBBBBB", "CCCCCCCCCCC", "DDDDDDDDDDD"].map {
let urls = ["AAAAAAAAAAA", "BBBBBBBBBBB", "CCCCCCCCCCC"].map {
URL(string: "https://www.youtube.com/watch?v=\($0)")!
}
} + [URL(string: "https://video.example/watch/fixture")!]
let episode = URL(string: "https://barelystarted.miruro.tv/watch/fixture-ID/episode?ep=1")!
var foreground: CheckedContinuation<YouTubeVideo, Never>?
var background: CheckedContinuation<YouTubeVideo, Never>?
var background: CheckedContinuation<String?, Never>?
var holdFirst = true
var episodeRequests = 0
func video(_ url: URL, title: String) -> YouTubeVideo {
var titleRequests: [URL] = []
func video(_ url: URL, title: String, height: Int = 1080) -> YouTubeVideo {
YouTubeVideo(title: title, video: .init(url: source.url, headers: source.headers), audio: nil,
duration: 0, isLive: false, webpageURL: url, height: nil, availableHeights: [])
duration: 0, isLive: false, webpageURL: url, height: height, availableHeights: [1080, 720])
}
let model = PlayerModel(defaults: defaults, youtubeResolver: { url, _ in
if url == urls[0], holdFirst {
let model = PlayerModel(defaults: defaults, youtubeResolver: { url, height in
if holdFirst || height != nil {
holdFirst = false
return await withCheckedContinuation { foreground = $0 }
}
if url == urls[1], Task.currentPriority <= .utility {
return await withCheckedContinuation { background = $0 }
}
if url == urls[2] { throw CocoaError(.fileReadCorruptFile) }
return video(url, title: url == urls[0] ? "Playing title" : "Fresh playback title")
}, youtubeTitleResolver: { url in
require(Task.currentPriority <= .utility, "title-only lookups use lower priority")
titleRequests.append(url)
if url == urls[1] { return await withCheckedContinuation { background = $0 } }
if url == urls[2] { throw CocoaError(.fileReadCorruptFile) }
return url == urls[0] ? "Early current title" : "Generic page title"
}, miruroResolver: { _, _ in
fatalError("FAIL: sidebar enrichment must not fetch Miruro playback sources")
}, miruroMetadataResolver: { _, _ in
@@ -154,68 +157,79 @@ struct ResolvedPlaybackCheck {
})
}
model.openStreamQueue(queue([urls[0], urls[1], episode, urls[2], urls[3]]))
try await until("foreground extraction starts first", model: model) { foreground != nil }
require(background == nil && episodeRequests == 0, "sidebar lookups yield to selected extraction")
foreground!.resume(returning: video(urls[0], title: "Playing title"))
foreground = nil
try await until("native playback and background extraction start", model: model) {
!model.isBusy && model.state.status == PLAYER_PLAYING && background != nil
try await until("early current title and next title request while full extraction is held", model: model) {
foreground != nil && background != nil && model.queue.currentItem?.displayName == "Early current title"
}
require(episodeRequests == 0, "sidebar lookups are serial")
require(model.setPlayback(playing: false), "pause for background title resolution")
try await until("metadata smoke pause acknowledged", model: model) { model.state.status == PLAYER_PAUSED }
require(model.resolvingStream && model.fileName == nil && episodeRequests == 0 &&
titleRequests == [urls[0], urls[1]], "serial sidebar work is independent of foreground extraction")
let selected = model.queue.currentID
let position = model.state.position
let pendingID = model.queue.items[1].id
model.moveQueueItems(fromOffsets: IndexSet(integer: 1), toOffset: 5)
background!.resume(returning: video(urls[1], title: "Queued title"))
background!.resume(returning: "Queued title")
background = nil
let deadline = ContinuousClock.now.advanced(by: .seconds(2))
while model.queue.items.last?.displayName != "Queued title", ContinuousClock.now < deadline {
try await Task.sleep(for: .milliseconds(10))
}
require(model.queue.items.last?.id == pendingID && model.queue.items.last?.displayName == "Queued title",
"unplayed queue entry resolves by identity after reorder")
try await until("mixed queue metadata continues after failure", model: model) {
model.queue.items.first { $0.url == episode }?.displayName == "Queued episode" &&
model.queue.items.first { $0.url == urls[3] }?.displayName == "Fresh playback title"
try await until("mixed queue titles continue before foreground extraction finishes", model: model) {
model.queue.items.last?.displayName == "Queued title" &&
model.queue.items.first { $0.url == episode }?.displayName == "Queued episode" &&
model.queue.items.first { $0.url == urls[3] }?.displayName == "Generic page title"
}
require(model.queue.items.last?.id == pendingID && model.queue.currentID == selected &&
model.resolvingStream && model.fileName == nil, "reordered metadata updates only its original row")
require(model.queue.items.first { $0.url == urls[2] }?.displayName == urls[2].absoluteString &&
model.commandError == nil, "failed enrichment preserves fallback and does not block later titles")
require(model.queue.currentID == selected &&
model.state.position == position && model.state.status == PLAYER_PAUSED &&
model.fileName == "Playing title", "background metadata preserves selection, position, paused state and current title")
model.queue.items.first { $0.url == urls[2] }?.metadataAttempted == true &&
model.commandError == nil, "failed title preserves fallback and does not block later titles")
foreground!.resume(returning: video(urls[0], title: "Playing title"))
foreground = nil
try await until("foreground title takes precedence and native playback starts", model: model) {
model.state.status == PLAYER_PLAYING && model.queue.currentItem?.displayName == "Playing title"
}
require(model.setPlayback(playing: false), "pause for metadata preservation")
try await until("metadata smoke pause acknowledged", model: model) { model.state.status == PLAYER_PAUSED }
let position = model.state.position
for _ in 0..<10 { await Task.yield() }
require(model.queue.currentID == selected && model.state.position == position &&
model.fileName == "Playing title", "title-only metadata preserves native selection, position and current title")
model.openStreamQueue(queue([urls[0], urls[1]]))
try await until("next background lookup starts", model: model) { background != nil }
let cancelled = background!
try await until("next title-only lookup starts", model: model) { background != nil }
let selectedLookup = background!
background = nil
model.selectQueueItem(model.queue.items[1].id)
try await until("selection preempts pending metadata with fresh playback extraction", model: model) {
try await until("selection resolves fresh playback independently", model: model) {
!model.isBusy && model.state.status == PLAYER_PLAYING && model.fileName == "Fresh playback title"
}
cancelled.resume(returning: video(urls[1], title: "Stale title"))
selectedLookup.resume(returning: "Stale title")
for _ in 0..<10 { await Task.yield() }
require(model.queue.currentItem?.displayName == "Fresh playback title" &&
model.fileName == "Fresh playback title", "cancelled metadata cannot overwrite selected title")
model.fileName == "Fresh playback title", "late title-only result cannot overwrite foreground metadata")
model.openStreamQueue(queue([urls[0], urls[1]]))
try await until("removable background lookup starts", model: model) { background != nil }
try await until("removable title-only lookup starts", model: model) { background != nil }
let removed = background!
background = nil
model.removeQueueItem(model.queue.items[1].id)
model.openStreamQueue(queue([urls[0], urls[1]]))
try await until("replacement background lookup starts", model: model) { background != nil }
removed.resume(returning: video(urls[1], title: "Removed title"))
try await until("replacement title-only lookup starts", model: model) { background != nil }
removed.resume(returning: "Removed title")
for _ in 0..<10 { await Task.yield() }
require(model.queue.items[1].displayName == urls[1].absoluteString,
"removed/replaced item cannot rename a new row for the same URL")
background!.resume(returning: video(urls[1], title: "Replacement title"))
require(model.setPlayback(playing: false), "pause before quality extraction")
try await until("quality smoke pause acknowledged", model: model) { model.state.status == PLAYER_PAUSED }
model.setYouTubeQuality(720)
try await until("quality extraction is held", model: model) { foreground != nil }
background!.resume(returning: "Replacement title")
background = nil
try await until("replacement result updates its own row", model: model) {
try await until("title arrives while quality extraction is held", model: model) {
model.queue.items[1].displayName == "Replacement title"
}
print("PASS: background mixed-stream titles, utility priority, serial lookup, reorder, failure, playback preemption and stale removal/replacement")
require(model.resolvingStream && model.fileName == "Playing title" &&
model.queue.currentItem?.displayName == "Playing title", "title work does not replace current quality metadata")
foreground!.resume(returning: video(urls[0], title: "Quality title", height: 720))
foreground = nil
try await until("quality extraction resumes paused native playback", model: model) {
!model.isBusy && model.state.status == PLAYER_PAUSED && model.fileName == "Quality title"
}
print("PASS: early current/queued titles during held playback and quality extraction; serial utility lookup, generic/Miruro titles, reorder, failure and stale replacement/foreground precedence")
}
static func streamQueueLifecycle(source: ResolvedSource) async throws {
@@ -242,14 +256,12 @@ struct ResolvedPlaybackCheck {
video: .init(url: source.url, headers: source.headers), audio: nil,
duration: 0, isLive: false, webpageURL: youtubeURL, height: nil, availableHeights: [])
let model = PlayerModel(defaults: defaults, streamQueue: queue, youtubeResolver: { _, _ in
if Task.currentPriority > .utility {
youtubeRequests += 1
if youtubeRequests == 1 {
return await withCheckedContinuation { stale = $0 }
}
youtubeRequests += 1
if youtubeRequests == 1 {
return await withCheckedContinuation { stale = $0 }
}
return video
}, miruroResolver: { _, _ in
}, youtubeTitleResolver: { _ in nil }, miruroResolver: { _, _ in
episodeRequests += 1
return source
}, miruroMetadataResolver: { _, _ in MiruroMetadata(title: nil, intervals: []) })
@@ -349,7 +361,7 @@ struct ResolvedPlaybackCheck {
return YouTubeVideo(title: url.absoluteString,
video: .init(url: source.url, headers: source.headers), audio: nil,
duration: 0, isLive: false, webpageURL: url, height: nil, availableHeights: [])
}, miruroResolver: { _, _ in episodeRequests += 1; return source },
}, youtubeTitleResolver: { _ in nil }, miruroResolver: { _, _ in episodeRequests += 1; return source },
miruroMetadataResolver: { _, _ in MiruroMetadata(title: nil, intervals: []) })
defer { model.shutdown() }
func deliver(_ items: [(URL, URL)]) throws {
@@ -468,7 +480,7 @@ struct ResolvedPlaybackCheck {
let empty = PlayerModel(defaults: defaults, youtubeResolver: { url, _ in
YouTubeVideo(title: "Cold enqueue", video: .init(url: source.url, headers: source.headers), audio: nil,
duration: 0, isLive: false, webpageURL: url, height: nil, availableHeights: [])
})
}, youtubeTitleResolver: { _ in nil })
defer { empty.shutdown() }
let coldReport = directory.appendingPathComponent("cold.jsonl")
empty.enqueueStreamQueue(StreamQueue(entries: [.init(url: fourth, identity: fourth.absoluteString,
@@ -498,7 +510,7 @@ struct ResolvedPlaybackCheck {
duration: 0, isLive: false, webpageURL: url, height: nil, availableHeights: [])
if url == cancelledURL { return await withCheckedContinuation { pending = $0 } }
return video
}, miruroResolver: { _, _ in source },
}, youtubeTitleResolver: { _ in nil }, miruroResolver: { _, _ in source },
miruroMetadataResolver: { _, _ in MiruroMetadata(title: nil, intervals: []) })
defer { model.shutdown() }
try await model.addStreamToQueue(first.absoluteString)