@koda-sl/baker-cli 0.477.0-dev.55c09e3e8 → 0.478.0

package/dist/chunk-KMKELX5X.js

@@ -0,0 +1,363 @@
+import {
+  MAX_VIDEO_INGEST_BYTES,
+  MAX_VIDEO_INGEST_SECONDS,
+  directDedupeKey,
+  downloadTimeoutMs,
+  isDirectMediaUrl,
+  isDrmProtected,
+  isRegionBlocked,
+  isToolingOrBlockFailure,
+  refuseByDuration,
+  resolveIngestSource,
+  worthDownloadingInstead
+} from "./chunk-FKOECEVC.js";
+import {
+  YtDlpError,
+  canonicalUrl,
+  durationSeconds,
+  isAudioOnly,
+  isVimeoAuthFailure,
+  probeYtDlp,
+  runYtDlp,
+  ytDlpBlockSignal
+} from "./chunk-CPTOHQSJ.js";
+import {
+  videosIngestRequestSchema
+} from "./chunk-A5VAM472.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-7ANWFQEA.js";
+import {
+  captureVimeoCookie,
+  isProxyFailure
+} from "./chunk-H5CGVMQW.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-ANYMWCST.js";
+
+// src/commands/videos/ingest.ts
+import { mkdtemp, rm, stat } from "fs/promises";
+import { tmpdir } from "os";
+import path from "path";
+import { defineCommand } from "citty";
+
+// src/lib/streamUpload.ts
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+async function hashFile(filePath) {
+  const hash = createHash("sha256");
+  await pipeline(createReadStream(filePath), hash);
+  return hash.digest("hex");
+}
+async function putFileStreamed(args) {
+  const body = Readable.toWeb(createReadStream(args.filePath));
+  return await fetch(args.putUrl, {
+    method: "PUT",
+    body,
+    headers: {
+      "Content-Type": args.contentType,
+      "Content-Length": String(args.sizeBytes)
+    },
+    duplex: "half"
+  });
+}
+
+// src/commands/videos/ingest.ts
+registerSchema({
+  command: "videos.ingest",
+  description: "Add a video to the library from a URL \u2014 a direct file, or a YouTube/TikTok/Vimeo page.",
+  args: {
+    url: { type: "string", description: "Video URL (direct file or a watch/post page)", required: true },
+    source: { type: "string", description: "Provenance: url | youtube", required: false },
+    "external-id": { type: "string", description: "Provider asset id (deduped on)", required: false },
+    "external-url": { type: "string", description: "Canonical page URL", required: false },
+    download: {
+      type: "boolean",
+      description: "Force the download path instead of letting Baker fetch the URL directly",
+      required: false,
+      default: false
+    },
+    country: {
+      type: "string",
+      description: "Two-letter country to fetch from (e.g. US, DE, JP) \u2014 use when a video is blocked in your region",
+      required: false
+    },
+    context: {
+      type: "string",
+      description: "What you know that the video cannot show \u2014 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.",
+      required: false
+    },
+    "dry-run": { type: "boolean", description: "Preview the operation without executing", required: false }
+  }
+});
+var ingestCommand = defineCommand({
+  meta: {
+    name: "ingest",
+    description: "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 \u2014 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"
+  },
+  args: {
+    url: { type: "positional", description: "Video URL", required: false },
+    source: { type: "string", description: "Provenance: url | youtube", required: false },
+    "external-id": { type: "string", description: "Provider asset id", required: false },
+    "external-url": { type: "string", description: "Canonical page URL", required: false },
+    download: { type: "boolean", description: "Force the download path", required: false, default: false },
+    country: { type: "string", description: "Two-letter country to fetch from, e.g. US", required: false },
+    context: {
+      type: "string",
+      description: "Context for the analysis \u2014 campaign, who is on camera, intended use",
+      required: false
+    },
+    "dry-run": { type: "boolean", description: "Preview without executing", required: false, default: false }
+  },
+  run: ({ args }) => runVideoIngest({
+    url: args.url,
+    source: args.source,
+    externalId: args["external-id"],
+    externalUrl: args["external-url"],
+    forceDownload: args.download === true,
+    country: args.country,
+    context: args.context,
+    dryRun: args["dry-run"] === true
+  })
+});
+async function runVideoIngest(opts) {
+  const url = opts.url;
+  if (!url) {
+    writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "URL is required" } });
+    process.exit(1);
+  }
+  const direct = !opts.forceDownload && isDirectMediaUrl(url);
+  const country = opts.country?.trim() || void 0;
+  const args = {
+    url,
+    source: resolveIngestSource(opts.source, url),
+    externalId: opts.externalId,
+    // Deliberately NOT pre-filled with the pasted URL. Doing so shadowed the
+    // canonical URL the probe resolves (`?? canonicalUrl(...)` below could never
+    // run), so the same video filed under a different `externalUrl` depending on
+    // whether the link was copied from a share sheet, a shorts page or the
+    // address bar. `downloadThenIngest` falls back to `args.url` when the probe
+    // resolves nothing, which is the value this used to hard-code.
+    externalUrl: opts.externalUrl,
+    descriptionContext: opts.context?.trim() || void 0
+  };
+  const validation = videosIngestRequestSchema.safeParse({ ...args, url });
+  if (!validation.success) {
+    const problem = validation.error.issues[0];
+    writeJson({
+      ok: false,
+      error: {
+        code: "VALIDATION_ERROR",
+        message: problem ? `${problem.path.join(".") || "request"}: ${problem.message}` : "Invalid request"
+      }
+    });
+    process.exit(1);
+  }
+  if (opts.dryRun) {
+    reportDryRun(args, direct, country);
+    return;
+  }
+  try {
+    const data = await ingestByRoute(args, direct, country);
+    writeJson({ ok: true, data, hints: ingestHints(data) });
+  } catch (err) {
+    reportIngestFailure(err);
+  }
+}
+function ingestHints(data) {
+  if (data.reducedQuality !== true) return void 0;
+  return [
+    "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 \u2014 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>`."
+  ];
+}
+function reportDryRun(args, direct, country) {
+  writeJson({
+    ok: true,
+    dryRun: true,
+    operation: "videos.ingest",
+    params: {
+      url: args.url,
+      source: args.source,
+      // Known up front on the direct route, because it is derived from the URL
+      // alone. The download route's key comes from the probe, which a dry run
+      // does not perform, so there it stays null rather than becoming a guess.
+      externalId: args.externalId ?? (direct ? directDedupeKey(args.source, args.url) : null),
+      // A page URL's canonical form is only known after the probe, which a dry
+      // run does not perform — so this is null rather than a guess.
+      externalUrl: args.externalUrl ?? null,
+      direct,
+      country: country ?? null,
+      descriptionContext: args.descriptionContext ?? null
+    }
+  });
+}
+async function ingestByRoute(args, direct, country) {
+  if (!direct) {
+    return { ...await downloadThenIngest(args, country), via: "download" };
+  }
+  try {
+    const externalId = args.externalId ?? directDedupeKey(args.source, args.url);
+    return { ...await ingestUrl({ ...args, externalId }), via: "direct" };
+  } catch (err) {
+    if (!(err instanceof ApiError) || !worthDownloadingInstead(err.code)) throw err;
+    return { ...await downloadThenIngest(args, country), via: "download", fallbackFrom: err.message };
+  }
+}
+function reportYtDlpFailure(err) {
+  const detail = `${err.stderrTail} ${err.message}`;
+  if (isProxyFailure(ytDlpBlockSignal(detail))) {
+    fail(
+      "Couldn't download that video: our connection to the internet was refused.",
+      "This is Baker's egress proxy, not the link \u2014 its credentials look wrong or expired. The link is probably fine. Report it; retrying won't help until the proxy is fixed."
+    );
+  }
+  if (isDrmProtected(detail)) {
+    fail(
+      "That video is copy-protected, so it can't be added to the library.",
+      "The publisher encrypted this one against downloading. Nothing will change that \u2014 not retrying, not a different region. Ask whoever owns the video for the original file and add it with `baker videos upload <file>`."
+    );
+  }
+  if (isVimeoAuthFailure(detail)) {
+    fail(
+      "Vimeo wouldn't hand over that video \u2014 Baker isn't signed in to Vimeo.",
+      "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>`."
+    );
+  }
+  if (isRegionBlocked(detail)) {
+    fail(
+      `That video isn't available in the region we're fetching from. ${err.stderrTail || err.message}`,
+      "Re-run with `--country <two-letter code>` for a country where the video plays \u2014 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."
+    );
+  }
+  fail(
+    `Couldn't download that video. ${err.stderrTail || err.message}`,
+    isToolingOrBlockFailure(detail) ? "The site wouldn't hand over the video \u2014 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>`." : "Check the link is public and playable. Private or age-restricted videos can't be downloaded \u2014 download the file yourself and use `baker videos upload <file>`."
+  );
+}
+function fail(message, fix, code = "INGEST_FAILED") {
+  writeJson({ ok: false, error: { code, message, fix } });
+  process.exit(1);
+}
+function reportIngestFailure(err) {
+  if (err instanceof ApiError) {
+    writeJson({ ok: false, error: { code: err.code, message: err.message } });
+    process.exit(1);
+  }
+  if (err instanceof YtDlpError) reportYtDlpFailure(err);
+  const detail = err instanceof Error ? err.message : String(err);
+  if (detail.includes("timed out after")) {
+    fail(
+      "That video took too long to download and was stopped part-way.",
+      "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>`.",
+      "INTERNAL_ERROR"
+    );
+  }
+  fail(
+    `Couldn't add that video. ${detail}`,
+    "This is a fault on Baker's side, not a problem with the link. Report it.",
+    "INTERNAL_ERROR"
+  );
+}
+function dedupeKey(args, info) {
+  const id = typeof info.id === "string" ? info.id : void 0;
+  if (!id) return void 0;
+  if (info.extractor === "generic") return `${args.source}:${canonicalUrl(info) ?? args.url}`;
+  return `${args.source}:${id}`;
+}
+function ingestUrl(args) {
+  const body = {
+    url: args.url,
+    source: args.source
+  };
+  if (args.externalId) body.externalId = args.externalId;
+  if (args.externalUrl) body.externalUrl = args.externalUrl;
+  if (args.descriptionContext) body.descriptionContext = args.descriptionContext;
+  return apiPost("/api/videos/ingest", body);
+}
+async function downloadThenIngest(args, country) {
+  const vimeoCookie = captureVimeoCookie();
+  const workDir = await mkdtemp(path.join(tmpdir(), "videos-ingest-"));
+  try {
+    const probe = await probeYtDlp({ url: args.url, country, vimeoCookie, cookieDir: workDir });
+    if (isAudioOnly(probe.info)) {
+      throw new ApiError(
+        "VALIDATION_ERROR",
+        "That link is audio, not video, so it can't go in the video library. Music and podcast links have no picture to store."
+      );
+    }
+    const tooLong = refuseByDuration(durationSeconds(probe.info), MAX_VIDEO_INGEST_SECONDS);
+    if (tooLong) {
+      throw new ApiError("VALIDATION_ERROR", tooLong);
+    }
+    const externalId = args.externalId ?? dedupeKey(args, probe.info);
+    const { filePath, tier, reducedQuality } = await runYtDlp({
+      url: args.url,
+      audioOnly: false,
+      workDir,
+      // Deliberately uncapped: take the best the site will release and let Mux
+      // decide what to serve. The 1080p ceiling this replaces was reasoning
+      // about the wrong cost — it saved download bytes by throwing away source
+      // pixels *before* the one system that can make renditions from them ever
+      // saw them, so a 4K master became a 1080p master permanently, for
+      // everything the library is ever asked to do with that clip afterwards.
+      // Downscaling is Mux's job and it is cheap; re-acquiring a master is not.
+      country,
+      vimeoCookie,
+      // Budgeted from the probed length, so the duration we accept and the time
+      // we allow to fetch it cannot drift apart.
+      timeoutMs: downloadTimeoutMs(durationSeconds(probe.info))
+    });
+    const stats = await stat(filePath);
+    if (stats.size > MAX_VIDEO_INGEST_BYTES) {
+      throw new ApiError(
+        "VALIDATION_ERROR",
+        `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.`
+      );
+    }
+    const publicUrl = await uploadToAssetStore(filePath, stats.size);
+    return {
+      ...await ingestUrl({
+        ...args,
+        url: publicUrl,
+        externalId,
+        externalUrl: args.externalUrl ?? canonicalUrl(probe.info) ?? args.url
+      }),
+      egress: tier,
+      // Named in the result for the same reason `egress` is: a geo-targeted exit
+      // is a deliberate, billable choice and must not be invisible afterwards.
+      ...country ? { country } : {},
+      // Third member of the same family. The site refused the good formats and
+      // the download quietly took the one it would release, which is the right
+      // call — but a clip that is 360p because of that must say so here, or the
+      // only way to find out is to watch it.
+      ...reducedQuality ? { reducedQuality: true } : {}
+    };
+  } finally {
+    await rm(workDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function uploadToAssetStore(filePath, sizeBytes) {
+  const sha256 = await hashFile(filePath);
+  const { putUrl, publicUrl } = await apiPost("/api/canvas/assets/presign", {
+    sha256,
+    mime: "video/mp4",
+    purpose: "source"
+  });
+  const putRes = await putFileStreamed({ putUrl, filePath, contentType: "video/mp4", sizeBytes });
+  if (!putRes.ok) {
+    throw new ApiError("INTERNAL_ERROR", `Storing the downloaded video failed: HTTP ${putRes.status}`);
+  }
+  return publicUrl;
+}
+
+export {
+  ingestCommand,
+  runVideoIngest,
+  ingestHints
+};
+//# sourceMappingURL=chunk-KMKELX5X.js.map

package/dist/chunk-KODTY7PB.js

@@ -0,0 +1,215 @@
+import {
+  debugLogSetting
+} from "./chunk-H5CGVMQW.js";
+
+// src/debugLog.ts
+import { appendFileSync, mkdirSync, renameSync, statSync } from "fs";
+import { dirname, isAbsolute, resolve } from "path";
+var DEFAULT_FILE = "baker-cli-debug.jsonl";
+var BOOLEAN_ON = /* @__PURE__ */ new Set(["1", "true", "on", "yes"]);
+var BOOLEAN_OFF = /* @__PURE__ */ new Set(["0", "false", "off", "no"]);
+var MAX_BYTES = 64 * 1024 * 1024;
+var REDACTIONS = [
+  [/Bearer\s+[A-Za-z0-9._-]+/g, "Bearer [redacted]"],
+  // Authorization headers
+  // Every prefix, captured rather than listed thrice: `bkr_` and `bkv_` do not
+  // contain the literal `bk_`, so the company-key rule matched no part of the
+  // read-only credentials a Session review or a published report runs with.
+  [/\b(bk[rv]?)_[A-Za-z0-9]+/g, "$1_[redacted]"],
+  // Baker API keys
+  [/eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, "[redacted-jwt]"],
+  // JWTs / id tokens
+  [/ya29\.[A-Za-z0-9._-]+/g, "[redacted-google-token]"],
+  // Google OAuth access tokens
+  [/1\/\/[A-Za-z0-9._-]+/g, "[redacted-google-refresh]"],
+  // Google refresh tokens
+  [/EAA[A-Za-z0-9]{20,}/g, "[redacted-meta-token]"]
+  // Meta/Facebook access tokens
+];
+function redactSecrets(input) {
+  let out = input;
+  for (const [pattern, replacement] of REDACTIONS) {
+    out = out.replace(pattern, replacement);
+  }
+  return out;
+}
+var CREDENTIAL_VALUE = "[credential value]";
+var CREDENTIAL_PUT_PATH = "/api/credentials/put";
+function withoutCredentialValue(url, body) {
+  let path;
+  try {
+    path = new URL(url).pathname;
+  } catch {
+    path = url;
+  }
+  if (path !== CREDENTIAL_PUT_PATH || body === null || typeof body !== "object" || !("value" in body)) {
+    return body;
+  }
+  return { ...body, value: CREDENTIAL_VALUE };
+}
+var PUT_FLAGS_WITH_VALUES = /* @__PURE__ */ new Set(["--host", "--label"]);
+function argvWithoutCredentialValue(argv) {
+  if (argv[0] !== "credentials" || argv[1] !== "put") {
+    return argv;
+  }
+  let nameSeen = false;
+  let keepNext = false;
+  let redactNext = false;
+  return argv.map((arg, index) => {
+    if (index < 2) return arg;
+    if (keepNext || redactNext) {
+      const kept = keepNext ? arg : CREDENTIAL_VALUE;
+      keepNext = false;
+      redactNext = false;
+      return kept;
+    }
+    if (arg.startsWith("--value=")) return `--value=${CREDENTIAL_VALUE}`;
+    redactNext = arg === "--value";
+    keepNext = PUT_FLAGS_WITH_VALUES.has(arg);
+    if (arg.startsWith("-")) return arg;
+    const isName = !nameSeen;
+    nameSeen = true;
+    return isName ? arg : CREDENTIAL_VALUE;
+  });
+}
+function resolveTarget() {
+  const raw = debugLogSetting();
+  if (!raw) {
+    return void 0;
+  }
+  const lower = raw.toLowerCase();
+  if (BOOLEAN_OFF.has(lower)) {
+    return void 0;
+  }
+  const target = BOOLEAN_ON.has(lower) ? DEFAULT_FILE : raw;
+  return isAbsolute(target) ? target : resolve(process.cwd(), target);
+}
+function isDebugLogEnabled() {
+  return resolveTarget() !== void 0;
+}
+var sessionId;
+function getSessionId() {
+  if (!sessionId) {
+    sessionId = `${process.pid}-${Date.now()}`;
+  }
+  return sessionId;
+}
+var trackedPath;
+var bytesInFile = 0;
+function ensureReady(filePath) {
+  if (trackedPath !== filePath) {
+    trackedPath = filePath;
+    mkdirSync(dirname(filePath), { recursive: true });
+    try {
+      bytesInFile = statSync(filePath).size;
+    } catch {
+      bytesInFile = 0;
+    }
+  }
+}
+function append(entry) {
+  const filePath = resolveTarget();
+  if (!filePath) {
+    return;
+  }
+  try {
+    const payload = { ts: (/* @__PURE__ */ new Date()).toISOString(), session: getSessionId(), ...entry };
+    const line = `${redactSecrets(JSON.stringify(payload))}
+`;
+    ensureReady(filePath);
+    const size = Buffer.byteLength(line);
+    if (bytesInFile + size > MAX_BYTES) {
+      renameSync(filePath, `${filePath}.1`);
+      bytesInFile = 0;
+    }
+    appendFileSync(filePath, line);
+    bytesInFile += size;
+  } catch {
+  }
+}
+function errorToPlain(err) {
+  if (err instanceof Error) {
+    const code = err.code;
+    return { name: err.name, message: err.message, ...typeof code === "string" ? { code } : {} };
+  }
+  return { message: String(err) };
+}
+var invocationStartedAt;
+function logInvocation(argv) {
+  invocationStartedAt = Date.now();
+  append({ kind: "invocation", argv: argvWithoutCredentialValue(argv), cwd: process.cwd() });
+}
+function logExit(code) {
+  append({
+    kind: "exit",
+    code,
+    ...invocationStartedAt === void 0 ? {} : { durationMs: Date.now() - invocationStartedAt }
+  });
+}
+var exitHookInstalled = false;
+function installExitRecord() {
+  if (exitHookInstalled || !isDebugLogEnabled()) {
+    return;
+  }
+  exitHookInstalled = true;
+  process.on("exit", (code) => {
+    logExit(typeof code === "number" ? code : 0);
+  });
+}
+function debugLogHttp(entry) {
+  if (!isDebugLogEnabled()) {
+    return;
+  }
+  append({
+    kind: "http",
+    source: entry.source,
+    method: entry.method,
+    url: entry.url,
+    durationMs: entry.durationMs,
+    request: withoutCredentialValue(entry.url, entry.requestBody),
+    status: entry.status,
+    ok: entry.ok,
+    response: entry.responseBody,
+    error: entry.error === void 0 ? void 0 : errorToPlain(entry.error)
+  });
+}
+async function readBodyForLog(response) {
+  if (!isDebugLogEnabled()) {
+    return void 0;
+  }
+  try {
+    return await response.clone().text();
+  } catch {
+    return void 0;
+  }
+}
+function tapStream(name, stream) {
+  const original = stream.write.bind(stream);
+  const decoder = new TextDecoder("utf-8");
+  stream.write = ((chunk, ...rest) => {
+    try {
+      const text = typeof chunk === "string" ? chunk : chunk instanceof Uint8Array ? decoder.decode(chunk, { stream: true }) : String(chunk);
+      append({ kind: "output", stream: name, text });
+    } catch {
+    }
+    return original(chunk, ...rest);
+  });
+}
+var tapsInstalled = false;
+function installStreamTaps() {
+  if (tapsInstalled || !isDebugLogEnabled()) {
+    return;
+  }
+  tapsInstalled = true;
+  tapStream("stdout", process.stdout);
+  tapStream("stderr", process.stderr);
+}
+
+export {
+  logInvocation,
+  installExitRecord,
+  debugLogHttp,
+  readBodyForLog,
+  installStreamTaps
+};
+//# sourceMappingURL=chunk-KODTY7PB.js.map

package/dist/chunk-L4LLNGJG.js

@@ -0,0 +1,111 @@
+import {
+  prepareCanvas,
+  unsuppliedPlaceholderAssets
+} from "./chunk-3YSLIBIM.js";
+import {
+  isSourceStale
+} from "./chunk-A5VAM472.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-L4LLNGJG.js.map