@koda-sl/baker-cli 0.385.0-dev.ec7b0e42b → 0.385.0-dev.f7ef4c7e1

package/dist/chunk-25E6SC3F.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/videos/ingest.ts","../src/lib/streamUpload.ts"],"sourcesContent":["import { mkdtemp, rm, stat } from \"node:fs/promises\";\nimport { tmpdir } from \"node:os\";\nimport path from \"node:path\";\nimport { type VideosIngestRequest, type VideosIngestResponse, videosIngestRequestSchema } from \"@baker/api\";\nimport { isProxyFailure } from \"@baker/proxy\";\nimport { defineCommand } from \"citty\";\nimport { ApiError, apiPost } from \"../../client.ts\";\nimport { captureVimeoCookie } from \"../../env.ts\";\nimport { hashFile, putFileStreamed } from \"../../lib/streamUpload.ts\";\nimport { isVimeoAuthFailure } from \"../../lib/vimeoCookie.ts\";\nimport {\n  canonicalUrl,\n  durationSeconds,\n  isAudioOnly,\n  probeYtDlp,\n  runYtDlp,\n  YtDlpError,\n  type YtDlpInfo,\n} from \"../../lib/ytDlp.ts\";\nimport { ytDlpBlockSignal } from \"../../lib/ytDlpSignal.ts\";\nimport { writeJson } from \"../../output.ts\";\nimport { registerSchema } from \"../../schemas.ts\";\nimport {\n  directDedupeKey,\n  downloadTimeoutMs,\n  isDirectMediaUrl,\n  isDrmProtected,\n  isRegionBlocked,\n  isToolingOrBlockFailure,\n  MAX_VIDEO_INGEST_BYTES,\n  MAX_VIDEO_INGEST_SECONDS,\n  refuseByDuration,\n  resolveIngestSource,\n  worthDownloadingInstead,\n} from \"./ingestUrl.ts\";\n\nregisterSchema({\n  command: \"videos.ingest\",\n  description: \"Add a video to the library from a URL — a direct file, or a YouTube/TikTok/Vimeo page.\",\n  args: {\n    url: { type: \"string\", description: \"Video URL (direct file or a watch/post page)\", required: true },\n    source: { type: \"string\", description: \"Provenance: url | youtube\", required: false },\n    \"external-id\": { type: \"string\", description: \"Provider asset id (deduped on)\", required: false },\n    \"external-url\": { type: \"string\", description: \"Canonical page URL\", required: false },\n    download: {\n      type: \"boolean\",\n      description: \"Force the download path instead of letting Baker fetch the URL directly\",\n      required: false,\n      default: false,\n    },\n    country: {\n      type: \"string\",\n      description: \"Two-letter country to fetch from (e.g. US, DE, JP) — use when a video is blocked in your region\",\n      required: false,\n    },\n    context: {\n      type: \"string\",\n      description:\n        \"What you know that the video cannot show — the campaign, whether the person on camera is a real customer, what it is for. Highest-leverage flag here: it is what makes the clip findable later.\",\n      required: false,\n    },\n    \"dry-run\": { type: \"boolean\", description: \"Preview the operation without executing\", required: false },\n  },\n});\n\nexport const ingestCommand = defineCommand({\n  meta: {\n    name: \"ingest\",\n    description:\n      \"Add a video to the library from a URL. A direct file URL is handed straight to Baker, which fetches it. A page URL (YouTube, TikTok, Vimeo, Instagram) is downloaded here first, then uploaded — and a direct URL that Baker cannot fetch falls back to that same path automatically.\\n\\nExample: baker videos ingest https://www.youtube.com/watch?v=abc123\",\n  },\n  args: {\n    url: { type: \"positional\", description: \"Video URL\", required: false },\n    source: { type: \"string\", description: \"Provenance: url | youtube\", required: false },\n    \"external-id\": { type: \"string\", description: \"Provider asset id\", required: false },\n    \"external-url\": { type: \"string\", description: \"Canonical page URL\", required: false },\n    download: { type: \"boolean\", description: \"Force the download path\", required: false, default: false },\n    country: { type: \"string\", description: \"Two-letter country to fetch from, e.g. US\", required: false },\n    context: {\n      type: \"string\",\n      description: \"Context for the analysis — campaign, who is on camera, intended use\",\n      required: false,\n    },\n    \"dry-run\": { type: \"boolean\", description: \"Preview without executing\", required: false, default: false },\n  },\n  run: ({ args }) =>\n    runVideoIngest({\n      url: args.url as string | undefined,\n      source: args.source as string | undefined,\n      externalId: args[\"external-id\"] as string | undefined,\n      externalUrl: args[\"external-url\"] as string | undefined,\n      forceDownload: args.download === true,\n      country: args.country as string | undefined,\n      context: args.context as string | undefined,\n      dryRun: args[\"dry-run\"] === true,\n    }),\n});\n\nexport type VideoIngestOptions = {\n  url: string | undefined;\n  source?: string;\n  externalId?: string;\n  externalUrl?: string;\n  forceDownload?: boolean;\n  country?: string;\n  /** What the adder knew that the frames cannot show. Feeds the analysis. */\n  context?: string;\n  dryRun?: boolean;\n};\n\n/**\n * The ingest flow itself, callable from `videos ingest` and from the URL branch\n * of `videos upload` — one implementation, so the two verbs cannot drift.\n */\nexport async function runVideoIngest(opts: VideoIngestOptions): Promise<void> {\n  const url = opts.url;\n  if (!url) {\n    writeJson({ ok: false, error: { code: \"VALIDATION_ERROR\", message: \"URL is required\" } });\n    process.exit(1);\n  }\n\n  const direct = !opts.forceDownload && isDirectMediaUrl(url);\n  const country = opts.country?.trim() || undefined;\n  const args: IngestArgs = {\n    url,\n    source: resolveIngestSource(opts.source, url),\n    externalId: opts.externalId,\n    // Deliberately NOT pre-filled with the pasted URL. Doing so shadowed the\n    // canonical URL the probe resolves (`?? canonicalUrl(...)` below could never\n    // run), so the same video filed under a different `externalUrl` depending on\n    // whether the link was copied from a share sheet, a shorts page or the\n    // address bar. `downloadThenIngest` falls back to `args.url` when the probe\n    // resolves nothing, which is the value this used to hard-code.\n    externalUrl: opts.externalUrl,\n    descriptionContext: opts.context?.trim() || undefined,\n  };\n\n  // Checked here as well as at the route, because the download path ends by\n  // posting this same body: a bad `--source` caught only server-side would\n  // otherwise be discovered twice, the second time after downloading the video.\n  const validation = videosIngestRequestSchema.safeParse({ ...args, url });\n  if (!validation.success) {\n    const problem = validation.error.issues[0];\n    writeJson({\n      ok: false,\n      error: {\n        code: \"VALIDATION_ERROR\",\n        message: problem ? `${problem.path.join(\".\") || \"request\"}: ${problem.message}` : \"Invalid request\",\n      },\n    });\n    process.exit(1);\n  }\n\n  if (opts.dryRun) {\n    reportDryRun(args, direct, country);\n    return;\n  }\n\n  try {\n    const data = await ingestByRoute(args, direct, country);\n    writeJson({ ok: true, data, hints: ingestHints(data) });\n  } catch (err) {\n    reportIngestFailure(err);\n  }\n}\n\n/**\n * The successful ingest as the caller receives it.\n *\n * Named rather than left as a `Record<string, unknown>` so the fields that only\n * *sometimes* appear are still a checked contract. `reducedQuality` is the one\n * that needs it: nothing else reads it, `ingestHints` is the only thing that\n * acts on it, and an untyped bag would let either side be renamed with the\n * tests still green and the hint silently never firing again.\n */\nexport type IngestReport = VideosIngestResponse & {\n  via: \"direct\" | \"download\";\n  egress?: string;\n  country?: string;\n  reducedQuality?: true;\n  fallbackFrom?: string;\n};\n\n/**\n * What the caller has to be told about a download that already succeeded.\n *\n * The recovery itself is deliberately invisible — nobody asks for a retry, and\n * a video that arrives is a video that arrived. What must not be invisible is\n * the price the recovery paid, because it is the one thing looking at the\n * result cannot reveal: a 360p clip and a 1080p clip are the same successful\n * envelope. Written for whoever reads the JSON to repeat to a marketer, so it\n * says \"standard quality\", not which player answered.\n */\nexport function ingestHints(data: IngestReport): string[] | undefined {\n  if (data.reducedQuality !== true) return undefined;\n  return [\n    \"Added, but at standard quality (360p): the site refused to release the full-quality file and this was the best it would hand over. Tell the user — the clip is in the library and usable, it is just not high-resolution. If they need the crisp version, ask them for the original file and use `baker videos upload <file>`.\",\n  ];\n}\n\nfunction reportDryRun(args: IngestArgs, direct: boolean, country?: string): void {\n  writeJson({\n    ok: true,\n    dryRun: true,\n    operation: \"videos.ingest\",\n    params: {\n      url: args.url,\n      source: args.source,\n      // Known up front on the direct route, because it is derived from the URL\n      // alone. The download route's key comes from the probe, which a dry run\n      // does not perform, so there it stays null rather than becoming a guess.\n      externalId: args.externalId ?? (direct ? directDedupeKey(args.source, args.url) : null),\n      // A page URL's canonical form is only known after the probe, which a dry\n      // run does not perform — so this is null rather than a guess.\n      externalUrl: args.externalUrl ?? null,\n      direct,\n      country: country ?? null,\n      descriptionContext: args.descriptionContext ?? null,\n    },\n  });\n}\n\n/**\n * A direct media URL is handed straight over: Baker asks Mux to pull it, so no\n * bytes cross this machine and there is no size ceiling to hit. Only when that\n * is refused do we pay to download and re-upload the file ourselves.\n */\nasync function ingestByRoute(args: IngestArgs, direct: boolean, country?: string): Promise<IngestReport> {\n  if (!direct) {\n    return { ...(await downloadThenIngest(args, country)), via: \"download\" };\n  }\n  try {\n    // Defaulted here rather than on `args`, so that the fallback below still\n    // derives its key from the probe: a URL that turns out to be a page carries\n    // a real provider id, which dedupes better than the link it was pasted as.\n    const externalId = args.externalId ?? directDedupeKey(args.source, args.url);\n    return { ...(await ingestUrl({ ...args, externalId })), via: \"direct\" };\n  } catch (err) {\n    if (!(err instanceof ApiError) || !worthDownloadingInstead(err.code)) throw err;\n    return { ...(await downloadThenIngest(args, country)), via: \"download\", fallbackFrom: err.message };\n  }\n}\n\n/**\n * Turn a yt-dlp failure into the one sentence that names its actual cause.\n *\n * Split out from `reportIngestFailure` because the list of distinguishable\n * causes kept growing — proxy, DRM, Vimeo login, region, stale extractor — and\n * each one exists because the generic message sent the reader somewhere useless.\n * Order matters and is not alphabetical: DRM and region both also emit phrases\n * the stale-extractor branch would match, so the specific cases are asked first.\n */\nfunction reportYtDlpFailure(err: YtDlpError): never {\n  const detail = `${err.stderrTail} ${err.message}`;\n\n  // Our own egress failing is not the site's fault and not the link's. Saying\n  // otherwise sends whoever reads this to check a video that was never the\n  // problem, while the real cause — a rotated proxy credential — stays hidden.\n  if (isProxyFailure(ytDlpBlockSignal(detail))) {\n    fail(\n      \"Couldn't download that video: our connection to the internet was refused.\",\n      \"This is Baker's egress proxy, not the link — its credentials look wrong or expired. The link is probably fine. Report it; retrying won't help until the proxy is fixed.\",\n    );\n  }\n  if (isDrmProtected(detail)) {\n    fail(\n      \"That video is copy-protected, so it can't be added to the library.\",\n      \"The publisher encrypted this one against downloading. Nothing will change that — not retrying, not a different region. Ask whoever owns the video for the original file and add it with `baker videos upload <file>`.\",\n    );\n  }\n  if (isVimeoAuthFailure(detail)) {\n    fail(\n      \"Vimeo wouldn't hand over that video — Baker isn't signed in to Vimeo.\",\n      \"Vimeo now refuses anonymous downloads entirely, so this needs a signed-in session and the one Baker holds has either expired or was never set. Nothing is wrong with the link. Report it so the Vimeo cookie can be refreshed; meanwhile download the file and use `baker videos upload <file>`.\",\n    );\n  }\n  if (isRegionBlocked(detail)) {\n    fail(\n      `That video isn't available in the region we're fetching from. ${err.stderrTail || err.message}`,\n      \"Re-run with `--country <two-letter code>` for a country where the video plays — e.g. `--country US`. Pick the one the video belongs to (the uploader's country is the usual answer); each attempt costs a paid connection, so choose rather than work through the list.\",\n    );\n  }\n  fail(\n    `Couldn't download that video. ${err.stderrTail || err.message}`,\n    isToolingOrBlockFailure(detail)\n      ? \"The site wouldn't hand over the video — usually the downloader being out of date against a site that changed, or the request being blocked. Retrying won't help, and the link is probably fine. Report it so the tool can be updated; meanwhile download the file and use `baker videos upload <file>`.\"\n      : \"Check the link is public and playable. Private or age-restricted videos can't be downloaded — download the file yourself and use `baker videos upload <file>`.\",\n  );\n}\n\n/** Emit an ingest failure envelope and stop. */\nfunction fail(message: string, fix: string, code = \"INGEST_FAILED\"): never {\n  writeJson({ ok: false, error: { code, message, fix } });\n  process.exit(1);\n}\n\nfunction reportIngestFailure(err: unknown): never {\n  if (err instanceof ApiError) {\n    writeJson({ ok: false, error: { code: err.code, message: err.message } });\n    process.exit(1);\n  }\n  if (err instanceof YtDlpError) reportYtDlpFailure(err);\n\n  // Say what actually went wrong. \"Unexpected error\" was worse than unhelpful:\n  // a download that outran its leash throws a plain `Error`, lands here, and had\n  // its only diagnostic thrown away — so a predictable timeout on a long video\n  // was indistinguishable from a genuine crash.\n  const detail = err instanceof Error ? err.message : String(err);\n  if (detail.includes(\"timed out after\")) {\n    fail(\n      \"That video took too long to download and was stopped part-way.\",\n      \"Long or slow-serving videos can outrun the download window. Try a shorter clip, or download this one yourself and use `baker videos upload <file>`.\",\n      \"INTERNAL_ERROR\",\n    );\n  }\n  fail(\n    `Couldn't add that video. ${detail}`,\n    \"This is a fault on Baker's side, not a problem with the link. Report it.\",\n    \"INTERNAL_ERROR\",\n  );\n}\n\ntype IngestArgs = {\n  url: string;\n  source: string;\n  externalId?: string;\n  externalUrl?: string;\n  descriptionContext?: string;\n};\n\n/**\n * A dedupe key that identifies this exact video and nothing else.\n *\n * yt-dlp's per-platform extractors return a real provider id, which is what we\n * want: the same YouTube clip pasted three ways dedupes to one row. Its\n * *generic* extractor does not — it returns the URL's basename, so two unrelated\n * files both named `demo.mp4` would produce `url:demo` and the second ingest\n * would \"succeed\" by handing back the first one's clip. A wrong hit is worse\n * than a missed one here: a duplicate costs a transcode, while a collision\n * silently returns the wrong video under a successful-looking response.\n *\n * So the generic case is keyed on the canonical URL, which is unique by\n * construction and still dedupes re-pastes of the same link exactly as intended.\n */\nfunction dedupeKey(args: IngestArgs, info: YtDlpInfo): string | undefined {\n  const id = typeof info.id === \"string\" ? info.id : undefined;\n  if (!id) return undefined;\n  if (info.extractor === \"generic\") return `${args.source}:${canonicalUrl(info) ?? args.url}`;\n  return `${args.source}:${id}`;\n}\n\nfunction ingestUrl(args: IngestArgs): Promise<VideosIngestResponse> {\n  const body: VideosIngestRequest = {\n    url: args.url,\n    source: args.source as VideosIngestRequest[\"source\"],\n  };\n  if (args.externalId) body.externalId = args.externalId;\n  if (args.externalUrl) body.externalUrl = args.externalUrl;\n  if (args.descriptionContext) body.descriptionContext = args.descriptionContext;\n  return apiPost<VideosIngestResponse>(\"/api/videos/ingest\", body);\n}\n\n/**\n * Download the media with yt-dlp, park it in R2, then ingest that URL.\n *\n * The extra hop is what makes a page URL work at all: Mux can only pull a media\n * file, and a watch page is not one. It is also the only route for a CDN that\n * serves us but refuses Mux — YouTube's file URLs, for instance, are bound to\n * the IP that requested them, so handing one to Mux would 403.\n */\nasync function downloadThenIngest(\n  args: IngestArgs,\n  country?: string,\n): Promise<VideosIngestResponse & { egress: string; country?: string; reducedQuality?: true }> {\n  const vimeoCookie = captureVimeoCookie();\n  // The work dir is created before the probe, not after, because the probe needs\n  // somewhere to put the cookie jar — Vimeo refuses metadata anonymously too.\n  const workDir = await mkdtemp(path.join(tmpdir(), \"videos-ingest-\"));\n\n  try {\n    // Metadata first, because both of the decisions it settles are decisions we\n    // used to make only after paying for the download.\n    const probe = await probeYtDlp({ url: args.url, country, vimeoCookie, cookieDir: workDir });\n\n    if (isAudioOnly(probe.info)) {\n      throw new ApiError(\n        \"VALIDATION_ERROR\",\n        \"That link is audio, not video, so it can't go in the video library. Music and podcast links have no picture to store.\",\n      );\n    }\n\n    const tooLong = refuseByDuration(durationSeconds(probe.info), MAX_VIDEO_INGEST_SECONDS);\n    if (tooLong) {\n      throw new ApiError(\"VALIDATION_ERROR\", tooLong);\n    }\n\n    // Prefer yt-dlp's own id: re-pasting the same link then dedupes instead of\n    // paying Mux to transcode and transcribe the same video twice. Read from the\n    // probe rather than from the download's info.json only because the probe has\n    // already run — the dedupe itself still happens at the route, after the file\n    // has been fetched. Skipping the download on a known id needs a lookup the\n    // API does not expose yet; `ingestFromUrlInternal` short-circuits on\n    // `externalId` before calling Mux, so the hook for it exists.\n    const externalId = args.externalId ?? dedupeKey(args, probe.info);\n\n    const { filePath, tier, reducedQuality } = await runYtDlp({\n      url: args.url,\n      audioOnly: false,\n      workDir,\n      // Deliberately uncapped: take the best the site will release and let Mux\n      // decide what to serve. The 1080p ceiling this replaces was reasoning\n      // about the wrong cost — it saved download bytes by throwing away source\n      // pixels *before* the one system that can make renditions from them ever\n      // saw them, so a 4K master became a 1080p master permanently, for\n      // everything the library is ever asked to do with that clip afterwards.\n      // Downscaling is Mux's job and it is cheap; re-acquiring a master is not.\n      country,\n      vimeoCookie,\n      // Budgeted from the probed length, so the duration we accept and the time\n      // we allow to fetch it cannot drift apart.\n      timeoutMs: downloadTimeoutMs(durationSeconds(probe.info)),\n    });\n\n    const stats = await stat(filePath);\n    if (stats.size > MAX_VIDEO_INGEST_BYTES) {\n      throw new ApiError(\n        \"VALIDATION_ERROR\",\n        `That video is ${(stats.size / 1024 ** 3).toFixed(1)} GB, over the ${Math.round(MAX_VIDEO_INGEST_BYTES / 1024 ** 3)} GB limit for this route.`,\n      );\n    }\n\n    const publicUrl = await uploadToAssetStore(filePath, stats.size);\n\n    // `url` becomes the stored copy, so the original has to survive as\n    // `externalUrl` — otherwise a direct link that fell back to this route\n    // leaves the library with no record of where the clip came from.\n    // `egress` names the rung that produced the bytes. A paid exit costing real\n    // money must never be spent invisibly — without this the only difference\n    // between a free download and a residential one is the wall clock.\n    return {\n      ...(await ingestUrl({\n        ...args,\n        url: publicUrl,\n        externalId,\n        externalUrl: args.externalUrl ?? canonicalUrl(probe.info) ?? args.url,\n      })),\n      egress: tier,\n      // Named in the result for the same reason `egress` is: a geo-targeted exit\n      // is a deliberate, billable choice and must not be invisible afterwards.\n      ...(country ? { country } : {}),\n      // Third member of the same family. The site refused the good formats and\n      // the download quietly took the one it would release, which is the right\n      // call — but a clip that is 360p because of that must say so here, or the\n      // only way to find out is to watch it.\n      ...(reducedQuality ? { reducedQuality: true } : {}),\n    };\n  } finally {\n    await rm(workDir, { recursive: true, force: true }).catch(() => {\n      // best-effort cleanup — the sandbox is disposable\n    });\n  }\n}\n\n/**\n * Park a downloaded file in R2 via the canvas asset presign route and return the\n * public URL.\n *\n * Streamed from disk in both passes — hashing and uploading — so a long video\n * costs one buffer rather than twice its own length in RAM. It reads the file\n * twice because the presign needs the sha before the PUT can start, which is a\n * cheap trade against holding gigabytes in memory to avoid the second read.\n */\nasync function uploadToAssetStore(filePath: string, sizeBytes: number): Promise<string> {\n  const sha256 = await hashFile(filePath);\n  const { putUrl, publicUrl } = await apiPost<{ putUrl: string; publicUrl: string }>(\"/api/canvas/assets/presign\", {\n    sha256,\n    mime: \"video/mp4\",\n    purpose: \"source\",\n  });\n\n  const putRes = await putFileStreamed({ putUrl, filePath, contentType: \"video/mp4\", sizeBytes });\n  if (!putRes.ok) {\n    throw new ApiError(\"INTERNAL_ERROR\", `Storing the downloaded video failed: HTTP ${putRes.status}`);\n  }\n  return publicUrl;\n}\n","import { createHash } from \"node:crypto\";\nimport { createReadStream } from \"node:fs\";\nimport { Readable } from \"node:stream\";\nimport { pipeline } from \"node:stream/promises\";\n\n/**\n * Move a file to object storage without ever holding it in memory.\n *\n * The reason this exists rather than `readFile` + `fetch`: a video is the one\n * asset whose size is set by someone else. Reading it into a Buffer costs its\n * full length in RAM, and handing that Buffer to `new Uint8Array(...)` copies it\n * again — measured, not assumed: `new Uint8Array(buf)` does not alias, so peak\n * usage was twice the file. On an 8 GB Runtime that puts the real ceiling near\n * 3-4 GB of *video*, well under the size a 4K master or a long recording\n * reaches, and the failure mode is an OOM kill with no error to report.\n *\n * Streaming makes peak memory a fixed chunk regardless of length, which is what\n * lets the size limit be a policy decision instead of a memory one.\n */\n\n/** sha256 of a file's contents, read in chunks. */\nexport async function hashFile(filePath: string): Promise<string> {\n  const hash = createHash(\"sha256\");\n  await pipeline(createReadStream(filePath), hash);\n  return hash.digest(\"hex\");\n}\n\n/**\n * PUT a file to a presigned URL, streaming from disk.\n *\n * `content-length` is mandatory and comes from the caller's `stat`: a stream\n * body would otherwise be sent chunked, which S3-compatible presigned PUTs\n * reject. `duplex: \"half\"` is required by undici whenever the body is a stream.\n */\nexport async function putFileStreamed(args: {\n  putUrl: string;\n  filePath: string;\n  contentType: string;\n  sizeBytes: number;\n}): Promise<Response> {\n  // `toWeb` rather than handing `fetch` the Node stream directly: undici accepts\n  // both, but only the web stream is a `BodyInit`, so this stays type-safe\n  // instead of needing a cast that would hide a real mistake later.\n  const body = Readable.toWeb(createReadStream(args.filePath)) as ReadableStream<Uint8Array>;\n\n  return await fetch(args.putUrl, {\n    method: \"PUT\",\n    body,\n    headers: {\n      \"Content-Type\": args.contentType,\n      \"Content-Length\": String(args.sizeBytes),\n    },\n    duplex: \"half\",\n  } as RequestInit & { duplex: \"half\" });\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-2GVXNKAE.js

@@ -0,0 +1,42 @@
+import {
+  ApiError
+} from "./chunk-CUL3VB4L.js";
+import {
+  writeJson
+} from "./chunk-MYTDK3AL.js";
+
+// src/commands/studio/errors.ts
+var CREDIT_HINTS = ["credit", "top up", "billing", "quota"];
+function studioStartFix(message) {
+  const lower = message.toLowerCase();
+  if (CREDIT_HINTS.some((hint) => lower.includes(hint))) {
+    return {
+      action: "Stop generating and finish the task with assets that already exist",
+      explanation: "No generation will run until the plan is topped up, so retrying costs time and changes nothing. Source or reuse an image instead, complete the rest of the work, and tell the user the new artwork could not be produced."
+    };
+  }
+  return {
+    action: "Drop or correct the setting the message names, then run the command once more",
+    explanation: "The message says which model was chosen and what it accepts. If the setting is not essential to the brief, leave it out rather than switching model. Do not abort the wider job over one refused setting."
+  };
+}
+function failStudioCommand(error, opts = {}) {
+  if (error instanceof ApiError) {
+    writeJson({
+      ok: false,
+      error: {
+        code: error.code,
+        message: error.message,
+        ...opts.withFix ? { fix: studioStartFix(error.message) } : {}
+      }
+    });
+    process.exit(1);
+  }
+  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+
+export {
+  failStudioCommand
+};
+//# sourceMappingURL=chunk-2GVXNKAE.js.map

package/dist/chunk-2GVXNKAE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/studio/errors.ts"],"sourcesContent":["import { ApiError } from \"../../client.ts\";\nimport { writeJson } from \"../../output.ts\";\n\nconst CREDIT_HINTS = [\"credit\", \"top up\", \"billing\", \"quota\"];\n\n/**\n * Structured remediation for a refused start.\n *\n * Both cases are recoverable and neither is a reason to abandon a multi-step job:\n * a knob the model does not take is one flag away from working, and an empty\n * balance means no generation in this Session will run, so the rest of the task\n * should finish with existing assets and say so.\n */\nexport function studioStartFix(message: string): { action: string; explanation: string } {\n  const lower = message.toLowerCase();\n  if (CREDIT_HINTS.some((hint) => lower.includes(hint))) {\n    return {\n      action: \"Stop generating and finish the task with assets that already exist\",\n      explanation:\n        \"No generation will run until the plan is topped up, so retrying costs time and changes nothing. Source or reuse an image instead, complete the rest of the work, and tell the user the new artwork could not be produced.\",\n    };\n  }\n  return {\n    action: \"Drop or correct the setting the message names, then run the command once more\",\n    explanation:\n      \"The message says which model was chosen and what it accepts. If the setting is not essential to the brief, leave it out rather than switching model. Do not abort the wider job over one refused setting.\",\n  };\n}\n\n/** Every studio subcommand fails the same way: envelope, fix, non-zero exit. */\nexport function failStudioCommand(error: unknown, opts: { withFix?: boolean } = {}): never {\n  if (error instanceof ApiError) {\n    writeJson({\n      ok: false,\n      error: {\n        code: error.code,\n        message: error.message,\n        ...(opts.withFix ? { fix: studioStartFix(error.message) } : {}),\n      },\n    });\n    process.exit(1);\n  }\n  writeJson({ ok: false, error: { code: \"INTERNAL_ERROR\", message: \"Unexpected error\" } });\n  process.exit(1);\n}\n"],"mappings":";;;;;;;;AAGA,IAAM,eAAe,CAAC,UAAU,UAAU,WAAW,OAAO;AAUrD,SAAS,eAAe,SAA0D;AACvF,QAAM,QAAQ,QAAQ,YAAY;AAClC,MAAI,aAAa,KAAK,CAAC,SAAS,MAAM,SAAS,IAAI,CAAC,GAAG;AACrD,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,aACE;AAAA,IACJ;AAAA,EACF;AACA,SAAO;AAAA,IACL,QAAQ;AAAA,IACR,aACE;AAAA,EACJ;AACF;AAGO,SAAS,kBAAkB,OAAgB,OAA8B,CAAC,GAAU;AACzF,MAAI,iBAAiB,UAAU;AAC7B,cAAU;AAAA,MACR,IAAI;AAAA,MACJ,OAAO;AAAA,QACL,MAAM,MAAM;AAAA,QACZ,SAAS,MAAM;AAAA,QACf,GAAI,KAAK,UAAU,EAAE,KAAK,eAAe,MAAM,OAAO,EAAE,IAAI,CAAC;AAAA,MAC/D;AAAA,IACF,CAAC;AACD,YAAQ,KAAK,CAAC;AAAA,EAChB;AACA,YAAU,EAAE,IAAI,OAAO,OAAO,EAAE,MAAM,kBAAkB,SAAS,mBAAmB,EAAE,CAAC;AACvF,UAAQ,KAAK,CAAC;AAChB;","names":[]}

package/dist/{chunk-WLDM2TRF.js → chunk-2UFRHW3T.js}

@@ -2,13 +2,13 @@ import {
   handleConnectionError,
   needsConnectionFix,
   writeAdsJson
-} from "./chunk-XHC4LMK4.js";
+} from "./chunk-EIGXX6KI.js";
 import {
   ApiError
-} from "./chunk-MF7YA62W.js";
+} from "./chunk-CUL3VB4L.js";
 import {
   getEnv
-} from "./chunk-HJEMOSPH.js";
+} from "./chunk-I4FTS5EE.js";
 
 // src/commands/ads/meta/shared.ts
 var DAY_MS = 864e5;
@@ -133,4 +133,4 @@ export {
   resolveEffectiveStatus,
   statusFilterHints
 };
-//# sourceMappingURL=chunk-WLDM2TRF.js.map
+//# sourceMappingURL=chunk-2UFRHW3T.js.map

package/dist/chunk-2Y5V23PU.js

@@ -0,0 +1,29 @@
+// src/commands/ads/google/keywords/provenance.ts
+var PLANNER_SOURCE = "keyword_planner_estimate";
+var IDENTITY_FIELDS = /* @__PURE__ */ new Set(["keyword"]);
+function stampPlannerRows(rows) {
+  return rows.map((row) => {
+    const stamped = { source: PLANNER_SOURCE };
+    for (const [key, value] of Object.entries(row)) {
+      stamped[IDENTITY_FIELDS.has(key) || key.startsWith("planner_") ? key : `planner_${key}`] = value;
+    }
+    return stamped;
+  });
+}
+var PLANNER_FIELD_DESCRIPTIONS = {
+  source: `Always "${PLANNER_SOURCE}". These rows are Keyword Planner ESTIMATES of total market search volume, NOT this account's data. Never report them as impressions, clicks or any account metric \u2014 read those from a query against the account.`,
+  keyword: "The keyword this estimate is for",
+  planner_avg_monthly_searches: "ESTIMATE: average monthly searches across the whole market (string), last 12 months",
+  planner_competition: "ESTIMATE: competition level \u2014 LOW, MEDIUM, HIGH",
+  planner_competition_index: "ESTIMATE: competition index 0-100 as string (higher = more competitive)",
+  planner_low_top_of_page_bid_micros: "ESTIMATE: low-range top-of-page CPC bid in micros (\xF7 1,000,000 for currency)",
+  planner_high_top_of_page_bid_micros: "ESTIMATE: high-range top-of-page CPC bid in micros (\xF7 1,000,000 for currency)",
+  planner_monthly_search_volumes: "ESTIMATE: monthly market search volume breakdown (array of {year, month, monthly_searches})"
+};
+
+export {
+  PLANNER_SOURCE,
+  stampPlannerRows,
+  PLANNER_FIELD_DESCRIPTIONS
+};
+//# sourceMappingURL=chunk-2Y5V23PU.js.map

package/dist/chunk-2Y5V23PU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/ads/google/keywords/provenance.ts"],"sourcesContent":["/**\n * Keyword Planner numbers are estimates of what the whole market searches. Account numbers are what\n * this advertiser actually got. They are different quantities with similar shapes, they end up in\n * neighbouring CSVs in /tmp, and a session once reported the first as the second — \"we already show\n * on shipbob (88 impressions)\" against an account that had never shown there once.\n *\n * A header banner does not survive `--output csv > file`, a `python3 -c` pass or 150 tool calls of\n * distance. A column name does: the only way to read one of these numbers is to name its source\n * while doing it. Every row also carries a constant `source` column, which survives any transform\n * that copies rows rather than picking fields.\n */\nexport const PLANNER_SOURCE = \"keyword_planner_estimate\";\n\n/** The one field that is not an estimate — it is the term itself, so it keeps its plain name. */\nconst IDENTITY_FIELDS = new Set([\"keyword\"]);\n\nexport type PlannerRow = Record<string, unknown>;\n\nexport function stampPlannerRows(rows: readonly PlannerRow[]): PlannerRow[] {\n  return rows.map((row) => {\n    const stamped: PlannerRow = { source: PLANNER_SOURCE };\n    for (const [key, value] of Object.entries(row)) {\n      stamped[IDENTITY_FIELDS.has(key) || key.startsWith(\"planner_\") ? key : `planner_${key}`] = value;\n    }\n    return stamped;\n  });\n}\n\n/** Field docs for the stamped shape, stated so the estimate can never be mistaken for account data. */\nexport const PLANNER_FIELD_DESCRIPTIONS: Record<string, string> = {\n  source: `Always \"${PLANNER_SOURCE}\". These rows are Keyword Planner ESTIMATES of total market search volume, NOT this account's data. Never report them as impressions, clicks or any account metric — read those from a query against the account.`,\n  keyword: \"The keyword this estimate is for\",\n  planner_avg_monthly_searches: \"ESTIMATE: average monthly searches across the whole market (string), last 12 months\",\n  planner_competition: \"ESTIMATE: competition level — LOW, MEDIUM, HIGH\",\n  planner_competition_index: \"ESTIMATE: competition index 0-100 as string (higher = more competitive)\",\n  planner_low_top_of_page_bid_micros: \"ESTIMATE: low-range top-of-page CPC bid in micros (÷ 1,000,000 for currency)\",\n  planner_high_top_of_page_bid_micros: \"ESTIMATE: high-range top-of-page CPC bid in micros (÷ 1,000,000 for currency)\",\n  planner_monthly_search_volumes:\n    \"ESTIMATE: monthly market search volume breakdown (array of {year, month, monthly_searches})\",\n};\n"],"mappings":";AAWO,IAAM,iBAAiB;AAG9B,IAAM,kBAAkB,oBAAI,IAAI,CAAC,SAAS,CAAC;AAIpC,SAAS,iBAAiB,MAA2C;AAC1E,SAAO,KAAK,IAAI,CAAC,QAAQ;AACvB,UAAM,UAAsB,EAAE,QAAQ,eAAe;AACrD,eAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC9C,cAAQ,gBAAgB,IAAI,GAAG,KAAK,IAAI,WAAW,UAAU,IAAI,MAAM,WAAW,GAAG,EAAE,IAAI;AAAA,IAC7F;AACA,WAAO;AAAA,EACT,CAAC;AACH;AAGO,IAAM,6BAAqD;AAAA,EAChE,QAAQ,WAAW,cAAc;AAAA,EACjC,SAAS;AAAA,EACT,8BAA8B;AAAA,EAC9B,qBAAqB;AAAA,EACrB,2BAA2B;AAAA,EAC3B,oCAAoC;AAAA,EACpC,qCAAqC;AAAA,EACrC,gCACE;AACJ;","names":[]}

package/dist/chunk-35NYNRRB.js

@@ -0,0 +1,111 @@
+import {
+  prepareCanvas,
+  unsuppliedPlaceholderAssets
+} from "./chunk-MYURCD23.js";
+import {
+  isSourceStale
+} from "./chunk-D46NOXRY.js";
+
+// src/commands/canvas/render-state.ts
+import { mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
+import path from "path";
+var RENDER_STATE_DIR = ".rendered";
+function statePath(canvasRoot, slug) {
+  return path.join(canvasRoot, RENDER_STATE_DIR, `${slug}.json`);
+}
+async function readRenderState(canvasRoot, slug) {
+  try {
+    const parsed = JSON.parse(await readFile(statePath(canvasRoot, slug), "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function latestVersion(canvasRoot, slug) {
+  return (await readRenderState(canvasRoot, slug)).rendered?.runId ?? null;
+}
+async function updateRenderState(canvasRoot, slug, patch) {
+  try {
+    const next = { ...await readRenderState(canvasRoot, slug), ...patch };
+    await mkdir(path.join(canvasRoot, RENDER_STATE_DIR), { recursive: true });
+    await writeFile(statePath(canvasRoot, slug), `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  } catch {
+  }
+}
+async function recordRenderAttempt(canvasRoot, slug, sourceSha) {
+  if (!sourceSha) return;
+  await updateRenderState(canvasRoot, slug, { attempted: { sourceSha, at: Date.now() } });
+}
+async function recordRendered(canvasRoot, slug, sourceSha, runId, drawn = {}) {
+  if (!sourceSha) return;
+  await updateRenderState(canvasRoot, slug, {
+    rendered: { sourceSha, runId, at: Date.now() },
+    ...drawn.prompt !== void 0 ? { prompt: drawn.prompt } : {},
+    lastFix: drawn.lastFix,
+    picture: drawn.picture,
+    ...drawn.seriesLeadRun ? { seriesLeadRun: drawn.seriesLeadRun } : {}
+  });
+}
+async function recordReviewOutcome(canvasRoot, slug, outcome) {
+  await updateRenderState(canvasRoot, slug, outcome);
+}
+async function recordSeriesLeadRun(canvasRoot, slug, leadRunId) {
+  await updateRenderState(canvasRoot, slug, { seriesLeadRun: leadRunId });
+}
+async function recordSnapshot(canvasRoot, slug, snapshot) {
+  await updateRenderState(canvasRoot, slug, { snapshot });
+}
+function isRenderStale(state, currentSourceSha) {
+  if (!state.rendered) return false;
+  if (!isSourceStale(currentSourceSha, state.rendered.sourceSha)) return false;
+  return state.attempted?.sourceSha !== currentSourceSha;
+}
+async function staleCreatives(workspaceRoot) {
+  const creativesDir = path.join(workspaceRoot, "src", "creatives");
+  const canvasRoot = path.join(workspaceRoot, "canvas");
+  let slugs;
+  try {
+    slugs = (await readdir(creativesDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+  const stale = [];
+  for (const slug of slugs.sort()) {
+    const state = await readRenderState(canvasRoot, slug);
+    if (!state.rendered) continue;
+    const canvasPath = path.join(creativesDir, slug, `${slug}.canvas.json`);
+    let prepared;
+    try {
+      prepared = await prepareCanvas(canvasPath, { write: false });
+    } catch {
+      continue;
+    }
+    if (unsuppliedPlaceholderAssets(prepared.fileGraph).length > 0) continue;
+    const current = prepared.sourceSha;
+    if (!current || !isRenderStale(state, current)) continue;
+    stale.push({
+      slug,
+      canvasPath: path.relative(workspaceRoot, canvasPath).split(path.sep).join("/"),
+      renderedRunId: state.rendered.runId,
+      sourceSha: current
+    });
+  }
+  return stale;
+}
+async function clearLegacyDirtyMarker(canvasRoot, slug) {
+  await rm(path.join(canvasRoot, ".dirty", `${slug}.json`), { force: true }).catch(() => void 0);
+}
+
+export {
+  readRenderState,
+  latestVersion,
+  recordRenderAttempt,
+  recordRendered,
+  recordReviewOutcome,
+  recordSeriesLeadRun,
+  recordSnapshot,
+  staleCreatives,
+  clearLegacyDirtyMarker
+};
+//# sourceMappingURL=chunk-35NYNRRB.js.map

package/dist/chunk-35NYNRRB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/canvas/render-state.ts"],"sourcesContent":["import { mkdir, readdir, readFile, rm, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { isSourceStale } from \"@baker/api\";\nimport type { LastFix } from \"./static-edit.ts\";\nimport type { PictureRecord } from \"./static-fix.ts\";\nimport { unsuppliedPlaceholderAssets } from \"./placeholders.ts\";\nimport { type PreparedCanvas, prepareCanvas } from \"./prepare-canvas.ts\";\n\n/**\n * What this workspace last rendered, per creative: `canvas/.rendered/<slug>.json`.\n *\n * \"Edited since its last render\" is the source fingerprint (`computeSourceSha`) now,\n * compared with the fingerprint the last completed render recorded here. It replaces the\n * `canvas/.dirty` marker a PostToolUse hook used to drop, which only saw the Write and\n * Edit tools touching `*.canvas.json` / `prompt.json`: an edit to a scene file, a\n * composition, or anything made through the shell slipped past it, and the Stop hook and\n * the `validate-creative-renders` gate let a stale preview ship.\n *\n * Two facts are kept apart:\n * - `rendered`: the source a COMPLETED render drew, and its run id;\n * - `attempted`: the source the last `baker canvas run` started on, whatever came of it.\n *   A render that fails on exactly this source is not asked for again until the source\n *   moves, so a canvas that cannot render never loops the agent.\n *\n * Lives under the gitignored `canvas/` outputs root of the workspace the canvas belongs\n * to (never `--outputs-dir`), so the CLI and the scaffold hooks always agree on the path.\n * A fresh workspace has no record, and a creative with none is not stale: there is no\n * preview of it in this workspace to be out of date.\n */\nexport const RENDER_STATE_DIR = \".rendered\";\n\nexport type RenderState = {\n  rendered?: { sourceSha: string; runId: string; at: number };\n  attempted?: { sourceSha: string; at: number };\n  /** The last portable run snapshot uploaded for this creative (see `run-snapshot.ts`). */\n  snapshot?: { identity: string; url: string };\n  /** A static ad's prompt.json as the completed render drew it: a later edit of only its words or colours renders as an edit of that version (`static-edit.ts`). */\n  prompt?: unknown;\n  /** The `--fix` (or edit) the completed render ran, and the blocking defects it left: the same fix is never run again. */\n  lastFix?: LastFix;\n  /** The blocking defects the review of the completed render named: what a fix of it is measured against. */\n  blocking?: string[];\n  /** How the completed render's picture came to be, where its canvas would not say (`static-fix.ts`). */\n  picture?: PictureRecord;\n  /**\n   * An ad of a series: the version of its lead its last registered run was made from, finished or not\n   * (`series-member.ts`). A run that fails after it is registered is not a new ask when retried.\n   */\n  seriesLeadRun?: string;\n};\n\nfunction statePath(canvasRoot: string, slug: string): string {\n  return path.join(canvasRoot, RENDER_STATE_DIR, `${slug}.json`);\n}\n\nexport async function readRenderState(canvasRoot: string, slug: string): Promise<RenderState> {\n  try {\n    const parsed = JSON.parse(await readFile(statePath(canvasRoot, slug), \"utf8\")) as RenderState;\n    return parsed && typeof parsed === \"object\" ? parsed : {};\n  } catch {\n    return {};\n  }\n}\n\n/** The version (run id) a creative shows in this workspace: its last completed render; null before one. */\nexport async function latestVersion(canvasRoot: string, slug: string): Promise<string | null> {\n  return (await readRenderState(canvasRoot, slug)).rendered?.runId ?? null;\n}\n\n/** Merge `patch` into the record. Best-effort: freshness is advisory, a render never fails over it. */\nasync function updateRenderState(canvasRoot: string, slug: string, patch: Partial<RenderState>): Promise<void> {\n  try {\n    const next = { ...(await readRenderState(canvasRoot, slug)), ...patch };\n    await mkdir(path.join(canvasRoot, RENDER_STATE_DIR), { recursive: true });\n    await writeFile(statePath(canvasRoot, slug), `${JSON.stringify(next, null, 2)}\\n`, \"utf8\");\n  } catch {\n    // Ignore: at worst the Stop hook asks for one render too many or too few.\n  }\n}\n\nexport async function recordRenderAttempt(canvasRoot: string, slug: string, sourceSha: string | undefined): Promise<void> {\n  if (!sourceSha) return;\n  await updateRenderState(canvasRoot, slug, { attempted: { sourceSha, at: Date.now() } });\n}\n\nexport async function recordRendered(\n  canvasRoot: string,\n  slug: string,\n  sourceSha: string | undefined,\n  runId: string,\n  drawn: { prompt?: unknown; lastFix?: LastFix; picture?: PictureRecord; seriesLeadRun?: string } = {},\n): Promise<void> {\n  if (!sourceSha) return;\n  await updateRenderState(canvasRoot, slug, {\n    rendered: { sourceSha, runId, at: Date.now() },\n    ...(drawn.prompt !== undefined ? { prompt: drawn.prompt } : {}),\n    lastFix: drawn.lastFix,\n    picture: drawn.picture,\n    ...(drawn.seriesLeadRun ? { seriesLeadRun: drawn.seriesLeadRun } : {}),\n  });\n}\n\n/** What the review of a completed render found blocking, and the fix the render ran, if one. */\nexport async function recordReviewOutcome(\n  canvasRoot: string,\n  slug: string,\n  outcome: { blocking: string[]; lastFix?: LastFix },\n): Promise<void> {\n  await updateRenderState(canvasRoot, slug, outcome);\n}\n\n/** The version of its lead a series ad's run was registered from: written before the run renders. */\nexport async function recordSeriesLeadRun(canvasRoot: string, slug: string, leadRunId: string): Promise<void> {\n  await updateRenderState(canvasRoot, slug, { seriesLeadRun: leadRunId });\n}\n\nexport async function recordSnapshot(canvasRoot: string, slug: string, snapshot: RenderState[\"snapshot\"]): Promise<void> {\n  await updateRenderState(canvasRoot, slug, { snapshot });\n}\n\n/**\n * Whether the preview in this workspace no longer shows the source: it was rendered, the\n * source has moved since (`isSourceStale`: a render fingerprinted by an older rule never\n * is), and no render of the source as it is now was attempted yet.\n */\nexport function isRenderStale(state: RenderState, currentSourceSha: string): boolean {\n  if (!state.rendered) return false;\n  if (!isSourceStale(currentSourceSha, state.rendered.sourceSha)) return false;\n  return state.attempted?.sourceSha !== currentSourceSha;\n}\n\n/** `sourceSha` is the source as it stands now: what a render of it would record. */\nexport type StaleCreative = { slug: string; canvasPath: string; renderedRunId: string; sourceSha: string };\n\n/**\n * Every renderable creative in the workspace whose preview is stale. A canvas that still\n * has an unfilled `[TODO]` asset slot is skipped: the agent is mid-build, and a half-built\n * creative must never be pushed to render. The source is fingerprinted the way a render\n * and the dashboard sync fingerprint it (`prepareCanvas`, read-only), so the three never\n * disagree about what is stale. `canvasPath` is workspace-relative.\n */\nexport async function staleCreatives(workspaceRoot: string): Promise<StaleCreative[]> {\n  const creativesDir = path.join(workspaceRoot, \"src\", \"creatives\");\n  const canvasRoot = path.join(workspaceRoot, \"canvas\");\n  let slugs: string[];\n  try {\n    slugs = (await readdir(creativesDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);\n  } catch {\n    return [];\n  }\n  const stale: StaleCreative[] = [];\n  for (const slug of slugs.sort()) {\n    const state = await readRenderState(canvasRoot, slug);\n    if (!state.rendered) continue;\n    const canvasPath = path.join(creativesDir, slug, `${slug}.canvas.json`);\n    let prepared: PreparedCanvas;\n    try {\n      prepared = await prepareCanvas(canvasPath, { write: false });\n    } catch {\n      continue; // Gone, renamed, or mid-edit invalid JSON: the next check reads it again.\n    }\n    if (unsuppliedPlaceholderAssets(prepared.fileGraph).length > 0) continue;\n    const current = prepared.sourceSha;\n    if (!current || !isRenderStale(state, current)) continue;\n    stale.push({\n      slug,\n      canvasPath: path.relative(workspaceRoot, canvasPath).split(path.sep).join(\"/\"),\n      renderedRunId: state.rendered.runId,\n      sourceSha: current,\n    });\n  }\n  return stale;\n}\n\n/**\n * Remove the `canvas/.dirty/<slug>.json` marker an older scaffold's PostToolUse hook wrote.\n * Nothing in a current scaffold reads it, but a client repo can run this CLI before its\n * scaffold sync lands, and there the old Stop hook and verify gate still read the marker:\n * clearing it on a render attempt, as the CLI always did, keeps that gate from blocking\n * forever. Delete once every client runs a scaffold without `nudge-canvas-rerender`.\n */\nexport async function clearLegacyDirtyMarker(canvasRoot: string, slug: string): Promise<void> {\n  await rm(path.join(canvasRoot, \".dirty\", `${slug}.json`), { force: true }).catch(() => undefined);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-3ACMDRSE.js

@@ -0,0 +1,39 @@
+// src/commands/canvas/definition-status.ts
+import { readFile, writeFile } from "fs/promises";
+import path from "path";
+import { parseDocument } from "yaml";
+var ORDER = { draft: 0, rendered: 1, published: 2 };
+async function advanceDefinitionStatus(definitionPath, to) {
+  let raw;
+  try {
+    raw = await readFile(definitionPath, "utf8");
+  } catch {
+    return "missing";
+  }
+  const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+  if (!match) return "unchanged";
+  const frontmatter = match[1] ?? "";
+  const doc = parseDocument(frontmatter);
+  if (doc.errors.length > 0) return "unchanged";
+  const current = doc.get("status");
+  if (typeof current === "string") {
+    const from = ORDER[current];
+    if (from === void 0 || from >= ORDER[to]) return "unchanged";
+  }
+  const statusLine = /^status:[^\n\r]*$/m;
+  const nextFrontmatter = statusLine.test(frontmatter) ? frontmatter.replace(statusLine, `status: ${to}`) : `${frontmatter}status: ${to}
+`;
+  if (nextFrontmatter === frontmatter) return "unchanged";
+  await writeFile(definitionPath, `---
+${nextFrontmatter}---${raw.slice(match[0].length)}`, "utf8");
+  return "updated";
+}
+function definitionPathFor(workspaceRoot, slug) {
+  return path.join(workspaceRoot, "src", "creatives", slug, "_definition.md");
+}
+
+export {
+  advanceDefinitionStatus,
+  definitionPathFor
+};
+//# sourceMappingURL=chunk-3ACMDRSE.js.map

package/dist/chunk-3ACMDRSE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/canvas/definition-status.ts"],"sourcesContent":["import { readFile, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { parseDocument } from \"yaml\";\n\n/**\n * A creative's lifecycle in its `_definition.md`, moved by the commands that cause it\n * rather than by hand: `baker canvas run` marks a creative `rendered` when the review\n * calls the render ready, and `baker creatives publish --run-id` marks it `published`.\n * The agent used to edit the field itself and often did not, so the committed status\n * drifted from what had happened and the backend had to guess around it.\n *\n * Only forward: draft, then rendered, then published. A published creative that is\n * rendered again stays published (what is live has not changed), and an archived one is\n * never touched. Only the `status` line changes; the rest of the file keeps its bytes.\n */\nexport type LifecycleStatus = \"rendered\" | \"published\";\n\nconst ORDER: Record<string, number | undefined> & Record<LifecycleStatus, number> = { draft: 0, rendered: 1, published: 2 };\n\nexport async function advanceDefinitionStatus(\n  definitionPath: string,\n  to: LifecycleStatus,\n): Promise<\"updated\" | \"unchanged\" | \"missing\"> {\n  let raw: string;\n  try {\n    raw = await readFile(definitionPath, \"utf8\");\n  } catch {\n    return \"missing\";\n  }\n  const match = raw.match(/^---\\r?\\n([\\s\\S]*?\\r?\\n)?---/);\n  if (!match) return \"unchanged\";\n  const frontmatter = match[1] ?? \"\";\n  const doc = parseDocument(frontmatter);\n  if (doc.errors.length > 0) return \"unchanged\";\n  const current = doc.get(\"status\");\n  if (typeof current === \"string\") {\n    const from = ORDER[current];\n    // Archived (or a status this CLI does not know) is never moved, and nothing moves back.\n    if (from === undefined || from >= ORDER[to]) return \"unchanged\";\n  }\n  const statusLine = /^status:[^\\n\\r]*$/m;\n  const nextFrontmatter = statusLine.test(frontmatter)\n    ? frontmatter.replace(statusLine, `status: ${to}`)\n    : `${frontmatter}status: ${to}\\n`;\n  if (nextFrontmatter === frontmatter) return \"unchanged\";\n  await writeFile(definitionPath, `---\\n${nextFrontmatter}---${raw.slice(match[0].length)}`, \"utf8\");\n  return \"updated\";\n}\n\n/** `src/creatives/<slug>/_definition.md` under the workspace root. */\nexport function definitionPathFor(workspaceRoot: string, slug: string): string {\n  return path.join(workspaceRoot, \"src\", \"creatives\", slug, \"_definition.md\");\n}\n"],"mappings":";AAAA,SAAS,UAAU,iBAAiB;AACpC,OAAO,UAAU;AACjB,SAAS,qBAAqB;AAe9B,IAAM,QAA8E,EAAE,OAAO,GAAG,UAAU,GAAG,WAAW,EAAE;AAE1H,eAAsB,wBACpB,gBACA,IAC8C;AAC9C,MAAI;AACJ,MAAI;AACF,UAAM,MAAM,SAAS,gBAAgB,MAAM;AAAA,EAC7C,QAAQ;AACN,WAAO;AAAA,EACT;AACA,QAAM,QAAQ,IAAI,MAAM,8BAA8B;AACtD,MAAI,CAAC,MAAO,QAAO;AACnB,QAAM,cAAc,MAAM,CAAC,KAAK;AAChC,QAAM,MAAM,cAAc,WAAW;AACrC,MAAI,IAAI,OAAO,SAAS,EAAG,QAAO;AAClC,QAAM,UAAU,IAAI,IAAI,QAAQ;AAChC,MAAI,OAAO,YAAY,UAAU;AAC/B,UAAM,OAAO,MAAM,OAAO;AAE1B,QAAI,SAAS,UAAa,QAAQ,MAAM,EAAE,EAAG,QAAO;AAAA,EACtD;AACA,QAAM,aAAa;AACnB,QAAM,kBAAkB,WAAW,KAAK,WAAW,IAC/C,YAAY,QAAQ,YAAY,WAAW,EAAE,EAAE,IAC/C,GAAG,WAAW,WAAW,EAAE;AAAA;AAC/B,MAAI,oBAAoB,YAAa,QAAO;AAC5C,QAAM,UAAU,gBAAgB;AAAA,EAAQ,eAAe,MAAM,IAAI,MAAM,MAAM,CAAC,EAAE,MAAM,CAAC,IAAI,MAAM;AACjG,SAAO;AACT;AAGO,SAAS,kBAAkB,eAAuB,MAAsB;AAC7E,SAAO,KAAK,KAAK,eAAe,OAAO,aAAa,MAAM,gBAAgB;AAC5E;","names":[]}

package/dist/chunk-3M6RNCDD.js

@@ -0,0 +1,26 @@
+import {
+  writeJsonEnvelope
+} from "./chunk-EIGXX6KI.js";
+import {
+  apiGet
+} from "./chunk-CUL3VB4L.js";
+
+// src/available-accounts.ts
+var AVAILABLE_ARG = {
+  type: "boolean",
+  description: "List everything the connected login reaches, each marked selected: true|false. Use it when the account, property, site or container the user means is not in the plain list.",
+  required: false
+};
+async function writeAvailableAccounts(platform, onError) {
+  try {
+    writeJsonEnvelope(await apiGet("/api/connections/available", { platform }));
+  } catch (err) {
+    onError(err);
+  }
+}
+
+export {
+  AVAILABLE_ARG,
+  writeAvailableAccounts
+};
+//# sourceMappingURL=chunk-3M6RNCDD.js.map

package/dist/chunk-3M6RNCDD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/available-accounts.ts"],"sourcesContent":["import type { AvailableAccountPlatform, AvailableAccountsResponse } from \"@baker/api\";\nimport { apiGet } from \"./client.ts\";\nimport { writeJsonEnvelope } from \"./commands/ads/output.ts\";\n\n/**\n * `--available` on every accounts command: what the connected login reaches,\n * each marked `selected`. The plain list shows only what the company selected,\n * so an account the user names but never ticked looks like one that does not\n * exist — this is how the agent tells the two apart before opening the picker.\n */\nexport const AVAILABLE_ARG = {\n  type: \"boolean\",\n  description:\n    \"List everything the connected login reaches, each marked selected: true|false. Use it when the account, property, site or container the user means is not in the plain list.\",\n  required: false,\n} as const;\n\n/** The `--available` answer, passed through as the backend shapes it; errors go to the command's own handler. */\nexport async function writeAvailableAccounts(\n  platform: AvailableAccountPlatform,\n  onError: (err: unknown) => never,\n): Promise<void> {\n  try {\n    writeJsonEnvelope(await apiGet<AvailableAccountsResponse>(\"/api/connections/available\", { platform }));\n  } catch (err) {\n    onError(err);\n  }\n}\n"],"mappings":";;;;;;;;AAUO,IAAM,gBAAgB;AAAA,EAC3B,MAAM;AAAA,EACN,aACE;AAAA,EACF,UAAU;AACZ;AAGA,eAAsB,uBACpB,UACA,SACe;AACf,MAAI;AACF,sBAAkB,MAAM,OAAkC,8BAA8B,EAAE,SAAS,CAAC,CAAC;AAAA,EACvG,SAAS,KAAK;AACZ,YAAQ,GAAG;AAAA,EACb;AACF;","names":[]}