@koda-sl/baker-cli 0.386.0-dev.4e118c09a → 0.386.0-dev.d6e55699d

package/dist/chunk-ERSX3MKH.js

@@ -0,0 +1,34 @@
+// src/lib/repeatedFlags.ts
+function repeatedFlagValues(rawArgs, flag) {
+  const long = `--${flag}`;
+  const inline = `${long}=`;
+  const values = [];
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    if (arg === "--") break;
+    if (arg === long) {
+      const value = rawArgs[i + 1];
+      if (value !== void 0 && !value.startsWith("-")) {
+        values.push(value);
+        i++;
+      }
+    } else if (arg?.startsWith(inline)) {
+      values.push(arg.slice(inline.length));
+    }
+  }
+  return values;
+}
+function repeatedValues(rawArgs, flag, parsed) {
+  if (rawArgs !== void 0) {
+    const fromLine = repeatedFlagValues(rawArgs, flag);
+    if (fromLine.length > 0) return fromLine;
+  }
+  if (Array.isArray(parsed)) return parsed.filter((v) => typeof v === "string");
+  return typeof parsed === "string" && parsed.length > 0 ? [parsed] : [];
+}
+
+export {
+  repeatedFlagValues,
+  repeatedValues
+};
+//# sourceMappingURL=chunk-ERSX3MKH.js.map

package/dist/chunk-ERSX3MKH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/repeatedFlags.ts"],"sourcesContent":["/**\n * Every value a flag was given on the command line.\n *\n * citty declares no array arg type: it hands `util.parseArgs` its options\n * without `multiple: true`, so a repeated flag collapses to its LAST value.\n * `--param utm_source=linkedin --param utm_medium=paid` reaches `run` as the\n * single string `\"utm_medium=paid\"`, and code shaped like\n * `Array.isArray(raw) ? raw : [raw]` never takes its array branch.\n *\n * That is silent, and on a wholesale-replace write it is destructive: the\n * command reports success having staged one pair of the three it was given,\n * and publish then replaces the entity's whole parameter set with that one.\n * So every repeatable flag reads its values from `ctx.rawArgs` instead.\n *\n * Accepts both spellings (`--flag value` and `--flag=value`), stops at a bare\n * `--`, and ignores a trailing flag with no value — that is a malformed line,\n * not an empty value.\n */\nexport function repeatedFlagValues(rawArgs: readonly string[], flag: string): string[] {\n  const long = `--${flag}`;\n  const inline = `${long}=`;\n  const values: string[] = [];\n  for (let i = 0; i < rawArgs.length; i++) {\n    const arg = rawArgs[i];\n    if (arg === \"--\") break;\n    if (arg === long) {\n      const value = rawArgs[i + 1];\n      if (value !== undefined && !value.startsWith(\"-\")) {\n        values.push(value);\n        i++;\n      }\n    } else if (arg?.startsWith(inline)) {\n      values.push(arg.slice(inline.length));\n    }\n  }\n  return values;\n}\n\n/**\n * The values of a repeatable flag, preferring the command line over the parsed\n * arg. `rawArgs` is absent in unit tests that call a payload builder directly\n * with an already-collected array, so the parsed value stays the fallback.\n */\nexport function repeatedValues(rawArgs: readonly string[] | undefined, flag: string, parsed: unknown): string[] {\n  if (rawArgs !== undefined) {\n    const fromLine = repeatedFlagValues(rawArgs, flag);\n    if (fromLine.length > 0) return fromLine;\n  }\n  if (Array.isArray(parsed)) return parsed.filter((v): v is string => typeof v === \"string\");\n  return typeof parsed === \"string\" && parsed.length > 0 ? [parsed] : [];\n}\n"],"mappings":";AAkBO,SAAS,mBAAmB,SAA4B,MAAwB;AACrF,QAAM,OAAO,KAAK,IAAI;AACtB,QAAM,SAAS,GAAG,IAAI;AACtB,QAAM,SAAmB,CAAC;AAC1B,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,MAAM,QAAQ,CAAC;AACrB,QAAI,QAAQ,KAAM;AAClB,QAAI,QAAQ,MAAM;AAChB,YAAM,QAAQ,QAAQ,IAAI,CAAC;AAC3B,UAAI,UAAU,UAAa,CAAC,MAAM,WAAW,GAAG,GAAG;AACjD,eAAO,KAAK,KAAK;AACjB;AAAA,MACF;AAAA,IACF,WAAW,KAAK,WAAW,MAAM,GAAG;AAClC,aAAO,KAAK,IAAI,MAAM,OAAO,MAAM,CAAC;AAAA,IACtC;AAAA,EACF;AACA,SAAO;AACT;AAOO,SAAS,eAAe,SAAwC,MAAc,QAA2B;AAC9G,MAAI,YAAY,QAAW;AACzB,UAAM,WAAW,mBAAmB,SAAS,IAAI;AACjD,QAAI,SAAS,SAAS,EAAG,QAAO;AAAA,EAClC;AACA,MAAI,MAAM,QAAQ,MAAM,EAAG,QAAO,OAAO,OAAO,CAAC,MAAmB,OAAO,MAAM,QAAQ;AACzF,SAAO,OAAO,WAAW,YAAY,OAAO,SAAS,IAAI,CAAC,MAAM,IAAI,CAAC;AACvE;","names":[]}

package/dist/chunk-FKOECEVC.js

@@ -0,0 +1,126 @@
+// src/commands/videos/videoPlatforms.ts
+var PLATFORM_DOMAINS = {
+  youtube: ["youtube.com", "youtu.be"],
+  instagram: ["instagram.com", "ddinstagram.com"],
+  tiktok: ["tiktok.com"],
+  twitter: ["twitter.com", "x.com", "vxtwitter.com", "fixvx.com"],
+  facebook: ["facebook.com", "fb.watch", "fb.com"],
+  linkedin: ["linkedin.com", "lnkd.in"],
+  reddit: ["reddit.com", "redd.it"],
+  vimeo: ["vimeo.com"],
+  dailymotion: ["dailymotion.com", "dai.ly"],
+  twitch: ["twitch.tv"],
+  bluesky: ["bsky.app"],
+  bilibili: ["bilibili.com", "bilibili.tv", "b23.tv"],
+  vk: ["vk.com", "vk.ru", "vkvideo.ru"],
+  ok: ["ok.ru"],
+  pinterest: ["pinterest.com", "pin.it"],
+  tumblr: ["tumblr.com"],
+  snapchat: ["snapchat.com"],
+  loom: ["loom.com"],
+  streamable: ["streamable.com"],
+  newgrounds: ["newgrounds.com"],
+  rutube: ["rutube.ru"]
+};
+var VIDEO_PLATFORMS = Object.keys(PLATFORM_DOMAINS);
+function platformFromUrl(rawUrl) {
+  let host;
+  try {
+    host = new URL(rawUrl).hostname.toLowerCase();
+  } catch {
+    return "url";
+  }
+  for (const [platform, domains] of Object.entries(PLATFORM_DOMAINS)) {
+    if (domains.some((domain) => host === domain || host.endsWith(`.${domain}`))) {
+      return platform;
+    }
+  }
+  return "url";
+}
+
+// src/commands/videos/ingestUrl.ts
+var MAX_VIDEO_INGEST_BYTES = 16 * 1024 * 1024 * 1024;
+var MAX_VIDEO_INGEST_SECONDS = 3 * 60 * 60;
+function refuseByDuration(seconds, maxSeconds) {
+  if (seconds === void 0 || seconds <= maxSeconds) return null;
+  return `That video is ${(seconds / 3600).toFixed(1)} hours long \u2014 the limit is ${Math.round(maxSeconds / 3600)} hours.`;
+}
+var DOWNLOAD_TIMEOUT_FLOOR_MS = 10 * 60 * 1e3;
+var DOWNLOAD_TIMEOUT_CEILING_MS = 15 * 60 * 1e3;
+function downloadTimeoutMs(seconds) {
+  if (seconds === void 0) return DOWNLOAD_TIMEOUT_FLOOR_MS;
+  const scaled = seconds * 2 * 1e3;
+  return Math.min(Math.max(scaled, DOWNLOAD_TIMEOUT_FLOOR_MS), DOWNLOAD_TIMEOUT_CEILING_MS);
+}
+var DIRECT_MEDIA_EXTENSIONS = [".mp4", ".mov", ".webm", ".m4v", ".mkv", ".avi"];
+function isDirectMediaUrl(rawUrl) {
+  const pathname = safePathname(rawUrl);
+  return DIRECT_MEDIA_EXTENSIONS.some((ext) => pathname.endsWith(ext));
+}
+function resolveIngestSource(explicit, rawUrl) {
+  if (explicit) return explicit;
+  return platformFromUrl(rawUrl);
+}
+var TOOLING_OR_BLOCK_SIGNATURES = [
+  "requested format is not available",
+  "only images are available",
+  "nsig",
+  "sign in to confirm",
+  // bot check — distinct from "Private video. Sign in if…"
+  "unable to download api page",
+  "http error 403",
+  // yt-dlp's own "the site changed under me" signature. It prints a GitHub issue
+  // link whenever a page parsed nothing like the shape the extractor expects —
+  // which is precisely a downloader that has aged out, not a bad link. Observed
+  // live on TikTok, which probed fine and then broke ninety minutes later from
+  // the same machine, identically through direct, datacenter and residential
+  // exits. Without this it fell through to "check the link is public", sending
+  // the reader to inspect a video that was never the problem.
+  "please report this issue"
+];
+function isToolingOrBlockFailure(detail) {
+  const haystack = detail.toLowerCase();
+  return TOOLING_OR_BLOCK_SIGNATURES.some((signature) => haystack.includes(signature));
+}
+var REGION_BLOCK_SIGNATURES = [
+  "in your country",
+  "geo-restricted",
+  "geo restricted",
+  "not available from your location",
+  "blocked in your country"
+];
+function isDrmProtected(detail) {
+  return detail.toLowerCase().includes("drm protected");
+}
+function isRegionBlocked(detail) {
+  const haystack = detail.toLowerCase();
+  return REGION_BLOCK_SIGNATURES.some((signature) => haystack.includes(signature));
+}
+function worthDownloadingInstead(errorCode) {
+  return errorCode === "VALIDATION_ERROR";
+}
+function directDedupeKey(source, rawUrl) {
+  return `${source}:${rawUrl}`;
+}
+function safePathname(rawUrl) {
+  try {
+    return new URL(rawUrl).pathname.toLowerCase();
+  } catch {
+    return "";
+  }
+}
+
+export {
+  MAX_VIDEO_INGEST_BYTES,
+  MAX_VIDEO_INGEST_SECONDS,
+  refuseByDuration,
+  downloadTimeoutMs,
+  isDirectMediaUrl,
+  resolveIngestSource,
+  isToolingOrBlockFailure,
+  isDrmProtected,
+  isRegionBlocked,
+  worthDownloadingInstead,
+  directDedupeKey
+};
+//# sourceMappingURL=chunk-FKOECEVC.js.map

package/dist/chunk-FKOECEVC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/videos/videoPlatforms.ts","../src/commands/videos/ingestUrl.ts"],"sourcesContent":["/**\n * Which platform a video link came from.\n *\n * This exists for provenance, not for capability. The downloader already reaches\n * far more sites than are named here, so a platform missing from this table\n * still ingests — it is simply recorded as `url`. What the table buys is the\n * ability to answer \"where did this clip come from\" later: a competitor's TikTok,\n * a supplier's Vimeo and the client's own YouTube are different things to a\n * marketer, and collapsing all three into \"url\" throws that away at the only\n * moment it is knowable.\n *\n * Kept deliberately small. Naming every site the downloader supports would be a\n * list nobody can maintain and would still be missing the next one; these are the\n * platforms whose provenance actually changes how a clip gets used.\n */\n\n/** Registrable domains per platform. Subdomains match; lookalikes must not. */\nconst PLATFORM_DOMAINS = {\n  youtube: [\"youtube.com\", \"youtu.be\"],\n  instagram: [\"instagram.com\", \"ddinstagram.com\"],\n  tiktok: [\"tiktok.com\"],\n  twitter: [\"twitter.com\", \"x.com\", \"vxtwitter.com\", \"fixvx.com\"],\n  facebook: [\"facebook.com\", \"fb.watch\", \"fb.com\"],\n  linkedin: [\"linkedin.com\", \"lnkd.in\"],\n  reddit: [\"reddit.com\", \"redd.it\"],\n  vimeo: [\"vimeo.com\"],\n  dailymotion: [\"dailymotion.com\", \"dai.ly\"],\n  twitch: [\"twitch.tv\"],\n  bluesky: [\"bsky.app\"],\n  bilibili: [\"bilibili.com\", \"bilibili.tv\", \"b23.tv\"],\n  vk: [\"vk.com\", \"vk.ru\", \"vkvideo.ru\"],\n  ok: [\"ok.ru\"],\n  pinterest: [\"pinterest.com\", \"pin.it\"],\n  tumblr: [\"tumblr.com\"],\n  snapchat: [\"snapchat.com\"],\n  loom: [\"loom.com\"],\n  streamable: [\"streamable.com\"],\n  newgrounds: [\"newgrounds.com\"],\n  rutube: [\"rutube.ru\"],\n} as const satisfies Record<string, readonly string[]>;\n\nexport type VideoPlatform = keyof typeof PLATFORM_DOMAINS;\n\n/** Every platform this can name; `platformFromUrl` returns one of these or `url`. */\nexport const VIDEO_PLATFORMS = Object.keys(PLATFORM_DOMAINS) as readonly VideoPlatform[];\n\n/**\n * The platform a URL belongs to, or `url` when it is not one we name.\n *\n * Matching is on the host, anchored at a dot boundary — never `includes`. That\n * is the whole security property of this function: `youtube.com.evil.test` and\n * `notyoutube.com` are attacker-controlled hosts that would otherwise inherit\n * YouTube's identity, and provenance that can be spoofed is worse than none,\n * because it is trusted.\n *\n * Pinterest is a deliberate omission from the country-mirror handling: cobalt\n * collapses `pinterest.co.uk` and friends, and doing the same here would mean\n * carrying a list of every ccTLD a platform has ever used. Those links resolve\n * as `url` and still ingest.\n */\nexport function platformFromUrl(rawUrl: string): VideoPlatform | \"url\" {\n  let host: string;\n  try {\n    host = new URL(rawUrl).hostname.toLowerCase();\n  } catch {\n    return \"url\";\n  }\n\n  for (const [platform, domains] of Object.entries(PLATFORM_DOMAINS)) {\n    if (domains.some((domain) => host === domain || host.endsWith(`.${domain}`))) {\n      return platform as VideoPlatform;\n    }\n  }\n  return \"url\";\n}\n","import { platformFromUrl } from \"./videoPlatforms.ts\";\n/**\n * URL classification for `baker videos ingest`. Pure so the routing decision —\n * hand the URL to Baker, or download it here first — is testable without a\n * network, a sandbox, or yt-dlp installed.\n */\n\n/**\n * Ceiling on the download path only. The direct path has no equivalent: Mux\n * fetches the file itself, so nothing is held in the Runtime's memory or disk.\n *\n * This was 2 GB, and it was never really a policy — it was a memory limit\n * wearing a policy's clothes. The upload read the whole file into a Buffer and\n * then copied it again into a `Uint8Array` (measured: that constructor does not\n * alias), so peak RAM was twice the file and an 8 GB Runtime would be OOM-killed\n * before the check ever fired. The file now streams from disk\n * (`lib/streamUpload.ts`), peak memory is one chunk regardless of length, and\n * this bounds the Runtime's *disk* — the last resource a download still spends\n * in proportion to how long the video is.\n *\n * The gate that does the real work is `refuseByDuration`, below: it turns away a\n * too-long video from its metadata, before a single byte is fetched.\n */\nexport const MAX_VIDEO_INGEST_BYTES = 16 * 1024 * 1024 * 1024;\n\n/** The longest video we will pull down, in seconds. */\nexport const MAX_VIDEO_INGEST_SECONDS = 3 * 60 * 60;\n\n/**\n * Whether a video is too long to ingest, phrased for whoever pasted the link.\n *\n * Duration rather than bytes, because duration is knowable *before* downloading\n * and a byte count is not: a watch page carries no `content-length`, an adaptive\n * stream has one per segment, and the merged file does not exist until it has\n * been muxed. So a byte cap can only be enforced after paying for the very\n * download it was supposed to avoid, while a duration cap costs one metadata\n * probe.\n *\n * An unknown duration is accepted, not refused. A live stream, or a site that\n * publishes no metadata, reports nothing — and treating silence as \"too long\"\n * would turn a missing field into a blocked ingest. The byte ceiling still\n * catches those on the way out.\n */\nexport function refuseByDuration(seconds: number | undefined, maxSeconds: number): string | null {\n  if (seconds === undefined || seconds <= maxSeconds) return null;\n  return `That video is ${(seconds / 3600).toFixed(1)} hours long — the limit is ${Math.round(maxSeconds / 3600)} hours.`;\n}\n\n/** Floor, and what an unknown duration gets: enough for any ordinary clip. */\nconst DOWNLOAD_TIMEOUT_FLOOR_MS = 10 * 60 * 1000;\n/**\n * Ceiling, and the binding constraint in practice.\n *\n * Set by what a person waiting in a chat will tolerate, not by what a download\n * might need: the turn is blocked for this whole time, and a chat that appears\n * frozen for three quarters of an hour is a worse outcome than a clip that did\n * not import. Fifteen minutes covers any ordinary clip even from a slow CDN,\n * and a video that cannot make it says so and points at `upload`.\n */\nconst DOWNLOAD_TIMEOUT_CEILING_MS = 15 * 60 * 1000;\n\n/**\n * How long a download may take, derived from how long the video is.\n *\n * These two numbers have to be related or they quietly contradict each other,\n * which is exactly what happened: the duration gate accepted up to three hours\n * while every download got a flat ten-minute window, so a 33-minute VK video —\n * served slowly, still transferring at 137 MB when the clock ran out — was\n * accepted by one rule and made impossible by another. It surfaced as\n * \"Unexpected error\", because a timeout throws a plain `Error` that the caller\n * discarded.\n *\n * Twice real-time is the budget: generous for a CDN serving faster than\n * playback, and still finite for one that is not. The ceiling matters more than\n * the ratio — without it a three-hour video would license a six-hour download.\n */\nexport function downloadTimeoutMs(seconds: number | undefined): number {\n  if (seconds === undefined) return DOWNLOAD_TIMEOUT_FLOOR_MS;\n  const scaled = seconds * 2 * 1000;\n  return Math.min(Math.max(scaled, DOWNLOAD_TIMEOUT_FLOOR_MS), DOWNLOAD_TIMEOUT_CEILING_MS);\n}\n\nconst DIRECT_MEDIA_EXTENSIONS = [\".mp4\", \".mov\", \".webm\", \".m4v\", \".mkv\", \".avi\"] as const;\n\n/**\n * True when the URL's path ends in a media extension, which is the signal that\n * Mux can pull it directly. Deliberately conservative: a false negative only\n * costs an unnecessary download, while a false positive hands Mux a web page.\n */\nexport function isDirectMediaUrl(rawUrl: string): boolean {\n  const pathname = safePathname(rawUrl);\n  return DIRECT_MEDIA_EXTENSIONS.some((ext) => pathname.endsWith(ext));\n}\n\n/** Explicit `--source` always wins; otherwise infer provenance from the host. */\nexport function resolveIngestSource(explicit: string | undefined, rawUrl: string): string {\n  if (explicit) return explicit;\n  return platformFromUrl(rawUrl);\n}\n\n/**\n * Signatures of \"the site wouldn't hand over the video\", as opposed to \"this\n * link is private or gone\".\n *\n * They matter because the remediation is opposite. These all mean the downloader\n * could not read the page — nearly always because it has aged out against a site\n * that changed (YouTube rewrites its player every few weeks) or because the\n * request was blocked. Retrying is useless and the user's link is fine, so\n * telling them to check whether their public video is \"private\" sends them after\n * a problem that isn't theirs.\n */\nconst TOOLING_OR_BLOCK_SIGNATURES = [\n  \"requested format is not available\",\n  \"only images are available\",\n  \"nsig\",\n  \"sign in to confirm\", // bot check — distinct from \"Private video. Sign in if…\"\n  \"unable to download api page\",\n  \"http error 403\",\n  // yt-dlp's own \"the site changed under me\" signature. It prints a GitHub issue\n  // link whenever a page parsed nothing like the shape the extractor expects —\n  // which is precisely a downloader that has aged out, not a bad link. Observed\n  // live on TikTok, which probed fine and then broke ninety minutes later from\n  // the same machine, identically through direct, datacenter and residential\n  // exits. Without this it fell through to \"check the link is public\", sending\n  // the reader to inspect a video that was never the problem.\n  \"please report this issue\",\n] as const;\n\nexport function isToolingOrBlockFailure(detail: string): boolean {\n  const haystack = detail.toLowerCase();\n  return TOOLING_OR_BLOCK_SIGNATURES.some((signature) => haystack.includes(signature));\n}\n\n/**\n * Failures a *different country* could plausibly open — the only ones where\n * retrying with `--country` is worth suggesting.\n *\n * Deliberately narrow, and it is the narrowness that matters. Every rung of the\n * ladder already tries a different IP, so \"we were refused\" is not evidence that\n * geography was the reason; it is only evidence that geography *might* be. These\n * phrases are the ones where the site itself named the country.\n *\n * TikTok is the worked counter-example and the reason this is not a loose match\n * on \"blocked\": it answers with \"Your IP address is blocked from accessing this\n * post\", which reads exactly like a geo problem. Measured across six exits in\n * four countries — Spain direct, Spain datacenter, US, DE, SG, BR — that post\n * failed identically from all of them, while a different post succeeded from the\n * plain direct IP. Treating that string as regional would sell the agent a retry\n * that cannot work, once per country it thinks to try.\n */\nconst REGION_BLOCK_SIGNATURES = [\n  \"in your country\",\n  \"geo-restricted\",\n  \"geo restricted\",\n  \"not available from your location\",\n  \"blocked in your country\",\n] as const;\n\n/**\n * The video's own encryption refusing us — a hard stop, not a hurdle.\n *\n * Kept separate from every other failure because it is the only one where the\n * honest answer is \"no, and no amount of retrying, signing in or changing\n * country will alter that\". Removing DRM is a different act from downloading\n * something published openly, so this never suggests a workaround.\n *\n * Checked *before* the tooling signatures, because a DRM video also emits\n * \"Requested format is not available\" as its second line — and that phrase is\n * read as a stale downloader, which would file a permanent property of the video\n * as a bug in our tooling. Measured: `--check-formats`, the remedy yt-dlp's own\n * message suggests, does not help when the audio track is the encrypted part.\n */\nexport function isDrmProtected(detail: string): boolean {\n  return detail.toLowerCase().includes(\"drm protected\");\n}\n\nexport function isRegionBlocked(detail: string): boolean {\n  const haystack = detail.toLowerCase();\n  return REGION_BLOCK_SIGNATURES.some((signature) => haystack.includes(signature));\n}\n\n/**\n * Whether a failed direct ingest is worth retrying by downloading the file\n * ourselves.\n *\n * The subtlety that makes this necessary: the download route finishes by posting\n * to the *same* endpoint, with the same API key and the same `source`. So a\n * failure about the request rather than about the URL is guaranteed to fail\n * again identically, except now after pulling the whole video down first.\n *\n * An allow-list of one, and it has to be, because the codes here are the CLI's\n * (`mapHttpError`), not the backend's. That distinction was previously missed:\n * this listed backend names, so `apiError(\"BAD_REQUEST\")` — the code the route\n * raises when Mux refuses the source, and the only case this exists for —\n * arrived as `VALIDATION_ERROR` and was refused, while a backend 500 arrived as\n * `INTERNAL_ERROR`, matched nothing, and downloaded a whole video to replay the\n * identical failing request. Naming the outcome we want, rather than the ones we\n * don't, means a code nobody anticipated costs a missed retry instead of a\n * wasted download.\n *\n * `VALIDATION_ERROR` is unambiguous *here* only because the request body is zod\n * validated client-side before it is ever sent, so a 400 from this route is not\n * a malformed request — it is Baker saying it could not fetch that URL.\n */\nexport function worthDownloadingInstead(errorCode: string): boolean {\n  return errorCode === \"VALIDATION_ERROR\";\n}\n\n/**\n * The dedupe key for a URL handed straight to Baker.\n *\n * The direct path never probes — that is the whole point of it — so there is no\n * provider id to key on and the URL is the only identifier available. That is\n * the same position the download path's *generic* extractor branch is in, and it\n * resolves it the same way, so a link filed directly and the same link filed via\n * the download fallback agree on one row instead of producing two.\n *\n * Keyed on the full URL rather than the filename: two unrelated clips are very\n * often both called `demo.mp4`, and a collision silently returns the wrong video\n * under a successful-looking response, which is far worse than a missed dedupe.\n * A signed URL carrying an expiring token simply never dedupes, which is the\n * harmless direction to fail in.\n */\nexport function directDedupeKey(source: string, rawUrl: string): string {\n  return `${source}:${rawUrl}`;\n}\n\nfunction safePathname(rawUrl: string): string {\n  try {\n    return new URL(rawUrl).pathname.toLowerCase();\n  } catch {\n    return \"\";\n  }\n}\n"],"mappings":"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","names":[]}