@koda-sl/baker-cli 0.384.0-dev.4699b7308 → 0.384.0-dev.557795bef

package/dist/chunk-W4SA4CMR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/vimeoCookie.ts","../src/lib/ytDlpSignal.ts","../src/lib/ytDlp.ts","../src/lib/ytDlpFormat.ts","../src/lib/ytDlpPlayerClient.ts"],"sourcesContent":["import { writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\n\n/**\n * Vimeo's session cookie, as a file yt-dlp can read.\n *\n * Vimeo is the only platform with no anonymous route left: every yt-dlp client\n * either cannot mint a token any more or refuses without a login, and the\n * failure is identical through direct, datacenter and residential exits, so it\n * is neither our IP nor our TLS fingerprint. A logged-in cookie is the whole\n * fix — measured, `vimeo` alone is sufficient and `vuid`/`auth_xsrft` without it\n * are worthless.\n *\n * The cookie arrives as a value, never as a path: the backend owns the secret\n * and the sandbox owns its filesystem, so nothing outside writes into the\n * Runtime. `--cookies <path>` then puts only the path in argv, keeping the\n * credential out of `ps` — the same rule that governs proxy passwords.\n */\n\n/** The single cookie yt-dlp's `_is_logged_in` actually checks. */\nconst COOKIE_NAME = \"vimeo\";\n\n/**\n * Write the cookie jar, returning its path — or undefined when unconfigured.\n *\n * Undefined rather than an empty file, because an empty jar is not the same as\n * no jar: yt-dlp would read it, find no session, and fail with the anonymous\n * error while looking as though credentials had been supplied.\n */\nexport async function writeVimeoCookieFile(cookie: string | undefined, workDir: string): Promise<string | undefined> {\n  const value = cookie?.trim();\n  if (!value) return undefined;\n\n  // A year out. The jar's own expiry is a formality — Vimeo expires the session\n  // server-side on its own schedule, and `isVimeoAuthFailure` is what notices.\n  const expires = Math.floor(Date.now() / 1000) + 365 * 24 * 60 * 60;\n  const jar = [\n    \"# Netscape HTTP Cookie File\",\n    [\".vimeo.com\", \"TRUE\", \"/\", \"TRUE\", String(expires), COOKIE_NAME, value].join(\"\\t\"),\n    \"\",\n  ].join(\"\\n\");\n\n  const filePath = path.join(workDir, \"vimeo-cookies.txt\");\n  // 0o600 at creation, not chmod-after: the sandbox runs the agent's own shell,\n  // and a world-readable window between write and chmod is a window.\n  await writeFile(filePath, jar, { mode: 0o600 });\n  return filePath;\n}\n\n/**\n * Whether a Vimeo failure is about authentication rather than the video.\n *\n * Every one of these phrasings means the same thing to whoever pasted the link —\n * Vimeo would not talk to us — but Vimeo's own wording (\"Failed to fetch macos\n * OAuth token\") names an internal detail that sends the reader nowhere. The\n * distinction earns its place because this credential *expires*: without it, the\n * day the cookie lapses looks like a brand-new mystery instead of a five-minute\n * re-export.\n *\n * Scoped to `[vimeo]` so another platform's 401 cannot inherit advice about a\n * cookie that has nothing to do with it.\n */\nconst VIMEO_AUTH_SIGNATURES = [\"oauth token\", \"only works when logged-in\", \"unable to fetch new oauth tokens\"] as const;\n\nexport function isVimeoAuthFailure(detail: string): boolean {\n  const haystack = detail.toLowerCase();\n  if (!haystack.includes(\"[vimeo]\")) return false;\n  return VIMEO_AUTH_SIGNATURES.some((signature) => haystack.includes(signature));\n}\n","import type { BlockSignal } from \"@baker/proxy\";\n\n/**\n * yt-dlp's stderr, read as the same signal every other surface produces.\n *\n * Deliberately only extraction — `shouldEscalate` still makes the decision, so\n * yt-dlp cannot drift into its own private idea of what a block is. The two\n * halves have to stay separate: a downloader that decided for itself would be\n * the one surface where a 404 could cost money.\n *\n * The parsing exists because yt-dlp gives us prose and an exit code, not a\n * response. There is no status line to read, so the status has to be recovered\n * from the sentence it was printed into.\n */\n\n/** `HTTP Error 403: Forbidden`, in any of the shapes yt-dlp writes it. */\nconst HTTP_ERROR = /HTTP Error (\\d{3})/i;\n\n/**\n * Refusals that arrive as prose with no status at all.\n *\n * YouTube's bot check is the one that matters: it is the single most common\n * reason a datacenter IP fails a download that a residential one completes, and\n * it looks like an ordinary successful page to everything except a human\n * reading the text.\n */\nconst CHALLENGE_PHRASES = [\n  \"sign in to confirm you're not a bot\",\n  \"sign in to confirm you’re not a bot\",\n  \"confirm you are not a bot\",\n  \"unusual traffic\",\n  \"captcha\",\n];\n\n/**\n * Prose that must never escalate, checked *before* the phrases above.\n *\n * \"Private video. Sign in if you've been granted access\" contains a sign-in\n * demand and is not a block — no exit IP on earth opens it, and treating it as\n * one would spend the expensive rung on every private link an agent is handed.\n */\nconst NOT_A_BLOCK_PHRASES = [\"private video\", \"video unavailable\", \"members-only\", \"this video is available to\"];\n\n/**\n * Our own proxy refusing us, which yt-dlp writes without an `HTTP Error` prefix.\n *\n * Checked before everything else. A 407 cannot come from an origin server, so\n * recovering it is what lets `isProxyFailure` separate \"the platform's egress\n * credentials are wrong\" from \"this site blocked us\" — opposite remediations,\n * and the first is otherwise invisible: a rotated password reads downstream as\n * every site having simultaneously started refusing us.\n */\nconst PROXY_TUNNEL_FAILURE = /tunnel connection failed: 407|proxy authentication required|http error 407/i;\n\nexport function ytDlpBlockSignal(stderr: string): BlockSignal {\n  const text = stderr.toLowerCase();\n\n  if (PROXY_TUNNEL_FAILURE.test(stderr)) return { status: 407 };\n\n  if (NOT_A_BLOCK_PHRASES.some((phrase) => text.includes(phrase))) return {};\n\n  // First, not last. yt-dlp prints a line per retry, so the final line is\n  // usually \"giving up after 3 retries\" — the verdict that started the sequence\n  // is the one that says why.\n  const status = HTTP_ERROR.exec(stderr);\n  if (status) return { status: Number(status[1]) };\n\n  if (CHALLENGE_PHRASES.some((phrase) => text.includes(phrase))) return { challenge: true };\n  return {};\n}\n","import { spawn } from \"node:child_process\";\nimport { readdir, readFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport type { ProxyCredentials, ProxyRoute, ProxyTier } from \"@baker/proxy\";\nimport { DIRECT_ROUTE, plannedRoutes, shouldEscalate } from \"@baker/proxy\";\nimport { captureProxyCredentials, childEnvWith } from \"../env.ts\";\nimport { writeVimeoCookieFile } from \"./vimeoCookie.ts\";\nimport { videoFormatArgs } from \"./ytDlpFormat.ts\";\nimport { needsPlayerClientRetry, YOUTUBE_FALLBACK_CLIENT_ARGS } from \"./ytDlpPlayerClient.ts\";\nimport { ytDlpBlockSignal } from \"./ytDlpSignal.ts\";\n\n/**\n * yt-dlp, run through the egress ladder, shared by the canvas `ingest` node and\n * `baker videos ingest`.\n *\n * Both download the same kinds of URL from the same sandbox and must agree about\n * what \"blocked\" means and how a credential is written down — and the second of\n * those is a decision that silently means two different passwords if it is made\n * twice (see `proxyEnvFor`). One copy is the point.\n *\n * Callers own how a failure is reported: the node wraps `YtDlpError` in a\n * `NodeExecutionError`, the command turns it into a `{ ok: false }` envelope.\n */\n\nexport const YT_DLP_BIN = \"yt-dlp\";\nexport const YT_DLP_TIMEOUT_MS = 10 * 60 * 1000;\n/** A probe fetches no media, so it gets a much shorter leash than a download. */\nexport const YT_DLP_PROBE_TIMEOUT_MS = 60 * 1000;\n\nexport type YtDlpInfo = Record<string, unknown>;\n\n/**\n * Verify TLS against the system bundle, never certifi's.\n *\n * The Runtime reads HTTPS through the credential broker, and the broker's CA is\n * installed in the system bundle (`SSL_CERT_FILE`) and nowhere else. yt-dlp is\n * installed with certifi and, left alone, verifies against certifi's own copy —\n * so once the broker shipped, every direct download in a Runtime failed with\n * `CERTIFICATE_VERIFY_FAILED` while `curl` to the same host answered. The agent\n * that hit it on our own CDN worked around it by pointing a committed canvas at\n * its gitignored local cache, which broke the next Session's publish. The\n * impersonating (curl_cffi) path reads `CURL_CA_BUNDLE`, which the broker also\n * sets, so it needs nothing here.\n */\nconst TRUST_SYSTEM_CERTS = [\"--compat-options\", \"no-certifi\"] as const;\n\nexport class YtDlpError extends Error {\n  constructor(\n    message: string,\n    readonly stderrTail: string,\n  ) {\n    super(message);\n    this.name = \"YtDlpError\";\n  }\n}\n\nexport function tail(text: string, maxLines: number): string {\n  return text.split(\"\\n\").slice(-maxLines).join(\"\\n\");\n}\n\n/**\n * Download `url` into `workDir`, climbing to a paid exit only if the host\n * refused the cheaper one. Returns the media file and yt-dlp's info.json\n * (best-effort — yt-dlp omits it for some direct file URLs).\n *\n * By default the best the site will release: `bv*+ba/b`. There used to be an\n * optional height cap here, on the reasoning that a 4K master is bytes we\n * re-encode anyway — but both callers now want the master, because capping\n * discards source pixels before the systems that make renditions from them ever\n * see them, and that loss is permanent while the saving is one download.\n * The one exception is opt-in: a bulk import may pass `maxHeight`.\n */\nexport async function runYtDlp(args: {\n  url: string;\n  audioOnly: boolean;\n  workDir: string;\n  timeoutMs?: number;\n  onLog?: (message: string) => void;\n  country?: string;\n  /** Vimeo session cookie value; written to a jar in `workDir` when present. */\n  vimeoCookie?: string;\n  /** Opt-in resolution cap (shorter side) for bulk imports — see `videoFormatArgs`. */\n  maxHeight?: number;\n}): Promise<{ filePath: string; info: YtDlpInfo; tier: EgressTier; reducedQuality: boolean }> {\n  const outTemplate = path.join(args.workDir, \"out.%(ext)s\");\n  const infoPath = path.join(args.workDir, \"out.info.json\");\n\n  const argv: string[] = [\n    args.url,\n    \"--no-playlist\",\n    \"--no-progress\",\n    \"--no-warnings\",\n    \"--quiet\",\n    \"--write-info-json\",\n    ...TRUST_SYSTEM_CERTS,\n    \"-o\",\n    outTemplate,\n  ];\n\n  if (args.audioOnly) {\n    argv.push(\"-x\", \"--audio-format\", \"m4a\");\n  } else {\n    argv.push(...videoFormatArgs(args.maxHeight));\n  }\n\n  const cookieFile = await writeVimeoCookieFile(args.vimeoCookie, args.workDir);\n  if (cookieFile) argv.push(\"--cookies\", cookieFile);\n\n  args.onLog?.(`yt-dlp: downloading ${args.audioOnly ? \"audio\" : \"video\"}`);\n  const timeoutMs = args.timeoutMs ?? YT_DLP_TIMEOUT_MS;\n  const { code, stderr, tier, reducedQuality } = await downloadWithClientFallback({\n    url: args.url,\n    argv,\n    onLog: args.onLog,\n    ladder: (attemptArgv) =>\n      runViaLadder({ url: args.url, argv: attemptArgv, timeoutMs, onLog: args.onLog, country: args.country }),\n    repeat: (attemptArgv, route) => spawnAndWait(YT_DLP_BIN, attemptArgv, timeoutMs, { extraEnv: proxyEnvFor(route) }),\n  });\n\n  if (code !== 0) {\n    throw new YtDlpError(`yt-dlp exited ${code}`, tail(stderr, 40));\n  }\n\n  const files = await readdir(args.workDir);\n  const wanted = args.audioOnly ? \".m4a\" : \".mp4\";\n  const downloaded = files.find((f) => f.startsWith(\"out.\") && f.endsWith(wanted));\n  if (!downloaded) {\n    throw new YtDlpError(`yt-dlp finished but produced no ${wanted} file (saw: ${files.join(\", \")})`, \"\");\n  }\n\n  let info: YtDlpInfo = {};\n  try {\n    info = JSON.parse(await readFile(infoPath, \"utf-8\")) as YtDlpInfo;\n  } catch {\n    // info.json is best-effort — yt-dlp sometimes omits it for direct file URLs.\n  }\n\n  return { filePath: path.join(args.workDir, downloaded), info, tier, reducedQuality };\n}\n\n/**\n * Read a URL's metadata without fetching any media.\n *\n * Worth its own round trip because it settles the one thing that has to be known\n * before the expensive part starts: how long the video is. Measured, a ten-hour\n * link is now refused in ~3s, where the byte ceiling it replaced could only\n * refuse it after the download it was meant to avoid. It also carries the\n * provider id, which used to be readable only from the download's own info.json.\n *\n * Climbs the same egress ladder as the download, so a host that answers only a\n * paid exit is probed through one too.\n */\nexport async function probeYtDlp(args: {\n  url: string;\n  timeoutMs?: number;\n  onLog?: (message: string) => void;\n  country?: string;\n  /** Vimeo session cookie value. `cookieDir` must be set for it to be used. */\n  vimeoCookie?: string;\n  cookieDir?: string;\n}): Promise<{ info: YtDlpInfo; tier: EgressTier }> {\n  const argv = [\n    args.url,\n    \"--no-playlist\",\n    \"--no-warnings\",\n    \"--dump-single-json\",\n    \"--skip-download\",\n    // Without this the probe fails wherever the *download* would fail, which\n    // defeats the point of probing: yt-dlp still runs format selection for\n    // `--dump-single-json`, so a binary too old to read a site's format list\n    // exits \"Requested format is not available\" and we learn nothing — measured\n    // against a stale build, which returned full metadata the moment this flag\n    // was added. Duration and id come from the page, not from a format.\n    \"--ignore-no-formats-error\",\n    ...TRUST_SYSTEM_CERTS,\n  ];\n\n  // The probe needs the same credential as the download: Vimeo refuses metadata\n  // to an anonymous caller too, so probing without it fails before the duration\n  // gate ever runs.\n  if (args.cookieDir) {\n    const cookieFile = await writeVimeoCookieFile(args.vimeoCookie, args.cookieDir);\n    if (cookieFile) argv.push(\"--cookies\", cookieFile);\n  }\n\n  let stdout = \"\";\n  const { code, stderr, tier } = await walkYtDlpLadder({\n    url: args.url,\n    credentials: captureProxyCredentials(),\n    attempt: async (route) => {\n      const result = await spawnAndWait(YT_DLP_BIN, argv, args.timeoutMs ?? YT_DLP_PROBE_TIMEOUT_MS, {\n        extraEnv: proxyEnvFor(route),\n        captureStdout: true,\n      });\n      stdout = result.stdout ?? \"\";\n      return result;\n    },\n    onLog: args.onLog,\n    country: args.country,\n  });\n\n  if (code !== 0) {\n    throw new YtDlpError(`yt-dlp exited ${code}`, tail(stderr, 40));\n  }\n\n  // Parsed, not trusted: yt-dlp prints a bare `null` for a page it recognised\n  // but could not extract, and on at least one site it pairs that with a\n  // non-zero exit — so the exit code alone is not enough to promise an object.\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(stdout);\n  } catch {\n    throw new YtDlpError(\"yt-dlp returned metadata that could not be read\", tail(stdout, 5));\n  }\n  if (parsed === null || typeof parsed !== \"object\") {\n    throw new YtDlpError(\"yt-dlp returned no metadata for that link\", tail(stderr, 40));\n  }\n  return { info: parsed as YtDlpInfo, tier };\n}\n\n/**\n * True only when the source explicitly says it carries no video.\n *\n * `vcodec: \"none\"` is the assertion; a *missing* vcodec is not, and that\n * distinction is the whole function. Measured: SoundCloud reports `\"none\"`,\n * while Streamable reports `null` and is perfectly good video. The obvious\n * version of this check — \"no format has a video codec\" — matches both and\n * would refuse Streamable, which ingests fine today.\n *\n * Caught at probe time because the alternative is what it replaces: the\n * download succeeds, produces an `.m4a`, and the caller fails looking for an\n * `.mp4` — surfaced as \"yt-dlp finished but produced no .mp4 file\", which names\n * an internal expectation rather than the fact that someone linked to audio.\n */\nexport function isAudioOnly(info: YtDlpInfo): boolean {\n  return info.vcodec === \"none\";\n}\n\n/** The probed duration in seconds, when the site reported one that can be read. */\nexport function durationSeconds(info: YtDlpInfo): number | undefined {\n  const raw = info.duration;\n  return typeof raw === \"number\" && Number.isFinite(raw) && raw > 0 ? raw : undefined;\n}\n\n/**\n * The canonical page URL for what was probed, when the extractor resolved one.\n *\n * Worth preferring over the URL a person pasted, because yt-dlp has already done\n * the normalising: measured, it turns `youtu.be/<id>?si=…&t=42`,\n * `/shorts/<id>` and `m.youtube.com/watch?v=<id>&feature=share` all into the one\n * `www.youtube.com/watch?v=<id>`. Storing the raw paste instead files the same\n * video under a different `externalUrl` depending on where the link was copied\n * from, which is exactly the provenance question this field exists to answer.\n */\nexport function canonicalUrl(info: YtDlpInfo): string | undefined {\n  const raw = info.webpage_url;\n  return typeof raw === \"string\" && raw.length > 0 ? raw : undefined;\n}\n\n/**\n * Walk the ladder: direct first, then each configured tier, stopping the moment\n * the failure is one a different exit IP cannot fix.\n *\n * The escalation decision is `shouldEscalate`'s, not ours — the same closed\n * allow-list every other egress surface uses. A downloader that decided for\n * itself would be the one surface where a 404 could cost money.\n */\nexport type EgressTier = \"direct\" | ProxyTier;\n\n/**\n * Which rung produced this result — so a paid exit is never spent invisibly.\n *\n * The `route` is here, and not just the tier's name, because one caller needs to\n * *repeat* the rung rather than merely report it: the player-client fallback\n * re-runs on whichever exit already got far enough to be refused at the media\n * stage. A name cannot be handed back to `proxyEnvFor`; the route can.\n */\nexport type LadderResult = SpawnResult & { tier: EgressTier; route: ProxyRoute };\n\nexport async function walkYtDlpLadder(args: {\n  url: string;\n  credentials: ProxyCredentials;\n  attempt: (route: ProxyRoute) => Promise<SpawnResult>;\n  onLog?: (message: string) => void;\n  /**\n   * ISO-3166 alpha-2 exit country for the paid rungs. Omit for \"wherever\".\n   *\n   * Not inferred and never automatic: a country is only right when someone\n   * knows *which* one opens the video, and guessing would multiply the cost of\n   * every failure by the length of the guess list. `@baker/proxy` owns the\n   * per-product syntax — datacenter and residential spell geo differently and\n   * each rejects the other's token.\n   */\n  country?: string;\n}): Promise<LadderResult> {\n  const routes = plannedRoutes(args.url, args.credentials, args.country ? { country: args.country } : undefined);\n  let last: LadderResult = { code: -1, stderr: \"\", tier: \"direct\", route: DIRECT_ROUTE };\n\n  for (const route of routes) {\n    const tier: EgressTier = route.kind === \"proxy\" ? route.tier : \"direct\";\n    if (route.kind === \"proxy\") args.onLog?.(`yt-dlp: retrying via ${tier}`);\n    last = { ...(await args.attempt(route)), tier, route };\n    if (last.code === 0) return last;\n    if (!shouldEscalate(ytDlpBlockSignal(last.stderr))) return last;\n  }\n  return last;\n}\n\n/**\n * The download, plus the one retry that changes the player instead of the exit.\n *\n * Split out from `runYtDlp` with its two runners injected because the decision\n * this makes is the expensive one to get wrong and the hardest to observe: it\n * spends egress. A test can drive both branches here; it cannot drive them\n * through a function that spawns a binary.\n *\n * **The retry repeats one rung and opens no new one.** It re-runs on\n * `first.route` — whichever exit already got far enough to be refused at the\n * media stage — rather than walking the ladder again. Walking it again was the\n * first version of this and it was wrong in exactly the way this whole change\n * exists to stop: the trigger is a 403, `shouldEscalate` treats a 403 as\n * escalatable, so a fallback client that was also refused would climb through\n * datacenter and residential a second time, paying twice more for a verdict\n * that has already been shown not to depend on the address. Re-using the rung\n * is also what makes the retry correct when the *only* rung that reached the\n * media stage was a paid one — a direct-only retry would land back on the bot\n * wall that made us leave direct in the first place.\n */\nexport async function downloadWithClientFallback(args: {\n  url: string;\n  argv: readonly string[];\n  ladder: (argv: readonly string[]) => Promise<LadderResult>;\n  repeat: (argv: readonly string[], route: ProxyRoute) => Promise<SpawnResult>;\n  onLog?: (message: string) => void;\n}): Promise<LadderResult & { reducedQuality: boolean }> {\n  const first = await args.ladder(args.argv);\n  if (first.code === 0 || !needsPlayerClientRetry(args.url, first.stderr)) {\n    return { ...first, reducedQuality: false };\n  }\n\n  args.onLog?.(\"yt-dlp: retrying with the fallback player client\");\n  const again = await args.repeat([...args.argv, ...YOUTUBE_FALLBACK_CLIENT_ARGS], first.route);\n\n  // `tier` and `route` stay the first attempt's: the retry deliberately did not\n  // move, so reporting a different rung would misstate what was spent.\n  return { ...again, tier: first.tier, route: first.route, reducedQuality: again.code === 0 };\n}\n\nfunction runViaLadder(args: {\n  url: string;\n  argv: readonly string[];\n  timeoutMs: number;\n  onLog?: (message: string) => void;\n  country?: string;\n}): Promise<LadderResult> {\n  return walkYtDlpLadder({\n    url: args.url,\n    credentials: captureProxyCredentials(),\n    attempt: (route) => spawnAndWait(YT_DLP_BIN, args.argv, args.timeoutMs, { extraEnv: proxyEnvFor(route) }),\n    onLog: args.onLog,\n    country: args.country,\n  });\n}\n\n/**\n * A route as the environment a child process reads it from.\n *\n * Env, never `--proxy`: the flag would put the password in `argv`, readable by\n * any `ps` sharing the sandbox and printed by yt-dlp into the very stderr this\n * module reads back and attaches to an error. Both spellings, because \"which\n * case does this tool read\" is not worth being wrong about once — and `NO_PROXY`\n * is deliberately unset, since `plannedRoutes` has already refused to build a\n * proxy route for a private address.\n *\n * The percent-encoding is correct here and is deliberately **not** the same\n * decision as `browserProxyUrl` in `@baker/proxy`. Measured against both readers\n * with a proxy that logs what it receives: given `ab%3Dcd`, yt-dlp (Python)\n * authenticates as `ab=cd` — it decodes — while Chromium authenticates as the\n * literal `ab%3Dcd`. The same URL means two different passwords depending on who\n * reads it, so each side is written for its own reader. Do not harmonise them.\n */\nexport function proxyEnvFor(route: ProxyRoute): Record<string, string> | undefined {\n  if (route.kind !== \"proxy\") return undefined;\n  const uri = new URL(route.server);\n  uri.username = encodeURIComponent(route.username);\n  uri.password = encodeURIComponent(route.password);\n  return {\n    HTTP_PROXY: uri.toString(),\n    HTTPS_PROXY: uri.toString(),\n    http_proxy: uri.toString(),\n    https_proxy: uri.toString(),\n  };\n}\n\nexport type SpawnResult = { code: number; stderr: string; stdout?: string };\n\n/**\n * Spawn helper local to yt-dlp: the engine's `cli-runner` rejects URL arguments\n * by policy, which is directly at odds with yt-dlp's job.\n *\n * stdout is discarded unless asked for, because on a download it is the media\n * progress firehose; the probe is the one caller that actually wants it.\n */\nexport function spawnAndWait(\n  bin: string,\n  argv: readonly string[],\n  timeoutMs: number,\n  options: { extraEnv?: Record<string, string>; captureStdout?: boolean } = {},\n): Promise<SpawnResult> {\n  return new Promise((resolve, reject) => {\n    const child = spawn(bin, argv, {\n      stdio: [\"ignore\", \"pipe\", \"pipe\"],\n      // `childEnvWith` because `spawn`'s `env` REPLACES the environment rather\n      // than extending it — passing only the additions would strip PATH.\n      ...(options.extraEnv ? { env: childEnvWith(options.extraEnv) } : {}),\n    });\n    const stderrChunks: Buffer[] = [];\n    const stdoutChunks: Buffer[] = [];\n    let stderrLen = 0;\n    const MAX_STDERR = 256 * 1024;\n\n    child.stdout.on(\"data\", (chunk: Buffer) => {\n      if (options.captureStdout) stdoutChunks.push(chunk);\n    });\n    child.stderr.on(\"data\", (chunk: Buffer) => {\n      if (stderrLen < MAX_STDERR) {\n        stderrChunks.push(chunk);\n        stderrLen += chunk.length;\n      }\n    });\n\n    const timer = setTimeout(() => {\n      child.kill(\"SIGKILL\");\n      reject(new Error(`${bin} timed out after ${timeoutMs}ms`));\n    }, timeoutMs);\n\n    child.on(\"error\", (err) => {\n      clearTimeout(timer);\n      reject(new Error(`failed to spawn \"${bin}\" — ${err.message}`));\n    });\n\n    child.on(\"close\", (code) => {\n      clearTimeout(timer);\n      resolve({\n        code: code ?? -1,\n        stderr: Buffer.concat(stderrChunks).toString(\"utf-8\"),\n        ...(options.captureStdout ? { stdout: Buffer.concat(stdoutChunks).toString(\"utf-8\") } : {}),\n      });\n    });\n  });\n}\n","/**\n * Which video yt-dlp keeps. By default the best the site releases — see\n * `runYtDlp` for why the master matters. A caller importing in bulk may cap\n * the resolution instead: a whole channel of 4K masters is five times the bytes\n * of 1080p, and those bytes are what overruns a download's time budget.\n *\n * The cap is on the shorter side (yt-dlp's `res` sort field), not the height: a\n * vertical Short's 1080p is 1080×1920, and a height cap would keep its 608×1080\n * rendition instead. A sort rather than a filter, so when nothing fits the cap\n * the closest there is still beats no video.\n */\nexport function videoFormatArgs(maxResolution?: number): string[] {\n  const sort = maxResolution ? [\"-S\", `res:${maxResolution}`] : [];\n  return [\"--format\", \"bv*+ba/b\", ...sort, \"--merge-output-format\", \"mp4\"];\n}\n","/**\n * The second thing to try when YouTube hands us a video and then refuses it.\n *\n * Distinct from the egress ladder, and the distinction is the whole point. The\n * ladder answers \"would a different IP help\"; this answers \"would a different\n * *client* help\" — and measured inside a Runtime, the second question is the one\n * that was failing. yt-dlp's default client selection lands on `android_vr`,\n * whose media URLs YouTube now signs and then rejects, so extraction succeeds,\n * a format is chosen, and the byte fetch comes back\n * `unable to download video data: HTTP Error 403: Forbidden`. That failure is\n * identical from every exit: direct, datacenter and residential all produced it,\n * so climbing the ladder spent both paid rungs to reproduce it.\n *\n * The `android` client resolves a progressive format whose URL is honoured from\n * the same address — verified on two unrelated videos from the Runtime's own IP\n * after the default clients had 403'd. It is a *fallback*, not the default: it\n * currently offers only 360p, so it is worth reaching for once the good formats\n * have already been refused and worth nothing before that.\n */\n\n/** yt-dlp's argv for the fallback client. Appended, never substituted. */\nexport const YOUTUBE_FALLBACK_CLIENT_ARGS = [\"--extractor-args\", \"youtube:player_client=android\"] as const;\n\n/**\n * The refusal that happens *after* a format was chosen.\n *\n * Deliberately this exact phrase rather than a bare 403: a 403 raised while\n * fetching the page is a block on us, which the egress ladder already owns and\n * can actually fix. This one is raised on the media URL yt-dlp was just given,\n * which no exit IP changes.\n */\nconst MEDIA_FETCH_REFUSED = \"unable to download video data\";\n\nconst YOUTUBE_HOSTS = [\"youtube.com\", \"youtu.be\"];\n\nfunction isYouTube(url: string): boolean {\n  let host: string;\n  try {\n    host = new URL(url).hostname.toLowerCase();\n  } catch {\n    return false;\n  }\n  return YOUTUBE_HOSTS.some((known) => host === known || host.endsWith(`.${known}`));\n}\n\n/** True when re-running with the fallback client is worth one more attempt. */\nexport function needsPlayerClientRetry(url: string, stderr: string): boolean {\n  return isYouTube(url) && stderr.toLowerCase().includes(MEDIA_FETCH_REFUSED);\n}\n"],"mappings":"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","names":["path","path"]}

package/dist/chunk-WFUMNDCE.js

@@ -0,0 +1,111 @@
+import {
+  reportError,
+  splitList
+} from "./chunk-OIL6PU5W.js";
+import {
+  apiGet
+} from "./chunk-CUL3VB4L.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-MYTDK3AL.js";
+
+// src/commands/winning-ads/launches.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "winning-ads.launches",
+  description: 'What the brands you follow (or the ones named) launched in the last N days and which of those ads still run, each with its stage (new, testing, killed_early\u2026), and the tests each brand decided in that window (the version kept, what differed). The "what did competitors launch last week" report. Compact by default; --full lists every launch.',
+  args: {
+    since: { type: "number", description: "Days to look back, 1-90 (default 7)", required: false, default: 7 },
+    advertiser: {
+      type: "string",
+      description: "Comma list of advertiser ids instead of every followed brand",
+      required: false
+    },
+    platform: { type: "string", description: "Only this platform: meta|linkedin|tiktok|google", required: false },
+    full: { type: "boolean", description: "List every launch", required: false, default: false }
+  }
+});
+var COMPACT_LAUNCHES = 10;
+function compactLaunches(report, full) {
+  return {
+    since_days: report.since_days,
+    advertisers: report.advertisers.map((b) => ({
+      advertiser_id: b.advertiser_id,
+      label: b.label,
+      launched: b.launched,
+      still_running: b.still_running,
+      launches: (full ? b.launches : b.launches.slice(0, COMPACT_LAUNCHES)).map((l) => ({
+        ad_id: l.ad_id,
+        platform: l.platform,
+        format: l.format,
+        headline: l.headline,
+        first_seen_at: l.first_seen_at,
+        stage: l.stage,
+        idea: l.idea ?? null,
+        ...full ? { media_url: l.media_url } : {}
+      })),
+      tests_decided: (b.tests_decided ?? []).map((t) => ({
+        concept: t.concept,
+        versions: t.versions,
+        kept_ad_id: t.winner_ad_id,
+        decided_at: t.decided_at ?? null,
+        what_differed: t.what_differed
+      }))
+    }))
+  };
+}
+var IDEA_HINT = "Idea: whether each launch was a `new` idea (the first day of its concept), another version of one the brand was still `testing`, or a version built on a `winner` it had already kept. Many launches and no new idea means the brand is iterating on what works, not testing new directions: say so.";
+function launchesHints(report, named) {
+  if (!named && report.following_count === 0) {
+    return ["You follow no brands yet: `baker winning-ads follow <domain>` adds one, or pass --advertiser <id>."];
+  }
+  if (report.advertisers.length === 0) {
+    return [`No launches in the last ${report.since_days} days. Widen the window with --since 30.`];
+  }
+  const withIdeas = report.advertisers.some((b) => b.launches.some((l) => l.idea));
+  return [
+    ...withIdeas ? [IDEA_HINT] : [],
+    "Stages: new \u22647 days, testing \u226421 days, proven \u226460 days, evergreen beyond, killed_early = stopped within 2 weeks (a lost test). tests_decided is what each brand learned in the window: the version it kept (kept_ad_id) and what differed. `baker winning-ads search --survived-test` finds the versions brands kept across the library."
+  ];
+}
+var launchesCommand = defineCommand({
+  meta: {
+    name: "launches",
+    description: "What competitors launched lately and what still runs. Start here: baker winning-ads launches --since 7 (every followed brand), or --advertiser adv_1,adv_2"
+  },
+  args: {
+    since: { type: "string", description: "Days to look back, 1-90 (default 7)", required: false },
+    advertiser: { type: "string", description: "Comma list of advertiser ids", required: false },
+    platform: { type: "string", description: "Only this platform: meta|linkedin|tiktok|google", required: false },
+    full: { type: "boolean", description: "List every launch", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const named = splitList(args.advertiser);
+      const params = { since_days: String(args.since ?? 7) };
+      if (named.length > 0) {
+        params.advertiser = named.join(",");
+      }
+      if (args.platform) {
+        params.platform = String(args.platform);
+      }
+      const report = await apiGet("/api/ad-library/launches", params);
+      writeJson({
+        ok: true,
+        data: compactLaunches(report, Boolean(args.full)),
+        hints: launchesHints(report, named.length > 0)
+      });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+
+export {
+  compactLaunches,
+  IDEA_HINT,
+  launchesHints,
+  launchesCommand
+};
+//# sourceMappingURL=chunk-WFUMNDCE.js.map

package/dist/chunk-WFUMNDCE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/winning-ads/launches.ts"],"sourcesContent":["import type { AdvertiserLaunches } from \"@baker/api/ad-library\";\nimport { defineCommand } from \"citty\";\nimport { apiGet } from \"../../client.ts\";\nimport { writeJson } from \"../../output.ts\";\nimport { registerSchema } from \"../../schemas.ts\";\nimport { reportError, splitList } from \"./shared.ts\";\n\nregisterSchema({\n  command: \"winning-ads.launches\",\n  description:\n    'What the brands you follow (or the ones named) launched in the last N days and which of those ads still run, each with its stage (new, testing, killed_early…), and the tests each brand decided in that window (the version kept, what differed). The \"what did competitors launch last week\" report. Compact by default; --full lists every launch.',\n  args: {\n    since: { type: \"number\", description: \"Days to look back, 1-90 (default 7)\", required: false, default: 7 },\n    advertiser: {\n      type: \"string\",\n      description: \"Comma list of advertiser ids instead of every followed brand\",\n      required: false,\n    },\n    platform: { type: \"string\", description: \"Only this platform: meta|linkedin|tiktok|google\", required: false },\n    full: { type: \"boolean\", description: \"List every launch\", required: false, default: false },\n  },\n});\n\nconst COMPACT_LAUNCHES = 10;\n\ntype LaunchesResponse = AdvertiserLaunches & { following_count?: number };\n\nexport function compactLaunches(report: AdvertiserLaunches, full: boolean) {\n  return {\n    since_days: report.since_days,\n    advertisers: report.advertisers.map((b) => ({\n      advertiser_id: b.advertiser_id,\n      label: b.label,\n      launched: b.launched,\n      still_running: b.still_running,\n      launches: (full ? b.launches : b.launches.slice(0, COMPACT_LAUNCHES)).map((l) => ({\n        ad_id: l.ad_id,\n        platform: l.platform,\n        format: l.format,\n        headline: l.headline,\n        first_seen_at: l.first_seen_at,\n        stage: l.stage,\n        idea: l.idea ?? null,\n        ...(full ? { media_url: l.media_url } : {}),\n      })),\n      tests_decided: (b.tests_decided ?? []).map((t) => ({\n        concept: t.concept,\n        versions: t.versions,\n        kept_ad_id: t.winner_ad_id,\n        decided_at: t.decided_at ?? null,\n        what_differed: t.what_differed,\n      })),\n    })),\n  };\n}\n\n/** How to read a launch's idea; the profile says the same. */\nexport const IDEA_HINT =\n  \"Idea: whether each launch was a `new` idea (the first day of its concept), another version of one the brand was still `testing`, or a version built on a `winner` it had already kept. Many launches and no new idea means the brand is iterating on what works, not testing new directions: say so.\";\n\nexport function launchesHints(report: LaunchesResponse, named: boolean): string[] {\n  if (!named && report.following_count === 0) {\n    return [\"You follow no brands yet: `baker winning-ads follow <domain>` adds one, or pass --advertiser <id>.\"];\n  }\n  if (report.advertisers.length === 0) {\n    return [`No launches in the last ${report.since_days} days. Widen the window with --since 30.`];\n  }\n  const withIdeas = report.advertisers.some((b) => b.launches.some((l) => l.idea));\n  return [\n    ...(withIdeas ? [IDEA_HINT] : []),\n    \"Stages: new ≤7 days, testing ≤21 days, proven ≤60 days, evergreen beyond, killed_early = stopped within 2 weeks (a lost test). tests_decided is what each brand learned in the window: the version it kept (kept_ad_id) and what differed. `baker winning-ads search --survived-test` finds the versions brands kept across the library.\",\n  ];\n}\n\nexport const launchesCommand = defineCommand({\n  meta: {\n    name: \"launches\",\n    description:\n      \"What competitors launched lately and what still runs. Start here: baker winning-ads launches --since 7 (every followed brand), or --advertiser adv_1,adv_2\",\n  },\n  args: {\n    since: { type: \"string\", description: \"Days to look back, 1-90 (default 7)\", required: false },\n    advertiser: { type: \"string\", description: \"Comma list of advertiser ids\", required: false },\n    platform: { type: \"string\", description: \"Only this platform: meta|linkedin|tiktok|google\", required: false },\n    full: { type: \"boolean\", description: \"List every launch\", required: false, default: false },\n  },\n  run: async ({ args }) => {\n    try {\n      const named = splitList(args.advertiser as string | undefined);\n      const params: Record<string, string> = { since_days: String(args.since ?? 7) };\n      if (named.length > 0) {\n        params.advertiser = named.join(\",\");\n      }\n      if (args.platform) {\n        params.platform = String(args.platform);\n      }\n      const report = await apiGet<LaunchesResponse>(\"/api/ad-library/launches\", params);\n      writeJson({\n        ok: true,\n        data: compactLaunches(report, Boolean(args.full)),\n        hints: launchesHints(report, named.length > 0),\n      });\n    } catch (err) {\n      reportError(err);\n    }\n  },\n});\n"],"mappings":";;;;;;;;;;;;;AACA,SAAS,qBAAqB;AAM9B,eAAe;AAAA,EACb,SAAS;AAAA,EACT,aACE;AAAA,EACF,MAAM;AAAA,IACJ,OAAO,EAAE,MAAM,UAAU,aAAa,uCAAuC,UAAU,OAAO,SAAS,EAAE;AAAA,IACzG,YAAY;AAAA,MACV,MAAM;AAAA,MACN,aAAa;AAAA,MACb,UAAU;AAAA,IACZ;AAAA,IACA,UAAU,EAAE,MAAM,UAAU,aAAa,mDAAmD,UAAU,MAAM;AAAA,IAC5G,MAAM,EAAE,MAAM,WAAW,aAAa,qBAAqB,UAAU,OAAO,SAAS,MAAM;AAAA,EAC7F;AACF,CAAC;AAED,IAAM,mBAAmB;AAIlB,SAAS,gBAAgB,QAA4B,MAAe;AACzE,SAAO;AAAA,IACL,YAAY,OAAO;AAAA,IACnB,aAAa,OAAO,YAAY,IAAI,CAAC,OAAO;AAAA,MAC1C,eAAe,EAAE;AAAA,MACjB,OAAO,EAAE;AAAA,MACT,UAAU,EAAE;AAAA,MACZ,eAAe,EAAE;AAAA,MACjB,WAAW,OAAO,EAAE,WAAW,EAAE,SAAS,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAAC,OAAO;AAAA,QAChF,OAAO,EAAE;AAAA,QACT,UAAU,EAAE;AAAA,QACZ,QAAQ,EAAE;AAAA,QACV,UAAU,EAAE;AAAA,QACZ,eAAe,EAAE;AAAA,QACjB,OAAO,EAAE;AAAA,QACT,MAAM,EAAE,QAAQ;AAAA,QAChB,GAAI,OAAO,EAAE,WAAW,EAAE,UAAU,IAAI,CAAC;AAAA,MAC3C,EAAE;AAAA,MACF,gBAAgB,EAAE,iBAAiB,CAAC,GAAG,IAAI,CAAC,OAAO;AAAA,QACjD,SAAS,EAAE;AAAA,QACX,UAAU,EAAE;AAAA,QACZ,YAAY,EAAE;AAAA,QACd,YAAY,EAAE,cAAc;AAAA,QAC5B,eAAe,EAAE;AAAA,MACnB,EAAE;AAAA,IACJ,EAAE;AAAA,EACJ;AACF;AAGO,IAAM,YACX;AAEK,SAAS,cAAc,QAA0B,OAA0B;AAChF,MAAI,CAAC,SAAS,OAAO,oBAAoB,GAAG;AAC1C,WAAO,CAAC,oGAAoG;AAAA,EAC9G;AACA,MAAI,OAAO,YAAY,WAAW,GAAG;AACnC,WAAO,CAAC,2BAA2B,OAAO,UAAU,0CAA0C;AAAA,EAChG;AACA,QAAM,YAAY,OAAO,YAAY,KAAK,CAAC,MAAM,EAAE,SAAS,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC;AAC/E,SAAO;AAAA,IACL,GAAI,YAAY,CAAC,SAAS,IAAI,CAAC;AAAA,IAC/B;AAAA,EACF;AACF;AAEO,IAAM,kBAAkB,cAAc;AAAA,EAC3C,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,aACE;AAAA,EACJ;AAAA,EACA,MAAM;AAAA,IACJ,OAAO,EAAE,MAAM,UAAU,aAAa,uCAAuC,UAAU,MAAM;AAAA,IAC7F,YAAY,EAAE,MAAM,UAAU,aAAa,gCAAgC,UAAU,MAAM;AAAA,IAC3F,UAAU,EAAE,MAAM,UAAU,aAAa,mDAAmD,UAAU,MAAM;AAAA,IAC5G,MAAM,EAAE,MAAM,WAAW,aAAa,qBAAqB,UAAU,OAAO,SAAS,MAAM;AAAA,EAC7F;AAAA,EACA,KAAK,OAAO,EAAE,KAAK,MAAM;AACvB,QAAI;AACF,YAAM,QAAQ,UAAU,KAAK,UAAgC;AAC7D,YAAM,SAAiC,EAAE,YAAY,OAAO,KAAK,SAAS,CAAC,EAAE;AAC7E,UAAI,MAAM,SAAS,GAAG;AACpB,eAAO,aAAa,MAAM,KAAK,GAAG;AAAA,MACpC;AACA,UAAI,KAAK,UAAU;AACjB,eAAO,WAAW,OAAO,KAAK,QAAQ;AAAA,MACxC;AACA,YAAM,SAAS,MAAM,OAAyB,4BAA4B,MAAM;AAChF,gBAAU;AAAA,QACR,IAAI;AAAA,QACJ,MAAM,gBAAgB,QAAQ,QAAQ,KAAK,IAAI,CAAC;AAAA,QAChD,OAAO,cAAc,QAAQ,MAAM,SAAS,CAAC;AAAA,MAC/C,CAAC;AAAA,IACH,SAAS,KAAK;AACZ,kBAAY,GAAG;AAAA,IACjB;AAAA,EACF;AACF,CAAC;","names":[]}

package/dist/chunk-WHWNXLTD.js

@@ -0,0 +1,166 @@
+import {
+  HEADLINE_SET_FLOOR,
+  SAME_CLAIM_HELD,
+  TELL_QUESTIONS,
+  copySentences,
+  sameClaimQuestion,
+  tellQuestionsFor
+} from "./chunk-4NZ47VXO.js";
+import {
+  rememberedJev
+} from "./chunk-DUPURL26.js";
+import {
+  holdUnbilledSpend
+} from "./chunk-FEG6MN4H.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-TNOSX3PJ.js";
+import {
+  CAPABILITY_SURFACE_SPECS
+} from "./chunk-UI6BKYQD.js";
+
+// src/commands/capabilities/fix.ts
+function capabilityFix(surface) {
+  const spec = CAPABILITY_SURFACE_SPECS[surface];
+  return {
+    action: `baker capabilities ${surface}`,
+    explanation: `Do not guess another field name. \`baker capabilities ${surface}\` lists every ${spec.label} change with its required and optional fields and the exact values each field accepts, plus what cannot be changed here at all and why. Read it, then either re-stage correctly or tell the user this part is out of reach \u2014 and carry on with the rest of the job either way.`
+  };
+}
+
+// src/commands/ads/boolean-word-positional.ts
+var BOOLEAN_WORD = /^(true|false)$/i;
+function booleanWordPositionalError(args, entity) {
+  const positionals = Array.isArray(args._) ? args._ : [];
+  const word = positionals.find((value2) => typeof value2 === "string" && BOOLEAN_WORD.test(value2));
+  if (word === void 0) {
+    return void 0;
+  }
+  const value = word.toLowerCase();
+  const raised = Object.keys(args).filter((key) => key !== "_" && args[key] === true);
+  const named = raised.length > 0 ? raised.map((flag) => `--${flag}`).join(" or ") : "a boolean flag";
+  const fix = raised.length > 0 ? raised.map((flag) => `--${flag}=${value}`).join(" or ") : `--<flag>=${value}`;
+  const negated = raised.length === 1 && value === "false" ? ` (or --no-${raised[0]})` : "";
+  return `"${word}" was read as the ${entity} target, not as a value for ${named}. A boolean flag written with a space is set to TRUE and the word is dropped \u2014 attach it instead: ${fix}${negated}.`;
+}
+
+// src/commands/ads/copy-hints.ts
+import path from "path";
+
+// src/engine/copy-tells/judge.ts
+var SAMPLE_MAX = 60;
+var sample = (text) => text.length <= SAMPLE_MAX ? text : `${text.slice(0, SAMPLE_MAX)}\u2026`;
+async function judgedCopyTells(input, ask) {
+  const sentences = input.texts.flatMap((t) => copySentences(t));
+  const pairs = (input.headlineSets ?? []).map((set) => set.map((h) => h.trim()).filter(Boolean)).filter((set) => set.length >= HEADLINE_SET_FLOOR).flatMap((set, s) => set.flatMap((a, i) => set.slice(i + 1).map((b) => ({ set: s, a, b }))));
+  const questions = [...sentences.flatMap(tellQuestionsFor), ...pairs.map(({ a, b }) => sameClaimQuestion(a, b))];
+  if (questions.length === 0) return [];
+  const answers = await ask(questions);
+  if (answers === null) return null;
+  const tells = [];
+  TELL_QUESTIONS.forEach((tell, t) => {
+    const hits = sentences.filter((_, s) => (answers[s * TELL_QUESTIONS.length + t] ?? 0) >= tell.threshold);
+    if (hits.length > 0) tells.push({ id: tell.id, count: hits.length, sample: sample(hits[0]?.text ?? "") });
+  });
+  const offset = sentences.length * TELL_QUESTIONS.length;
+  const cycled = pairs.filter((_, p) => (answers[offset + p] ?? 0) >= SAME_CLAIM_HELD);
+  for (const set of new Set(cycled.map((p) => p.set))) {
+    const inSet = cycled.filter((p) => p.set === set);
+    const { a, b } = inSet[0] ?? { a: "", b: "" };
+    tells.push({ id: "synonym-cycling", count: inSet.length, sample: sample(`"${a}" / "${b}"`) });
+  }
+  return tells;
+}
+
+// src/commands/ads/copy-hints.ts
+var COPY_KEYS = /* @__PURE__ */ new Set([
+  "headline",
+  "headlines",
+  "longheadline",
+  "longheadlines",
+  "shortheadline",
+  "shortheadlines",
+  "description",
+  "descriptions",
+  "primarytext",
+  "primarytexts",
+  "message",
+  "messages",
+  "commentary",
+  "body",
+  "bodies",
+  "text",
+  "calltoaction",
+  "linkdescription",
+  "sitelinktext",
+  "callout",
+  "callouts",
+  "introtext"
+]);
+var HEADLINE_SET_KEYS = /* @__PURE__ */ new Set(["headlines", "longheadlines", "shortheadlines"]);
+var MAX_HINTS = 5;
+var SYNONYM_PAIR_FLOOR = 2;
+function asStrings(value) {
+  const one = (v) => {
+    const text = typeof v === "string" ? v : v !== null && typeof v === "object" ? v.text : "";
+    return typeof text === "string" && text.trim() ? text : void 0;
+  };
+  const values = Array.isArray(value) ? value : [value];
+  return values.map(one).filter((v) => v !== void 0);
+}
+function collectCopy(value, depth = 0) {
+  const texts = [];
+  const headlineSets = [];
+  if (depth > 4 || value === null || typeof value !== "object") return { texts, headlineSets };
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const nested = collectCopy(item, depth + 1);
+      texts.push(...nested.texts);
+      headlineSets.push(...nested.headlineSets);
+    }
+    return { texts, headlineSets };
+  }
+  for (const [key, raw] of Object.entries(value)) {
+    const normalized = key.toLowerCase().replace(/[_-]/g, "");
+    const strings = COPY_KEYS.has(normalized) ? asStrings(raw) : [];
+    if (strings.length > 0) {
+      texts.push(...strings);
+      if (HEADLINE_SET_KEYS.has(normalized) && strings.length > 1) headlineSets.push(strings);
+      continue;
+    }
+    const nested = collectCopy(raw, depth + 1);
+    texts.push(...nested.texts);
+    headlineSets.push(...nested.headlineSets);
+  }
+  return { texts, headlineSets };
+}
+function hintFor(tell) {
+  if (tell.id === "synonym-cycling") {
+    return `AI COPY TELL \u2014 ${tell.count} headline pairs are the same claim reworded (${tell.sample}). A cycled set gives the auction nothing to choose between: make each headline a different claim, not a different verb.`;
+  }
+  return `AI COPY TELL (${tell.id}) \u2014 "${tell.sample}". This construction reads as machine-written; rewrite it as a plain, specific claim before publishing.`;
+}
+async function adCopyHints(payload, ask) {
+  const { texts, headlineSets } = collectCopy(payload);
+  if (texts.length === 0) return [];
+  const cacheDir = path.join(findWorkspaceRoot(process.cwd()) ?? process.cwd(), "canvas", ".cache");
+  const spent = [];
+  const judged = await judgedCopyTells(
+    { texts: texts.flatMap((t) => t.split("\n")), headlineSets },
+    ask ?? rememberedJev(path.join(cacheDir, "copy-tells.json"), (u) => spent.push(u))
+  ).catch(() => null);
+  await holdUnbilledSpend(cacheDir, spent).catch(() => void 0);
+  const cycled = (judged ?? []).filter((t) => t.id === "synonym-cycling" && t.count >= SYNONYM_PAIR_FLOOR).sort((a, b) => b.count - a.count).slice(0, 1);
+  const tells = [...cycled, ...(judged ?? []).filter((t) => t.id !== "synonym-cycling")];
+  tells.sort(
+    (a, b) => (b.id === "synonym-cycling" ? 1 : 0) - (a.id === "synonym-cycling" ? 1 : 0) || b.count - a.count
+  );
+  return tells.slice(0, MAX_HINTS).map(hintFor);
+}
+
+export {
+  capabilityFix,
+  booleanWordPositionalError,
+  adCopyHints
+};
+//# sourceMappingURL=chunk-WHWNXLTD.js.map

package/dist/chunk-WHWNXLTD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/capabilities/fix.ts","../src/commands/ads/boolean-word-positional.ts","../src/commands/ads/copy-hints.ts","../src/engine/copy-tells/judge.ts"],"sourcesContent":["import type { CapabilitySurfaceId } from \"@baker/api/capabilities\";\nimport { CAPABILITY_SURFACE_SPECS } from \"@baker/api/capabilities\";\n\n/**\n * A rejected change should say where the real contract is.\n *\n * The expensive version of \"this field is not valid\" is an agent trying four\n * spellings of a field that never existed, staging a bogus op, and cleaning it\n * up again — several turns, none of them work. The validation message already\n * names what was wrong with THIS attempt; this names the one call that lists\n * every field the change accepts and every value each one takes, so the next\n * attempt is informed rather than another guess.\n */\nexport function capabilityFix(surface: CapabilitySurfaceId): { action: string; explanation: string } {\n  const spec = CAPABILITY_SURFACE_SPECS[surface];\n  return {\n    action: `baker capabilities ${surface}`,\n    explanation:\n      `Do not guess another field name. \\`baker capabilities ${surface}\\` lists every ${spec.label} change with its ` +\n      \"required and optional fields and the exact values each field accepts, plus what cannot be changed here at all \" +\n      \"and why. Read it, then either re-stage correctly or tell the user this part is out of reach — and carry on \" +\n      \"with the rest of the job either way.\",\n  };\n}\n","/**\n * `--flag false` — the natural way to type a negation — is a citty trap, not a typo we can honour:\n * a boolean flag written with a space parses as the flag set to **TRUE** plus a stray positional\n * nobody consumes. The word does the OPPOSITE of what was typed and nothing fails, because the\n * target still resolves and the command still reports \"staged\". No layer downstream can catch it —\n * an inverted boolean is a valid op — so it has to be caught where the positionals are read.\n *\n * This is the same rule on every ad surface (it is citty's parse, not a platform's), but each\n * surface owns its own error envelope, so this returns the message and the caller fails with it.\n */\n\nconst BOOLEAN_WORD = /^(true|false)$/i;\n\n/**\n * The refusal message for a bare `true`/`false` sitting in the positionals, or `undefined` when\n * there is none. `entity` is the surface's own noun for what the positional addresses (\"campaign\",\n * \"ad set\", …), so the message reads as that command's vocabulary.\n */\nexport function booleanWordPositionalError(args: Record<string, unknown>, entity: string): string | undefined {\n  const positionals = Array.isArray(args._) ? args._ : [];\n  const word = positionals.find((value): value is string => typeof value === \"string\" && BOOLEAN_WORD.test(value));\n  if (word === undefined) {\n    return undefined;\n  }\n  const value = word.toLowerCase();\n  // Every flag citty just set to true, so the fix is copy-pasteable. Which one the word was meant for\n  // is unknowable from parsed args — it need not even follow that flag on the command line — so with\n  // several raised we list them all rather than inventing a single culprit the user never typed.\n  const raised = Object.keys(args).filter((key) => key !== \"_\" && args[key] === true);\n  const named = raised.length > 0 ? raised.map((flag) => `--${flag}`).join(\" or \") : \"a boolean flag\";\n  const fix = raised.length > 0 ? raised.map((flag) => `--${flag}=${value}`).join(\" or \") : `--<flag>=${value}`;\n  const negated = raised.length === 1 && value === \"false\" ? ` (or --no-${raised[0]})` : \"\";\n  return `\"${word}\" was read as the ${entity} target, not as a value for ${named}. A boolean flag written with a space is set to TRUE and the word is dropped — attach it instead: ${fix}${negated}.`;\n}\n","/**\n * AI copy tells on staged ad copy → `hints[]`.\n *\n * Ad text is the surface where a tell costs real money and the one place we had\n * no copy check at all: staging validated character limits and policy, never\n * whether the words read like a model wrote them.\n *\n * ADVISORY BY CONSTRUCTION. These are hints, never errors — an ad refused over a\n * fallible prose heuristic costs more than a tell that ships, and the agent can\n * act on a hint in the same turn. Nothing here can fail a staged write.\n *\n * Thresholds differ from the landing gate on purpose. A landing needs a CLUSTER\n * before a tell means anything (`COPY_TELL_GATES`); a 30-character headline has\n * no room for a cluster, so one occurrence is the signal. The exclusion list\n * below is where most of the judgment lives.\n *\n * The tells that read the words are asked of the decision model, in whatever\n * language the ad is written; when it cannot answer, nothing is reported rather\n * than a guess.\n */\n\nimport path from \"node:path\";\nimport type { CopyTell } from \"../../engine/copy-tells/detect.ts\";\nimport { judgedCopyTells } from \"../../engine/copy-tells/judge.ts\";\nimport { type AskNouls, rememberedJev } from \"../../engine/lib/remembered-nouls.ts\";\nimport type { ReviewUsage } from \"../../engine/nodes/local/lib/render-review.ts\";\nimport { findWorkspaceRoot } from \"../canvas/normalize-paths.ts\";\nimport { holdUnbilledSpend } from \"../canvas/unbilled-spend.ts\";\n\n/*\n * The tells that are a shape (`structuralCopyTells`) do not apply to ad copy, and\n * none is hinted. Each is a real convention in this medium, so reporting it would\n * train the agent to ignore hints:\n *   - `title-case-heading` — English search ads are conventionally Title Case.\n *   - `staccato-drama` — \"Compara. Ahorra. Cambia.\" is ad rhythm, not drama.\n *   - `emoji` — deliberate and effective in Meta and LinkedIn primary text.\n *   - `curly-quote` — inserted automatically by every editor copy is pasted from.\n *   - `inline-header-list` — a markdown shape that ad fields cannot hold.\n */\n\n/**\n * Payload keys whose values are copy a human will read in the ad. Every platform\n * names its primary text differently in `@baker/api` — Meta stages it as\n * `message`, LinkedIn as `commentary` — so the concept appears here under each\n * of its contract names, not under one invented one.\n */\nconst COPY_KEYS = new Set([\n  \"headline\",\n  \"headlines\",\n  \"longheadline\",\n  \"longheadlines\",\n  \"shortheadline\",\n  \"shortheadlines\",\n  \"description\",\n  \"descriptions\",\n  \"primarytext\",\n  \"primarytexts\",\n  \"message\",\n  \"messages\",\n  \"commentary\",\n  \"body\",\n  \"bodies\",\n  \"text\",\n  \"calltoaction\",\n  \"linkdescription\",\n  \"sitelinktext\",\n  \"callout\",\n  \"callouts\",\n  \"introtext\",\n]);\n\n/** Keys holding a SET of headlines, where synonym cycling is meaningful. */\nconst HEADLINE_SET_KEYS = new Set([\"headlines\", \"longheadlines\", \"shortheadlines\"]);\n\n/**\n * At most this many hints, so copy advice never crowds out the staging result.\n *\n * Five, not three: a heavily model-written ad routinely carries six tells, and a\n * cap of three showed the agent half the diagnosis. Since it already has the copy\n * in front of it, fixing six constructions in one pass is cheaper than three\n * re-stagings that each reveal the next batch.\n */\nconst MAX_HINTS = 5;\n/** Two near-duplicate pairs; one pair in a 15-headline RSA is not a pattern. */\nconst SYNONYM_PAIR_FLOOR = 2;\n\n/**\n * The copy under a copy key, whether it is a plain string or a Google text\n * asset. Google stages EVERY ad text as `{ text, pinnedField? }`\n * (`adTextAssetSchema` in `@baker/api/ads-google`), so reading only strings here\n * would skip the whole Google surface — headlines, descriptions, long headline.\n */\nfunction asStrings(value: unknown): string[] {\n  const one = (v: unknown): string | undefined => {\n    const text = typeof v === \"string\" ? v : v !== null && typeof v === \"object\" ? (v as { text?: unknown }).text : \"\";\n    return typeof text === \"string\" && text.trim() ? text : undefined;\n  };\n  const values = Array.isArray(value) ? value : [value];\n  return values.map(one).filter((v): v is string => v !== undefined);\n}\n\n/** Walk a staged-op payload of unknown shape and pull out the human-readable\n * copy fields plus any headline sets. Depth-limited — payloads are shallow, and\n * an unbounded walk on a hostile shape is a hang, not a hint. */\nfunction collectCopy(value: unknown, depth = 0): { texts: string[]; headlineSets: string[][] } {\n  const texts: string[] = [];\n  const headlineSets: string[][] = [];\n  if (depth > 4 || value === null || typeof value !== \"object\") return { texts, headlineSets };\n\n  if (Array.isArray(value)) {\n    for (const item of value) {\n      const nested = collectCopy(item, depth + 1);\n      texts.push(...nested.texts);\n      headlineSets.push(...nested.headlineSets);\n    }\n    return { texts, headlineSets };\n  }\n\n  for (const [key, raw] of Object.entries(value as Record<string, unknown>)) {\n    const normalized = key.toLowerCase().replace(/[_-]/g, \"\");\n    const strings = COPY_KEYS.has(normalized) ? asStrings(raw) : [];\n    if (strings.length > 0) {\n      texts.push(...strings);\n      if (HEADLINE_SET_KEYS.has(normalized) && strings.length > 1) headlineSets.push(strings);\n      continue;\n    }\n    // A copy key holding neither a string nor a text asset (`call_to_action`)\n    // still gets walked — a matched key must never swallow the subtree.\n    const nested = collectCopy(raw, depth + 1);\n    texts.push(...nested.texts);\n    headlineSets.push(...nested.headlineSets);\n  }\n  return { texts, headlineSets };\n}\n\nfunction hintFor(tell: CopyTell): string {\n  if (tell.id === \"synonym-cycling\") {\n    return `AI COPY TELL — ${tell.count} headline pairs are the same claim reworded (${tell.sample}). A cycled set gives the auction nothing to choose between: make each headline a different claim, not a different verb.`;\n  }\n  return `AI COPY TELL (${tell.id}) — \"${tell.sample}\". This construction reads as machine-written; rewrite it as a plain, specific claim before publishing.`;\n}\n\n/**\n * Inspect a staged ad-copy payload and return advisory hints about AI writing\n * tells. Never throws; returns `[]` when the copy reads clean or the payload\n * carries no copy at all. `ask` is the decision model (the real one, its answers\n * kept in the workspace's canvas cache and its spend billed with the next run,\n * unless given).\n */\nexport async function adCopyHints(payload: unknown, ask?: AskNouls): Promise<string[]> {\n  const { texts, headlineSets } = collectCopy(payload);\n  if (texts.length === 0) return [];\n\n  const cacheDir = path.join(findWorkspaceRoot(process.cwd()) ?? process.cwd(), \"canvas\", \".cache\");\n  const spent: ReviewUsage[] = [];\n  // A line break in ad text is the author's, never a wrap: each line is read on its own.\n  const judged = await judgedCopyTells(\n    { texts: texts.flatMap((t) => t.split(\"\\n\")), headlineSets },\n    ask ?? rememberedJev(path.join(cacheDir, \"copy-tells.json\"), (u) => spent.push(u)),\n  ).catch(() => null);\n  await holdUnbilledSpend(cacheDir, spent).catch(() => undefined);\n\n  // The floor is per headline set (one per ad); only the most cycled set is hinted.\n  const cycled = (judged ?? [])\n    .filter((t) => t.id === \"synonym-cycling\" && t.count >= SYNONYM_PAIR_FLOOR)\n    .sort((a, b) => b.count - a.count)\n    .slice(0, 1);\n  const tells: CopyTell[] = [...cycled, ...(judged ?? []).filter((t) => t.id !== \"synonym-cycling\")];\n\n  // Loudest first: the cycled-headline finding is a set-level defect, and the\n  // rest sort by how often the tell fired.\n  tells.sort(\n    (a, b) => (b.id === \"synonym-cycling\" ? 1 : 0) - (a.id === \"synonym-cycling\" ? 1 : 0) || b.count - a.count,\n  );\n  return tells.slice(0, MAX_HINTS).map(hintFor);\n}\n","/**\n * The AI copy tells in a piece of copy that are a reading of its words, and synonym cycling in a\n * set of headlines, asked of the decision model (Jev) in one fanned-out set of requests, in\n * whatever language the copy is written. Raw counts, like `structuralCopyTells`: the caller gates.\n */\nimport type { AskNouls } from \"../lib/remembered-nouls.ts\";\nimport type { CopyTell } from \"./detect.ts\";\nimport { HEADLINE_SET_FLOOR } from \"./patterns.ts\";\nimport { SAME_CLAIM_HELD, sameClaimQuestion, TELL_QUESTIONS, tellQuestionsFor } from \"./questions.ts\";\nimport { copySentences } from \"./sentences.ts\";\n\nconst SAMPLE_MAX = 60;\nconst sample = (text: string) => (text.length <= SAMPLE_MAX ? text : `${text.slice(0, SAMPLE_MAX)}…`);\n\n/**\n * Every judged tell in `texts` (one count per sentence that carries it) and, for each headline set\n * of at least `HEADLINE_SET_FLOOR`, one `synonym-cycling` tell counting that set's pairs that are\n * one claim reworded. Null when the model could not answer: the caller reports nothing rather than\n * guess.\n */\nexport async function judgedCopyTells(\n  input: { texts: readonly string[]; headlineSets?: ReadonlyArray<readonly string[]> },\n  ask: AskNouls,\n): Promise<CopyTell[] | null> {\n  const sentences = input.texts.flatMap((t) => copySentences(t));\n  const pairs = (input.headlineSets ?? [])\n    .map((set) => set.map((h) => h.trim()).filter(Boolean))\n    .filter((set) => set.length >= HEADLINE_SET_FLOOR)\n    .flatMap((set, s) => set.flatMap((a, i) => set.slice(i + 1).map((b) => ({ set: s, a, b }))));\n  const questions = [...sentences.flatMap(tellQuestionsFor), ...pairs.map(({ a, b }) => sameClaimQuestion(a, b))];\n  if (questions.length === 0) return [];\n  const answers = await ask(questions);\n  if (answers === null) return null;\n\n  const tells: CopyTell[] = [];\n  TELL_QUESTIONS.forEach((tell, t) => {\n    const hits = sentences.filter((_, s) => (answers[s * TELL_QUESTIONS.length + t] ?? 0) >= tell.threshold);\n    if (hits.length > 0) tells.push({ id: tell.id, count: hits.length, sample: sample(hits[0]?.text ?? \"\") });\n  });\n  const offset = sentences.length * TELL_QUESTIONS.length;\n  const cycled = pairs.filter((_, p) => (answers[offset + p] ?? 0) >= SAME_CLAIM_HELD);\n  for (const set of new Set(cycled.map((p) => p.set))) {\n    const inSet = cycled.filter((p) => p.set === set);\n    const { a, b } = inSet[0] ?? { a: \"\", b: \"\" };\n    tells.push({ id: \"synonym-cycling\", count: inSet.length, sample: sample(`\"${a}\" / \"${b}\"`) });\n  }\n  return tells;\n}\n"],"mappings":"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","names":["value"]}

package/dist/chunk-WN4KX7GE.js

@@ -0,0 +1,25 @@
+// src/commands/avatars/wait.ts
+var WAIT_TIMEOUT_MS = 9e4;
+var WAIT_INTERVAL_MS = 3e3;
+function shouldKeepWaiting(avatar, elapsedMs) {
+  if (avatar.status === "ready") return { done: true, reason: "ready" };
+  if (avatar.status === "error" || avatar.status === "archived") return { done: true, reason: "settled" };
+  if (avatar.needsFace) return { done: true, reason: "needs-face" };
+  if (elapsedMs >= WAIT_TIMEOUT_MS) return { done: false, reason: "expired" };
+  return { done: false, reason: "building" };
+}
+async function waitForSheet(first, read, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
+  const startedAt = Date.now();
+  let latest = first;
+  while (!shouldKeepWaiting(latest, Date.now() - startedAt).done) {
+    if (shouldKeepWaiting(latest, Date.now() - startedAt).reason === "expired") return latest;
+    await sleep(WAIT_INTERVAL_MS);
+    latest = await read();
+  }
+  return latest;
+}
+
+export {
+  waitForSheet
+};
+//# sourceMappingURL=chunk-WN4KX7GE.js.map

package/dist/chunk-WN4KX7GE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/avatars/wait.ts"],"sourcesContent":["import type { AvatarStatus } from \"@baker/api\";\n\n/**\n * Waiting for an avatar's identity sheet, inside the command rather than in the agent.\n *\n * The sheet is a ~30s render, and the agent is told never to sleep on it — right, because\n * a turn spent standing still is a turn the user watches do nothing. But when the only\n * work left DEPENDS on that avatar, \"do the next piece of work\" names work that does not\n * exist, and the observed turn simply ended: the user had to come back and say \"ya está\n * lista\" for the clip to be made.\n *\n * A command that blocks internally is the sanctioned shape for this — it has its own\n * deadline and returns the moment the thing is ready, which a polling loop written by the\n * agent does neither of.\n */\n\n/** How long to keep asking before giving up. Twice the sheet's usual render. */\nexport const WAIT_TIMEOUT_MS = 90_000;\n/** Gap between reads. Short enough to return promptly, long enough not to hammer. */\nexport const WAIT_INTERVAL_MS = 3_000;\n\nexport type WaitDecision =\n  | { done: true; reason: \"ready\" | \"settled\" | \"needs-face\" }\n  | { done: false; reason: \"building\" | \"expired\" };\n\n/** Just enough of an avatar to know whether waiting on it can ever end. */\nexport interface WaitSubject {\n  status: AvatarStatus;\n  /**\n   * The build is parked on a face the user has not picked yet.\n   *\n   * `generating` normally means a render is running. This is the one case where it\n   * does not: the casting portraits are in front of the user and nothing starts until\n   * they answer.\n   */\n  needsFace?: boolean;\n}\n\n/**\n * Whether to stop waiting on this avatar, given how long we have waited.\n *\n * `error` and `archived` stop it too: both are settled states, and waiting out the\n * deadline for one of them would burn 90 seconds to learn what the first read said.\n *\n * So does an avatar waiting on its face. Nothing is rendering, so the only thing that\n * can happen here is the deadline expiring — and it is the user's own turn to act, not\n * the agent's. Observed: an agent blocked the full 90 seconds twice, concluded the\n * avatar was broken, and deleted the one the user was at that moment picking a face for.\n */\nexport function shouldKeepWaiting(avatar: WaitSubject, elapsedMs: number): WaitDecision {\n  if (avatar.status === \"ready\") return { done: true, reason: \"ready\" };\n  if (avatar.status === \"error\" || avatar.status === \"archived\") return { done: true, reason: \"settled\" };\n  if (avatar.needsFace) return { done: true, reason: \"needs-face\" };\n  if (elapsedMs >= WAIT_TIMEOUT_MS) return { done: false, reason: \"expired\" };\n  return { done: false, reason: \"building\" };\n}\n\n/**\n * Re-reads the avatar until its sheet settles, or the deadline passes.\n *\n * Returns whatever the last read said either way — an expired wait is not a failure, it\n * is a slow render, and the caller's own hints already say what a still-building avatar\n * can and cannot be used for.\n */\nexport async function waitForSheet<T extends WaitSubject>(\n  first: T,\n  read: () => Promise<T>,\n  sleep: (ms: number) => Promise<void> = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),\n): Promise<T> {\n  const startedAt = Date.now();\n  let latest = first;\n  while (!shouldKeepWaiting(latest, Date.now() - startedAt).done) {\n    if (shouldKeepWaiting(latest, Date.now() - startedAt).reason === \"expired\") return latest;\n    await sleep(WAIT_INTERVAL_MS);\n    latest = await read();\n  }\n  return latest;\n}\n"],"mappings":";AAiBO,IAAM,kBAAkB;AAExB,IAAM,mBAAmB;AA8BzB,SAAS,kBAAkB,QAAqB,WAAiC;AACtF,MAAI,OAAO,WAAW,QAAS,QAAO,EAAE,MAAM,MAAM,QAAQ,QAAQ;AACpE,MAAI,OAAO,WAAW,WAAW,OAAO,WAAW,WAAY,QAAO,EAAE,MAAM,MAAM,QAAQ,UAAU;AACtG,MAAI,OAAO,UAAW,QAAO,EAAE,MAAM,MAAM,QAAQ,aAAa;AAChE,MAAI,aAAa,gBAAiB,QAAO,EAAE,MAAM,OAAO,QAAQ,UAAU;AAC1E,SAAO,EAAE,MAAM,OAAO,QAAQ,WAAW;AAC3C;AASA,eAAsB,aACpB,OACA,MACA,QAAuC,CAAC,OAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,EAAE,CAAC,GACnF;AACZ,QAAM,YAAY,KAAK,IAAI;AAC3B,MAAI,SAAS;AACb,SAAO,CAAC,kBAAkB,QAAQ,KAAK,IAAI,IAAI,SAAS,EAAE,MAAM;AAC9D,QAAI,kBAAkB,QAAQ,KAAK,IAAI,IAAI,SAAS,EAAE,WAAW,UAAW,QAAO;AACnF,UAAM,MAAM,gBAAgB;AAC5B,aAAS,MAAM,KAAK;AAAA,EACtB;AACA,SAAO;AACT;","names":[]}

package/dist/chunk-XIY7P54H.js

@@ -0,0 +1,84 @@
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-CUL3VB4L.js";
+
+// src/commands/videos/api.ts
+import { readFile } from "fs/promises";
+import { basename, extname } from "path";
+var videoProcessingTimeoutMs = 18e4;
+var videoReadyPollIntervalMs = 3e3;
+var mimeMap = {
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm",
+  ".avi": "video/x-msvideo",
+  ".mkv": "video/x-matroska"
+};
+var defaultVideoApiDeps = {
+  readFile,
+  post: apiPost,
+  get: apiGet,
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  putFile: async (url, contentType, body) => {
+    const response = await fetch(url, { method: "PUT", headers: { "Content-Type": contentType }, body });
+    if (!response.ok) {
+      throw new ApiError("INTERNAL_ERROR", `Mux upload failed: HTTP ${response.status} ${response.statusText}`);
+    }
+  }
+};
+function isVideoFile(filePath) {
+  return mimeMap[extname(filePath).toLowerCase()] !== void 0;
+}
+function detectVideoContentType(filePath, opts = {}) {
+  const ext = extname(filePath).toLowerCase();
+  const contentType = mimeMap[ext];
+  if (!contentType || opts.allowedContentTypes && !opts.allowedContentTypes.includes(contentType)) {
+    throw new ApiError(
+      "VALIDATION_ERROR",
+      opts.unsupportedMessage ?? `Cannot detect content type for extension "${ext}". Use --content-type.`
+    );
+  }
+  return contentType;
+}
+async function uploadLocalVideo(args, deps = defaultVideoApiDeps) {
+  const { uploadUrl, videoId } = await deps.post("/api/videos/upload", {
+    originalFilename: basename(args.file),
+    descriptionContext: args.descriptionContext
+  });
+  await deps.putFile(uploadUrl, args.contentType, await deps.readFile(args.file));
+  return { videoId };
+}
+var PLAYABLE_STATUSES = /* @__PURE__ */ new Set(["uploaded", "processing", "ready"]);
+async function waitForPlayableVideo(deps, videoId, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? videoProcessingTimeoutMs;
+  const pollIntervalMs = opts.pollIntervalMs ?? videoReadyPollIntervalMs;
+  const deadline = Date.now() + timeoutMs;
+  let lastStatus = "unknown";
+  while (Date.now() <= deadline) {
+    const video = await deps.get("/api/videos/get", { id: videoId });
+    lastStatus = video.status;
+    if (video.muxPlaybackId && PLAYABLE_STATUSES.has(video.status)) {
+      return video;
+    }
+    if (video.status === "error") {
+      throw new ApiError(
+        "INTERNAL_ERROR",
+        "The video library could not process this file. Export it again as an MP4 (H.264) and retry."
+      );
+    }
+    await deps.sleep(pollIntervalMs);
+  }
+  throw new ApiError("TIMEOUT", `Video was not playable before timeout; last status: ${lastStatus}`);
+}
+
+export {
+  videoProcessingTimeoutMs,
+  defaultVideoApiDeps,
+  isVideoFile,
+  detectVideoContentType,
+  uploadLocalVideo,
+  waitForPlayableVideo
+};
+//# sourceMappingURL=chunk-XIY7P54H.js.map

package/dist/chunk-XIY7P54H.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/videos/api.ts"],"sourcesContent":["import type { Buffer } from \"node:buffer\";\nimport { readFile } from \"node:fs/promises\";\nimport { basename, extname } from \"node:path\";\nimport type { VideosGetResponse, VideosUploadResponse } from \"@baker/api\";\nimport { ApiError, apiGet, apiPost } from \"../../client.ts\";\n\n/** Mux usually has a short render playable within a minute; this bounds the wait. */\nexport const videoProcessingTimeoutMs = 180_000;\nconst videoReadyPollIntervalMs = 3_000;\n\nconst mimeMap: Record<string, string> = {\n  \".mp4\": \"video/mp4\",\n  \".mov\": \"video/quicktime\",\n  \".webm\": \"video/webm\",\n  \".avi\": \"video/x-msvideo\",\n  \".mkv\": \"video/x-matroska\",\n};\n\nexport type VideoApiDeps = {\n  readFile: (path: string) => Promise<Buffer<ArrayBuffer>>;\n  post: typeof apiPost;\n  get: typeof apiGet;\n  sleep: (ms: number) => Promise<void>;\n  /** PUT the bytes to the Mux direct-upload URL. */\n  putFile: (url: string, contentType: string, body: Buffer<ArrayBuffer>) => Promise<void>;\n};\n\nexport const defaultVideoApiDeps: VideoApiDeps = {\n  readFile,\n  post: apiPost,\n  get: apiGet,\n  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),\n  putFile: async (url, contentType, body) => {\n    const response = await fetch(url, { method: \"PUT\", headers: { \"Content-Type\": contentType }, body });\n    if (!response.ok) {\n      throw new ApiError(\"INTERNAL_ERROR\", `Mux upload failed: HTTP ${response.status} ${response.statusText}`);\n    }\n  },\n};\n\nexport function isVideoFile(filePath: string): boolean {\n  return mimeMap[extname(filePath).toLowerCase()] !== undefined;\n}\n\nexport function detectVideoContentType(\n  filePath: string,\n  opts: { allowedContentTypes?: readonly string[]; unsupportedMessage?: string } = {},\n): string {\n  const ext = extname(filePath).toLowerCase();\n  const contentType = mimeMap[ext];\n  if (!contentType || (opts.allowedContentTypes && !opts.allowedContentTypes.includes(contentType))) {\n    throw new ApiError(\n      \"VALIDATION_ERROR\",\n      opts.unsupportedMessage ?? `Cannot detect content type for extension \"${ext}\". Use --content-type.`,\n    );\n  }\n  return contentType;\n}\n\n/**\n * Add a local video file to the company's video library: a Mux direct-upload\n * URL from Baker, then the bytes straight to Mux. The filename travels along,\n * since the bytes never pass through Baker and it is often the only statement\n * of intent there is.\n */\nexport async function uploadLocalVideo(\n  args: { file: string; contentType: string; descriptionContext?: string },\n  deps: VideoApiDeps = defaultVideoApiDeps,\n): Promise<{ videoId: string }> {\n  const { uploadUrl, videoId } = await deps.post<VideosUploadResponse>(\"/api/videos/upload\", {\n    originalFilename: basename(args.file),\n    descriptionContext: args.descriptionContext,\n  });\n  await deps.putFile(uploadUrl, args.contentType, await deps.readFile(args.file));\n  return { videoId };\n}\n\nconst PLAYABLE_STATUSES: ReadonlySet<string> = new Set([\"uploaded\", \"processing\", \"ready\"]);\n\n/**\n * Wait until Baker can play the video: Mux has produced its playback id. Its\n * description (transcript, analysis) keeps running afterwards, and nothing\n * that saves or ships the video needs to wait for that.\n */\nexport async function waitForPlayableVideo(\n  deps: VideoApiDeps,\n  videoId: string,\n  opts: { timeoutMs?: number; pollIntervalMs?: number } = {},\n): Promise<VideosGetResponse> {\n  const timeoutMs = opts.timeoutMs ?? videoProcessingTimeoutMs;\n  const pollIntervalMs = opts.pollIntervalMs ?? videoReadyPollIntervalMs;\n  const deadline = Date.now() + timeoutMs;\n  let lastStatus = \"unknown\";\n  while (Date.now() <= deadline) {\n    const video = await deps.get<VideosGetResponse>(\"/api/videos/get\", { id: videoId });\n    lastStatus = video.status;\n    if (video.muxPlaybackId && PLAYABLE_STATUSES.has(video.status)) {\n      return video;\n    }\n    if (video.status === \"error\") {\n      throw new ApiError(\n        \"INTERNAL_ERROR\",\n        \"The video library could not process this file. Export it again as an MP4 (H.264) and retry.\",\n      );\n    }\n    await deps.sleep(pollIntervalMs);\n  }\n  throw new ApiError(\"TIMEOUT\", `Video was not playable before timeout; last status: ${lastStatus}`);\n}\n"],"mappings":";;;;;;;AACA,SAAS,gBAAgB;AACzB,SAAS,UAAU,eAAe;AAK3B,IAAM,2BAA2B;AACxC,IAAM,2BAA2B;AAEjC,IAAM,UAAkC;AAAA,EACtC,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,QAAQ;AACV;AAWO,IAAM,sBAAoC;AAAA,EAC/C;AAAA,EACA,MAAM;AAAA,EACN,KAAK;AAAA,EACL,OAAO,CAAC,OAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,EAAE,CAAC;AAAA,EAC/D,SAAS,OAAO,KAAK,aAAa,SAAS;AACzC,UAAM,WAAW,MAAM,MAAM,KAAK,EAAE,QAAQ,OAAO,SAAS,EAAE,gBAAgB,YAAY,GAAG,KAAK,CAAC;AACnG,QAAI,CAAC,SAAS,IAAI;AAChB,YAAM,IAAI,SAAS,kBAAkB,2BAA2B,SAAS,MAAM,IAAI,SAAS,UAAU,EAAE;AAAA,IAC1G;AAAA,EACF;AACF;AAEO,SAAS,YAAY,UAA2B;AACrD,SAAO,QAAQ,QAAQ,QAAQ,EAAE,YAAY,CAAC,MAAM;AACtD;AAEO,SAAS,uBACd,UACA,OAAiF,CAAC,GAC1E;AACR,QAAM,MAAM,QAAQ,QAAQ,EAAE,YAAY;AAC1C,QAAM,cAAc,QAAQ,GAAG;AAC/B,MAAI,CAAC,eAAgB,KAAK,uBAAuB,CAAC,KAAK,oBAAoB,SAAS,WAAW,GAAI;AACjG,UAAM,IAAI;AAAA,MACR;AAAA,MACA,KAAK,sBAAsB,6CAA6C,GAAG;AAAA,IAC7E;AAAA,EACF;AACA,SAAO;AACT;AAQA,eAAsB,iBACpB,MACA,OAAqB,qBACS;AAC9B,QAAM,EAAE,WAAW,QAAQ,IAAI,MAAM,KAAK,KAA2B,sBAAsB;AAAA,IACzF,kBAAkB,SAAS,KAAK,IAAI;AAAA,IACpC,oBAAoB,KAAK;AAAA,EAC3B,CAAC;AACD,QAAM,KAAK,QAAQ,WAAW,KAAK,aAAa,MAAM,KAAK,SAAS,KAAK,IAAI,CAAC;AAC9E,SAAO,EAAE,QAAQ;AACnB;AAEA,IAAM,oBAAyC,oBAAI,IAAI,CAAC,YAAY,cAAc,OAAO,CAAC;AAO1F,eAAsB,qBACpB,MACA,SACA,OAAwD,CAAC,GAC7B;AAC5B,QAAM,YAAY,KAAK,aAAa;AACpC,QAAM,iBAAiB,KAAK,kBAAkB;AAC9C,QAAM,WAAW,KAAK,IAAI,IAAI;AAC9B,MAAI,aAAa;AACjB,SAAO,KAAK,IAAI,KAAK,UAAU;AAC7B,UAAM,QAAQ,MAAM,KAAK,IAAuB,mBAAmB,EAAE,IAAI,QAAQ,CAAC;AAClF,iBAAa,MAAM;AACnB,QAAI,MAAM,iBAAiB,kBAAkB,IAAI,MAAM,MAAM,GAAG;AAC9D,aAAO;AAAA,IACT;AACA,QAAI,MAAM,WAAW,SAAS;AAC5B,YAAM,IAAI;AAAA,QACR;AAAA,QACA;AAAA,MACF;AAAA,IACF;AACA,UAAM,KAAK,MAAM,cAAc;AAAA,EACjC;AACA,QAAM,IAAI,SAAS,WAAW,uDAAuD,UAAU,EAAE;AACnG;","names":[]}