import Foundation @main struct StreamResolverChecks { struct Failure: Error { let message: String } static let mediaID = "OERe_a0YS4h-DlsBDOeXwX7HOO6316tw" static let page = "https://barelystarted.miruro.tv/watch/\(mediaID)/the-apothecary-diaries-season-3?ep=1" // Sanitized shape from Tubular's observed source response and projection fixture. static let fixture = #""" { "episodeNumber": 1, "config": {"sun": {"player": "native", "proxy": false, "hls": {"segments": {"enabled": false}, "query": {"enabled": false}}}}, "providerOrder": ["sun", "bun"], "tracks": [{"track": "ssub", "providers": [{ "provider": "sun", "servers": [ {"server": "iframe", "headers": null, "streams": [], "embed": {"url": "https://embed.example/"}}, {"server": "icarus-2-1", "headers": {"Origin": "https://ultracloud.cc", "Referer": "https://ultracloud.cc/"}, "streams": [{"url": "https://vault.example/master.m3u8?token=secret", "format": "hls", "embed": null}]} ], "subtitles": [ {"file": "https://vault.example/english.jpeg", "format": "vtt", "language": "en", "label": "English", "default": true}, {"file": "https://vault.example/spanish.jpeg", "format": "vtt", "language": "sp", "label": "Spanish (Latin America)", "default": false}, {"file": "https://vault.example/unsupported.srt", "format": "srt", "language": "en", "label": "English SRT", "default": false} ] }]}] } """# static func require(_ condition: @autoclosure () -> Bool, _ message: String) throws { if !condition() { throw Failure(message: message) } } static func reject(_ message: String, _ operation: () throws -> Void) throws { do { try operation() } catch { try require(!error.localizedDescription.contains("secret"), "errors must not expose source secrets") return } throw Failure(message: "Accepted \(message)") } static func project(_ json: String) throws -> ResolvedSource { try MiruroResolver.decode(Data(json.utf8), mediaID: mediaID, episode: 1).select().source } static func catalog(_ document: [String: Any]) throws -> MiruroSources { try MiruroResolver.decode(JSONSerialization.data(withJSONObject: document), mediaID: mediaID, episode: 1) } static func provider(_ name: String, captions: Bool = true) -> [String: Any] { ["provider": name, "servers": [["headers": ["Referer": "https://\(name).example/"], "streams": [["url": "https://\(name).example/master.m3u8", "format": "hls"]]]], "subtitles": captions ? [["file": "https://\(name).example/english.vtt", "format": "vtt", "language": "en", "label": "English", "default": true]] : []] } static func checks() async throws { guard case .miruro(let id, let episode) = try StreamURL.parse(" \n" + page + "\n") else { throw Failure(message: "Miruro URL classification") } try require(id == mediaID && episode == 1, "opaque identity and route episode retained") guard case .youtube(let youtube) = try StreamURL.parse("https://youtu.be/jNQXAC9IVRw") else { throw Failure(message: "YouTube URL classification") } try require(youtube.absoluteString == "https://www.youtube.com/watch?v=jNQXAC9IVRw", "existing YouTube normalization") let other = "https://vimeo.com/76979871?quality=original" guard case .youtube(let generic) = try StreamURL.parse(other) else { throw Failure(message: "other HTTP(S) sites route through yt-dlp") } try require(generic.absoluteString == other, "other sites retain their URL and query") for invalid in [ page.replacingOccurrences(of: "barelystarted.miruro.tv", with: "barelystarted.miruro.tv@evil.example"), page.replacingOccurrences(of: "https://", with: "http://"), page.replacingOccurrences(of: "https://", with: "https://user:secret@"), page.replacingOccurrences(of: "/watch/", with: "/info/"), page.replacingOccurrences(of: mediaID, with: "invalid%2Fid"), page.replacingOccurrences(of: mediaID, with: "%2e%2e"), page.replacingOccurrences(of: "?ep=1", with: ""), page.replacingOccurrences(of: "?ep=1", with: "?ep=0"), page.replacingOccurrences(of: "?ep=1", with: "?ep=01"), page.replacingOccurrences(of: "?ep=1", with: "?ep=-1"), page.replacingOccurrences(of: "?ep=1", with: "?ep=2147483648"), page.replacingOccurrences(of: "?ep=1", with: "?ep=%31"), page + "&ep=2", page + "&provider=bee", page + "#secret", page.replacingOccurrences(of: ".tv/", with: ".tv:444/"), page.replacingOccurrences(of: "?ep", with: "/?ep"), "file:///secret" ] { try reject("unsupported or unsafe URL") { _ = try StreamURL.parse(invalid) } } let source = try project(fixture) try require(source.identity == "miruro:\(mediaID):1", "stable catalog identity") try require(source.url == "https://vault.example/master.m3u8?token=secret", "first direct HLS stream retained") try require(source.headers == "Origin: https://ultracloud.cc\r\nReferer: https://ultracloud.cc/\r\n", "all server headers retained") try require(source.subtitles.count == 2 && source.subtitles[0].isDefault, "only external VTT retained with default") try require(source.subtitles[0].url.hasSuffix(".jpeg") && source.subtitles[1].label == "Spanish (Latin America)", "subtitle format and labels independent of file extension") try require(source.subtitles.allSatisfy { $0.headers == source.headers }, "verified Sun subtitle headers retained") let native: [String: Any] = ["player": "native", "proxy": false] var captionOnly = provider("bun") captionOnly["servers"] = [["headers": ["Referer": "https://bun.example/"], "streams": [], "embed": ["url": "https://bun.example/embed"]]] var missingVideo = provider("captions") missingVideo["servers"] = [["headers": ["Origin": "https://captions.example"]]] let independentCatalog = try catalog([ "episodeNumber": 1, "config": ["sun": native, "bun": ["player": "iframe", "proxy": false]], "tracks": [["track": "ssub", "providers": [provider("sun"), captionOnly, missingVideo]]] ]) let independentCaptions = try independentCatalog.select(captionProvider: "bun:ssub") try require(independentCaptions.source.subtitles.first?.url == "https://bun.example/english.vtt" && independentCaptions.source.subtitles.first?.headers == "Referer: https://bun.example/\r\n", "iframe-only provider captions are discovered independently of video eligibility") let unconfiguredCaptions = try independentCatalog.select(captionProvider: "captions") try require(unconfiguredCaptions.captionProvider == "captions:ssub" && unconfiguredCaptions.source.subtitles.first?.headers == "Origin: https://captions.example\r\n", "captions without config or video streams retain their own server headers") let embedded = try independentCatalog.select(videoProvider: "bun:ssub") try require(independentCatalog.videoProviders == ["sun:ssub", "bun:ssub"] && independentCatalog.captionProviders == ["sun:ssub", "bun:ssub", "captions:ssub"] && embedded.source.url == "https://bun.example/embed" && embedded.source.requirements.embed, "iframe choices retain the embed URL and require asynchronous native preparation") let captionsOnly = try catalog([ "episodeNumber": 1, "tracks": [["track": "ssub", "providers": [missingVideo]]] ]) try require(captionsOnly.videoProviders.isEmpty && captionsOnly.captionProviders == ["captions:ssub"], "caption discovery does not require any video candidate or config table") try reject("caption-only catalog playback") { _ = try captionsOnly.select() } var document: [String: Any] = [ "episodeNumber": 1, "providerOrder": ["cloud", "river", "sun", "cloud", "missing"], "config": ["sun": native, "river": native, "cloud": native], "tracks": [["track": "ssub", "providers": [provider("river"), provider("sun"), provider("cloud")]]] ] let choices = try catalog(document) try require(choices.videoProviders == ["cloud:ssub", "river:ssub", "sun:ssub"] && choices.captionProviders == ["cloud:ssub", "river:ssub", "sun:ssub"], "choices expose provider and track in deduplicated runtime provider order") let automatic = try choices.select() try require(automatic.videoProvider == "sun:ssub" && automatic.captionProvider == "sun:ssub", "Auto prefers usable Japanese Sun") let independent = try choices.select(videoProvider: "river", captionProvider: "cloud:ssub") try require(independent.videoProvider == "river:ssub" && independent.captionProvider == "cloud:ssub" && independent.source.url == "https://river.example/master.m3u8" && independent.source.headers == "Referer: https://river.example/\r\n" && independent.source.subtitles.first?.headers == "Referer: https://cloud.example/\r\n", "bare provider preference and exact caption choice retain independent URLs and headers") let absent = try choices.select(videoProvider: "absent", captionProvider: "unsupported") let empty = try choices.select(videoProvider: "", captionProvider: "") try require(absent.videoProvider == "sun:ssub" && absent.captionProvider == "sun:ssub" && empty.videoProvider == "sun:ssub" && empty.captionProvider == "sun:ssub", "unavailable and empty preferences fall back to Japanese Auto") document["tracks"] = [["track": "ssub", "providers": [provider("river", captions: false), provider("cloud")]]] let withoutSun = try catalog(document).select() try require(withoutSun.videoProvider == "cloud:ssub" && withoutSun.captionProvider == "cloud:ssub", "provider order applies without Sun") document["providerOrder"] = [] let otherCaptions = try catalog(document).select() try require(otherCaptions.videoProvider == "river:ssub" && otherCaptions.captionProvider == "cloud:ssub", "response order is retained and captions fall back independently") document["tracks"] = [["track": "sub", "providers": [provider("river", captions: false)]]] let noCaptions = try catalog(document) let bare = try noCaptions.select(captionProvider: "cloud") try require(noCaptions.captionProviders.isEmpty && bare.captionProvider == nil && bare.source.subtitles.isEmpty, "Japanese sub without captions remains playable") document["tracks"] = [ ["track": "ssub", "providers": [provider("river")]], ["track": "dub", "providers": [provider("river"), provider("sun")]], ["track": "sub", "providers": [provider("river")]]] document["config"] = ["sun": native, "river": ["player": "native", "proxy": false, "variantOrder": ["dub", "sub", "sub", "ssub"]]] let variants = try catalog(document) let preferredVariant = try variants.select(videoProvider: "river") let dubbed = try variants.select(videoProvider: "river:dub", captionProvider: "river:dub") try require(variants.videoProviders == ["river:dub", "river:sub", "river:ssub", "sun:dub"] && preferredVariant.videoProvider == "river:sub" && preferredVariant.captionProvider == "river:sub" && dubbed.videoProvider == "river:dub" && dubbed.captionProvider == "river:dub", "all tracks remain selectable; bare provider uses variantOrder without implicit dub") document["tracks"] = [["track": "dub", "providers": [provider("sun")]]] let dubOnly = try catalog(document) try reject("automatic dub fallback") { _ = try dubOnly.select() } try reject("bare provider dub fallback") { _ = try dubOnly.select(videoProvider: "sun") } let explicitDub = try dubOnly.select(videoProvider: "sun:dub") try require(explicitDub.videoProvider == "sun:dub", "dub-only catalog remains available for an explicit track choice") let processed: [String: Any] = ["player": "native", "proxy": ["rotate": true, "segments": true], "hls": ["segments": ["enabled": true, "origin": "https://segments.example"], "query": ["enabled": true, "params": ["skip": "opaque", "token": "secret"]]]] document["config"] = ["river": native, "bee": processed] document["tracks"] = [["track": "ssub", "providers": [provider("river"), provider("bee")]]] let processing = try catalog(document).select(videoProvider: "bee", captionProvider: "bee") try require(processing.source.url == "https://bee.example/master.m3u8" && processing.source.requirements.proxy?.rotate == true && processing.source.requirements.proxy?.segments == true && processing.source.requirements.segmentOrigin == "https://segments.example" && processing.source.requirements.playlistQuery == ["skip": "opaque", "token": "secret"] && processing.source.subtitles.first?.proxy?.segments == true && !processing.source.requirements.embed, "selection preserves native proxy/HLS requirements and caption proxy independently") let parent = provider("bee") var embeddedCaptions = provider("bun") embeddedCaptions["subtitles"] = parent["subtitles"] embeddedCaptions["servers"] = [["streams": [], "embed": ["url": "https://megaplay.buzz/videojs/stream/example"]]] document["config"] = ["river": native, "bee": processed, "bun": ["player": "iframe", "proxy": false, "parent": "bee"]] document["tracks"] = [["track": "ssub", "providers": [provider("river"), parent, embeddedCaptions]]] let sharedCaptions = try catalog(document).select(captionProvider: "bun:ssub") try require(sharedCaptions.captionProvider == "bun:ssub" && sharedCaptions.source.subtitles.first?.headers == "Referer: https://bee.example/\r\n" && sharedCaptions.source.subtitles.first?.proxy?.segments == true, "identical iframe caption resources use their parent's known request transport") embeddedCaptions["subtitles"] = provider("bun")["subtitles"] document["tracks"] = [["track": "ssub", "providers": [provider("river"), parent, embeddedCaptions]]] let distinctCaptions = try catalog(document).select(captionProvider: "bun:ssub") try require(distinctCaptions.source.subtitles.first?.proxy == nil && distinctCaptions.source.subtitles.first?.headers.isEmpty == true, "parent credentials and routing never propagate to different caption resources") var unsafeHLS = processed unsafeHLS["hls"] = ["segments": ["enabled": true, "origin": "file:///secret"]] document["config"] = ["river": native, "bee": unsafeHLS] let captionDespiteHLS = try catalog(document).select(videoProvider: "river", captionProvider: "bee:ssub") try require(captionDespiteHLS.captionProvider == "bee:ssub" && captionDespiteHLS.source.subtitles.first?.proxy?.segments == true, "unsupported video processing does not hide valid independent captions") var resilient = provider("river") resilient["servers"] = [ ["streams": [42, ["url": "file:///secret", "format": "hls"], ["url": "https://river.example/master.m3u8", "format": "application/vnd.apple.mpegurl"]] as [Any], "headers": ["Referer": "https://river.example/"]]] document["config"] = ["river": native, "broken": ["player": 42], "bad name": native] document["tracks"] = [["track": "ssub", "providers": [ 42, ["provider": "broken", "servers": "invalid"], provider("bad name"), resilient] as [Any]]] let resilientSources = try catalog(document) try require(resilientSources.videoProviders == ["river:ssub"] && resilientSources.captionProviders == ["river:ssub"], "malformed neighboring entries do not poison usable provider tracks") for (old, replacement) in [ ("https://vault.example/english.jpeg", "https://user:secret@vault.example/english.jpeg"), ("\"default\": false", "\"default\": true") ] { let safeVideo = try project(fixture.replacingOccurrences(of: old, with: replacement)) try require(safeVideo.url == source.url && safeVideo.subtitles.isEmpty, "unsafe caption sets are excluded without losing safe video") } let renewed = try project(fixture.replacingOccurrences(of: "token=secret", with: "token=renewed")) try require(renewed.identity == source.identity && renewed.url != source.url, "token rotation does not change stable identity") for (old, replacement) in [ ("\"episodeNumber\": 1", "\"episodeNumber\": 49"), ("\"proxy\": false", "\"proxy\": true"), ("\"format\": \"hls\"", "\"format\": \"mp4\""), ("https://vault.example/master.m3u8?token=secret", "file:///secret"), ("\"embed\": null", "\"embed\": false"), ("https://ultracloud.cc/\"", "https://ultracloud.cc/\\r\\nX-Injected: secret\""), ("\"Origin\":", "\"origin\": \"secret\", \"Origin\":") ] { try reject("unsafe/unsupported source projection") { _ = try project(fixture.replacingOccurrences(of: old, with: replacement)) } } try reject("oversized metadata") { _ = try MiruroResolver.decode(Data(repeating: 32, count: MiruroResolver.bodyLimit + 1), mediaID: mediaID, episode: 1) } let responseURL = URL(string: "https://barelystarted.miruro.tv/api/sources")! for (status, type, length) in [(403, "text/html", "12"), (302, "application/json", "12"), (200, "text/html", "12"), (200, "application/json", "2097153")] { let response = HTTPURLResponse(url: responseURL, statusCode: status, httpVersion: nil, headerFields: ["Content-Type": type, "Content-Length": length])! try reject("protection/redirect/oversized response") { try MiruroResolver.validateResponse(response) } } let cancelled = Task { withUnsafeCurrentTask { $0?.cancel() } return try await MiruroResolver.resolve(mediaID: mediaID, episode: 1) } do { _ = try await cancelled.value throw Failure(message: "Cancelled resolution was accepted") } catch is CancellationError {} print("PASS: streaming URL security, provider/track choices, proxy/HLS requirements, independent captions, bounded responses and cancellation") } static func main() async { do { let args = Array(CommandLine.arguments.dropFirst()) if args.count == 2, args[0] == "--live" { guard case .miruro(let id, let episode) = try StreamURL.parse(args[1]) else { throw Failure(message: "--live requires a Miruro episode URL") } let sources = try await MiruroResolver.resolve(mediaID: id, episode: episode) let selection = try sources.select() print("PASS: live video=\(selection.videoProvider); captions=\(selection.captionProvider ?? "none"); \(sources.videoProviders.count) hosts; \(sources.captionProviders.count) caption providers; \(selection.source.subtitles.count) VTT tracks") } else if args.count == 2, args[0] == "--fixture" { let data = try Data(contentsOf: URL(fileURLWithPath: args[1])) let sources = try MiruroResolver.decode(data, mediaID: mediaID, episode: 1) let selection = try sources.select() print("PASS: fixture video=\(selection.videoProvider); captions=\(selection.captionProvider ?? "none"); \(sources.videoProviders.count) hosts; \(sources.captionProviders.count) caption providers; \(selection.source.subtitles.count) VTT tracks") } else if args.isEmpty { try await checks() } else { throw Failure(message: "Usage: stream-resolver-check [--live EPISODE_URL | --fixture SOURCES_JSON]") } } catch { let message = (error as? Failure)?.message ?? error.localizedDescription FileHandle.standardError.write(Data("FAIL: \(message)\n".utf8)) exit(1) } } }