@koda-sl/baker-cli 0.442.0 → 0.443.0-dev.043c1d4ac

package/dist/chunk-TCNNOLVZ.js

@@ -0,0 +1,207 @@
+import {
+  nodeParamsPreview
+} from "./chunk-EZUG6WE2.js";
+import {
+  creativeSlugFromCanvasPath,
+  parseDefinitionSeriesPlace,
+  parseDefinitionSourceFields,
+  parseDefinitionStrategyFields
+} from "./chunk-ICM2OXZV.js";
+import {
+  prepareCanvas
+} from "./chunk-2CD5ZP7M.js";
+import {
+  BackendClient
+} from "./chunk-HMEFD2CG.js";
+import {
+  nodeDependencies
+} from "./chunk-RRUJQVWA.js";
+import {
+  requireCredentialsFromEnv
+} from "./chunk-W3B4BHQU.js";
+
+// src/commands/canvas/sync-definition.ts
+import { readdir, readFile, stat } from "fs/promises";
+import path from "path";
+import { parseDocument } from "yaml";
+import { defineCommand } from "citty";
+
+// src/commands/canvas/definition-graph.ts
+var MAX_NODES = 300;
+var PREVIEWABLE_INGEST_EXPECTS = /* @__PURE__ */ new Set(["image"]);
+function nodeInputPreviewUrl(type, params) {
+  if (type !== "ingest" || !params || typeof params !== "object") return void 0;
+  const p = params;
+  if (p.source !== "url" || typeof p.url !== "string") return void 0;
+  if (!/^https?:\/\//i.test(p.url)) return void 0;
+  if (typeof p.expect === "string" && !PREVIEWABLE_INGEST_EXPECTS.has(p.expect)) return void 0;
+  return p.url;
+}
+function canvasToDefinitionGraph(canvas) {
+  const rawNodes = canvas?.nodes;
+  if (!Array.isArray(rawNodes)) return null;
+  const parsed = [];
+  for (const raw of rawNodes) {
+    const id = raw?.id;
+    const type = raw?.type;
+    if (typeof id !== "string" || typeof type !== "string") continue;
+    parsed.push({ id, type, inputs: raw.inputs, params: raw.params });
+    if (parsed.length >= MAX_NODES) break;
+  }
+  if (parsed.length === 0) return null;
+  const ids = new Set(parsed.map((n) => n.id));
+  const nodes = parsed.map(({ id, type, inputs, params }) => {
+    const deps = nodeDependencies({ id, inputs, params }, ids);
+    deps.delete(id);
+    const depList = [...deps];
+    const paramsPreview = nodeParamsPreview(params, depList);
+    const base = { id, type };
+    if (depList.length > 0) base.deps = depList;
+    if (paramsPreview) base.paramsPreview = paramsPreview;
+    const inputPreviewUrl = nodeInputPreviewUrl(type, params);
+    if (inputPreviewUrl) base.inputPreviewUrl = inputPreviewUrl;
+    return base;
+  });
+  const rawOutput = canvas?.output;
+  const outNode = rawOutput?.node;
+  const outSlot = rawOutput?.output;
+  const output = typeof outNode === "string" && typeof outSlot === "string" ? { node: outNode, output: outSlot } : void 0;
+  return { nodes, output };
+}
+
+// src/commands/canvas/sync-definition.ts
+function buildDefinitionSyncPayload(input, graph, chatId) {
+  const { canvas: _canvas, ...fields } = input;
+  return Object.fromEntries([
+    ...Object.entries(fields).filter(([, v]) => v !== void 0),
+    ["graph", graph],
+    ["chatId", chatId]
+  ]);
+}
+async function readDefinitionSourceFields(canvasPath) {
+  try {
+    return parseDefinitionSourceFields(await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function readDefinitionTitle(canvasPath) {
+  try {
+    const raw = await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8");
+    const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+    const doc = match ? parseDocument(match[1] ?? "") : null;
+    const title = doc && doc.errors.length === 0 ? doc.get("title") : void 0;
+    return typeof title === "string" && title.trim() ? title.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readDefinitionStrategyFields(canvasPath) {
+  try {
+    return parseDefinitionStrategyFields(await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function readDefinitionSeriesPlace(canvasPath) {
+  try {
+    return parseDefinitionSeriesPlace(await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8")) ?? {};
+  } catch {
+    return {};
+  }
+}
+async function syncCreativeDefinitionBestEffort(input) {
+  const chatId = process.env.BAKER_CHAT_ID;
+  if (!chatId) return;
+  const graph = canvasToDefinitionGraph(input.canvas);
+  if (!graph || graph.nodes.length === 0) return;
+  try {
+    const creds = requireCredentialsFromEnv();
+    const client = new BackendClient({ baseUrl: creds.url, apiKey: creds.apiKey });
+    await client.syncCreativeDefinition(buildDefinitionSyncPayload(input, graph, chatId));
+    process.stdout.write(`[definition] synced workflow graph (${graph.nodes.length} nodes) \u2014 view it in the dashboard
+`);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    process.stderr.write(`[warn] workflow graph not synced (${msg})
+`);
+  }
+}
+async function resolveCanvasPath(inputPath) {
+  const resolved = path.resolve(inputPath);
+  let dir = resolved;
+  try {
+    if ((await stat(resolved)).isFile()) {
+      if (resolved.endsWith(".canvas.json")) return resolved;
+      dir = path.dirname(resolved);
+    }
+  } catch {
+    dir = resolved.endsWith(".canvas.json") ? path.dirname(resolved) : resolved;
+  }
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return null;
+  }
+  const canvases = entries.filter((name) => name.endsWith(".canvas.json"));
+  const slug = creativeSlugFromCanvasPath(`${dir}/x/`);
+  const chosen = (slug ? canvases.find((name) => name === `${slug}.canvas.json`) : void 0) ?? canvases[0];
+  return chosen ? path.join(dir, chosen) : null;
+}
+var syncDefinitionCommand = defineCommand({
+  meta: {
+    name: "sync-definition",
+    description: "Push a creative's current node-graph + input thumbnails to the dashboard without rendering. The graph has the creative's blueprint applied (prompt.json and scenes/*.json edits), exactly as `run` would render it, without changing any file. Runs automatically when you edit a creative's canvas.json or prompt.json."
+  },
+  args: {
+    file: {
+      type: "positional",
+      required: true,
+      description: "A path under src/creatives/<slug>/ (the .canvas.json, its prompt.json, or the folder)"
+    },
+    title: {
+      type: "boolean",
+      description: "Also record the title its _definition.md gives. Only for a creative just made from another (a series ad, a translation), never on an edit re-sync."
+    }
+  },
+  async run({ args }) {
+    const canvasPath = await resolveCanvasPath(String(args.file));
+    if (!canvasPath) {
+      return;
+    }
+    const slug = creativeSlugFromCanvasPath(canvasPath);
+    if (!slug) return;
+    let canvas;
+    let sourceSha;
+    try {
+      const prepared = await prepareCanvas(canvasPath, { write: false });
+      canvas = prepared.fileGraph;
+      sourceSha = prepared.sourceSha;
+    } catch {
+      return;
+    }
+    const title = args.title ? await readDefinitionTitle(canvasPath) : void 0;
+    await syncCreativeDefinitionBestEffort({
+      slug,
+      canvas,
+      sourceSha,
+      ...title ? { title } : {},
+      ...await readDefinitionSourceFields(canvasPath),
+      ...await readDefinitionStrategyFields(canvasPath),
+      ...await readDefinitionSeriesPlace(canvasPath)
+    });
+  }
+});
+
+export {
+  buildDefinitionSyncPayload,
+  readDefinitionSourceFields,
+  readDefinitionTitle,
+  readDefinitionStrategyFields,
+  readDefinitionSeriesPlace,
+  syncCreativeDefinitionBestEffort,
+  resolveCanvasPath,
+  syncDefinitionCommand
+};
+//# sourceMappingURL=chunk-TCNNOLVZ.js.map

package/dist/chunk-TCNNOLVZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/canvas/sync-definition.ts","../src/commands/canvas/definition-graph.ts"],"sourcesContent":["import { readdir, readFile, stat } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { parseDocument } from \"yaml\";\nimport { defineCommand } from \"citty\";\nimport { BackendClient } from \"../../engine/index.ts\";\nimport { requireCredentialsFromEnv } from \"../../engine/client/env.ts\";\nimport {\n  type DefinitionSeriesPlace,\n  type DefinitionSourceFields,\n  type DefinitionStrategyFields,\n  parseDefinitionSeriesPlace,\n  parseDefinitionSourceFields,\n  parseDefinitionStrategyFields,\n} from \"./creative-definition.ts\";\nimport { canvasToDefinitionGraph } from \"./definition-graph.ts\";\nimport { prepareCanvas } from \"./prepare-canvas.ts\";\nimport { creativeSlugFromCanvasPath } from \"./run-record.ts\";\n\n/** Why the creative exists (`_definition.md` idea / message / evidence / angle / persona / awareness / hypothesis). */\ntype DefinitionSyncInput = Omit<DefinitionStrategyFields, \"seriesLead\" | \"language\"> & {\n  slug: string;\n  /** The series lead and language: omitted when not read (the backend keeps them), null when the definition names none (cleared). */\n  seriesLead?: string | null;\n  language?: string | null;\n  /** Omitted on an edit re-sync so the backend keeps the creative's existing title. */\n  title?: string;\n  platform?: string;\n  formats?: string[];\n  sourceReferenceUrl?: string;\n  /** The library ad it adapted (`_definition.md` sourceAdId / sourcePlatform / sourceAdvertiserId). */\n  sourceAdId?: string;\n  sourcePlatform?: string;\n  sourceAdvertiserId?: string;\n  canvas: unknown;\n  /** The creative's source fingerprint (`computeSourceSha`): powers the \"edited since last render\" staleness signal. */\n  sourceSha?: string;\n};\n\n/**\n * The body `POST /api/creatives/definition` receives. Absent fields are left out rather than\n * sent as undefined so the backend's `?? existing` keeps what an earlier sync recorded.\n */\nexport function buildDefinitionSyncPayload(\n  input: DefinitionSyncInput,\n  graph: unknown,\n  chatId: string,\n): Record<string, unknown> {\n  const { canvas: _canvas, ...fields } = input;\n  return Object.fromEntries([\n    ...Object.entries(fields).filter(([, v]) => v !== undefined),\n    [\"graph\", graph],\n    [\"chatId\", chatId],\n  ]);\n}\n\n/** The library ids the creative's `_definition.md` names, read from beside its canvas; empty when there is none. */\nexport async function readDefinitionSourceFields(canvasPath: string): Promise<DefinitionSourceFields> {\n  try {\n    return parseDefinitionSourceFields(await readFile(path.join(path.dirname(canvasPath), \"_definition.md\"), \"utf8\"));\n  } catch {\n    return {};\n  }\n}\n\n/** The creative's title, read from the `_definition.md` beside its canvas; undefined when it names none. */\nexport async function readDefinitionTitle(canvasPath: string): Promise<string | undefined> {\n  try {\n    const raw = await readFile(path.join(path.dirname(canvasPath), \"_definition.md\"), \"utf8\");\n    const match = raw.match(/^---\\r?\\n([\\s\\S]*?\\r?\\n)?---/);\n    const doc = match ? parseDocument(match[1] ?? \"\") : null;\n    const title = doc && doc.errors.length === 0 ? doc.get(\"title\") : undefined;\n    return typeof title === \"string\" && title.trim() ? title.trim() : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/** The creative's strategy, read from the `_definition.md` beside its canvas; empty when there is none. */\nexport async function readDefinitionStrategyFields(canvasPath: string): Promise<DefinitionStrategyFields> {\n  try {\n    return parseDefinitionStrategyFields(await readFile(path.join(path.dirname(canvasPath), \"_definition.md\"), \"utf8\"));\n  } catch {\n    return {};\n  }\n}\n\n/** The series place the `_definition.md` beside the canvas names; empty when it cannot be read, so nothing is cleared. */\nexport async function readDefinitionSeriesPlace(canvasPath: string): Promise<DefinitionSeriesPlace | Record<never, never>> {\n  try {\n    return (\n      parseDefinitionSeriesPlace(await readFile(path.join(path.dirname(canvasPath), \"_definition.md\"), \"utf8\")) ?? {}\n    );\n  } catch {\n    return {};\n  }\n}\n\n/**\n * Push a creative's parsed node-graph to the backend so the dashboard can draw\n * its workflow (and its wired input thumbnails) BEFORE — and BETWEEN — billed\n * runs. Best-effort: a missing chat id, missing creds, an unparseable canvas, or\n * a failed POST warns and returns — it must never fail the caller (a scaffold\n * that just did the real work, or a watcher reacting to an edit).\n */\nexport async function syncCreativeDefinitionBestEffort(input: DefinitionSyncInput): Promise<void> {\n  const chatId = process.env.BAKER_CHAT_ID;\n  if (!chatId) return; // Not chat-attached — nothing to preview against.\n  const graph = canvasToDefinitionGraph(input.canvas);\n  if (!graph || graph.nodes.length === 0) return;\n  try {\n    const creds = requireCredentialsFromEnv();\n    const client = new BackendClient({ baseUrl: creds.url, apiKey: creds.apiKey });\n    await client.syncCreativeDefinition(buildDefinitionSyncPayload(input, graph, chatId));\n    process.stdout.write(`[definition] synced workflow graph (${graph.nodes.length} nodes) — view it in the dashboard\\n`);\n  } catch (e) {\n    const msg = e instanceof Error ? e.message : String(e);\n    process.stderr.write(`[warn] workflow graph not synced (${msg})\\n`);\n  }\n}\n\n/**\n * Resolve the canvas file backing a creative from ANY path under its dir — the\n * `{slug}.canvas.json` itself, its sibling `prompt.json`, or the creative\n * directory. Lets a file watcher hand us whichever file changed and still find\n * the one canvas to project. Prefers `{slug}.canvas.json`, else the sole\n * `*.canvas.json` in the directory; null when there is no single canvas.\n */\nexport async function resolveCanvasPath(inputPath: string): Promise<string | null> {\n  const resolved = path.resolve(inputPath);\n  let dir = resolved;\n  try {\n    if ((await stat(resolved)).isFile()) {\n      if (resolved.endsWith(\".canvas.json\")) return resolved;\n      dir = path.dirname(resolved);\n    }\n  } catch {\n    // A deleted/renamed file: fall back to treating the path as its directory.\n    dir = resolved.endsWith(\".canvas.json\") ? path.dirname(resolved) : resolved;\n  }\n  let entries: string[];\n  try {\n    entries = await readdir(dir);\n  } catch {\n    return null;\n  }\n  const canvases = entries.filter((name) => name.endsWith(\".canvas.json\"));\n  const slug = creativeSlugFromCanvasPath(`${dir}/x/`);\n  const chosen = (slug ? canvases.find((name) => name === `${slug}.canvas.json`) : undefined) ?? canvases[0];\n  return chosen ? path.join(dir, chosen) : null;\n}\n\nexport const syncDefinitionCommand = defineCommand({\n  meta: {\n    name: \"sync-definition\",\n    description:\n      \"Push a creative's current node-graph + input thumbnails to the dashboard without rendering. The graph has the creative's blueprint applied (prompt.json and scenes/*.json edits), exactly as `run` would render it, without changing any file. Runs automatically when you edit a creative's canvas.json or prompt.json.\",\n  },\n  args: {\n    file: {\n      type: \"positional\",\n      required: true,\n      description: \"A path under src/creatives/<slug>/ (the .canvas.json, its prompt.json, or the folder)\",\n    },\n    title: {\n      type: \"boolean\",\n      description:\n        \"Also record the title its _definition.md gives. Only for a creative just made from another (a series ad, a translation), never on an edit re-sync.\",\n    },\n  },\n  async run({ args }) {\n    const canvasPath = await resolveCanvasPath(String(args.file));\n    if (!canvasPath) {\n      // Nothing to sync (not a creative path, or no canvas yet) — a no-op, not an error.\n      return;\n    }\n    const slug = creativeSlugFromCanvasPath(canvasPath);\n    if (!slug) return;\n    // The same preflight `run` uses, so the dashboard draws the graph that will render\n    // (the scene and copy projections included), in the file's canvas-relative spelling,\n    // never this machine's absolute paths. Read-only: the watcher runs this over every\n    // creative on every edit, and must never rewrite a creative nobody touched. The\n    // fingerprint is taken over the projected graph, as `run` and `baker canvas stale` take it.\n    let canvas: unknown;\n    let sourceSha: string | undefined;\n    try {\n      const prepared = await prepareCanvas(canvasPath, { write: false });\n      canvas = prepared.fileGraph;\n      sourceSha = prepared.sourceSha;\n    } catch {\n      // Mid-edit invalid JSON (canvas, prompt.json or a scene): skip this tick; the next\n      // save re-fires the watcher.\n      return;\n    }\n    // No title/platform/formats: an edit re-sync must never rename or re-classify\n    // the creative — the backend preserves what the scaffold already set. The library\n    // ids are re-read from `_definition.md`, so an agent that adds or fixes them after\n    // the scaffold still gets them recorded without waiting for Publish — and so is the\n    // creative's strategy, the moment the agent writes it.\n    const title = args.title ? await readDefinitionTitle(canvasPath) : undefined;\n    await syncCreativeDefinitionBestEffort({\n      slug,\n      canvas,\n      sourceSha,\n      ...(title ? { title } : {}),\n      ...(await readDefinitionSourceFields(canvasPath)),\n      ...(await readDefinitionStrategyFields(canvasPath)),\n      ...(await readDefinitionSeriesPlace(canvasPath)),\n    });\n  },\n});\n","import { nodeDependencies } from \"../../engine/engine/graph.ts\";\nimport { nodeParamsPreview } from \"./node-preview.ts\";\n\nexport type DefinitionGraphNode = {\n  id: string;\n  type: string;\n  deps?: string[];\n  paramsPreview?: string;\n  /**\n   * A directly-viewable input image/video for the node BEFORE any run — today\n   * an `ingest` node's `source:\"url\"` src. Lets the dashboard show a real\n   * thumbnail (a swapped logo/hero) the moment the canvas changes, with no\n   * render. Path-source ingests carry no preview (their bytes aren't uploaded\n   * outside a run); the graph still shows the `path:` line via paramsPreview.\n   */\n  inputPreviewUrl?: string;\n};\nexport type CanvasDefinitionGraph = {\n  nodes: DefinitionGraphNode[];\n  output?: { node: string; output: string };\n};\n\n// Keep the synced blueprint bounded — matches the backend's cap.\nconst MAX_NODES = 300;\n\n// Only image ingests become a pre-run thumbnail: absent `expect` defaults to an\n// image, and a still renders unambiguously in the graph card. Video/font/json\n// ingests carry no preview (a video would need its own player wiring) — their\n// `url:`/`path:` line still shows via paramsPreview.\nconst PREVIEWABLE_INGEST_EXPECTS = new Set([\"image\"]);\n\n/**\n * A directly-viewable input URL for a node's pre-run thumbnail: an `ingest`\n * node pulling an image from a `source:\"url\"` src. Everything else (path-source\n * ingests, generators, non-image expects) returns undefined — only image bytes\n * the dashboard can already fetch become a thumbnail without a run.\n */\nfunction nodeInputPreviewUrl(type: string, params: unknown): string | undefined {\n  if (type !== \"ingest\" || !params || typeof params !== \"object\") return undefined;\n  const p = params as { source?: unknown; url?: unknown; expect?: unknown };\n  if (p.source !== \"url\" || typeof p.url !== \"string\") return undefined;\n  if (!/^https?:\\/\\//i.test(p.url)) return undefined;\n  if (typeof p.expect === \"string\" && !PREVIEWABLE_INGEST_EXPECTS.has(p.expect)) return undefined;\n  return p.url;\n}\n\n/**\n * Parse a canvas JSON into the compact node-graph the dashboard draws before any\n * run — shares the engine's `nodeDependencies` ($ref edges from inputs AND params) so\n * the pre-run blueprint matches the eventual run graph. Best-effort and defensive:\n * a not-yet-valid canvas (mid-edit) returns whatever nodes it can read, or null\n * if there are none, so a caller can skip the sync without failing the command.\n */\nexport function canvasToDefinitionGraph(canvas: unknown): CanvasDefinitionGraph | null {\n  const rawNodes = (canvas as { nodes?: unknown })?.nodes;\n  if (!Array.isArray(rawNodes)) return null;\n\n  const parsed: Array<{ id: string; type: string; inputs: unknown; params: unknown }> = [];\n  for (const raw of rawNodes) {\n    const id = (raw as { id?: unknown })?.id;\n    const type = (raw as { type?: unknown })?.type;\n    if (typeof id !== \"string\" || typeof type !== \"string\") continue;\n    parsed.push({ id, type, inputs: (raw as { inputs?: unknown }).inputs, params: (raw as { params?: unknown }).params });\n    if (parsed.length >= MAX_NODES) break;\n  }\n  if (parsed.length === 0) return null;\n\n  const ids = new Set(parsed.map((n) => n.id));\n  const nodes: DefinitionGraphNode[] = parsed.map(({ id, type, inputs, params }) => {\n    const deps = nodeDependencies({ id, inputs, params }, ids);\n    deps.delete(id);\n    const depList = [...deps];\n    // The pre-run graph carries each node's spec (model / aspect / size / expect …) +\n    // its wired props so a freshly-scaffolded creative shows full node detail in the\n    // inspector BEFORE the first billed run, matching what a run later records.\n    const paramsPreview = nodeParamsPreview(params, depList);\n    const base: DefinitionGraphNode = { id, type };\n    if (depList.length > 0) base.deps = depList;\n    if (paramsPreview) base.paramsPreview = paramsPreview;\n    const inputPreviewUrl = nodeInputPreviewUrl(type, params);\n    if (inputPreviewUrl) base.inputPreviewUrl = inputPreviewUrl;\n    return base;\n  });\n\n  const rawOutput = (canvas as { output?: unknown })?.output;\n  const outNode = (rawOutput as { node?: unknown })?.node;\n  const outSlot = (rawOutput as { output?: unknown })?.output;\n  const output =\n    typeof outNode === \"string\" && typeof outSlot === \"string\" ? { node: outNode, output: outSlot } : undefined;\n\n  return { nodes, output };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-TD2P4HBP.js

@@ -0,0 +1,55 @@
+import {
+  ApiError
+} from "./chunk-XBOK23HI.js";
+import {
+  writeJson
+} from "./chunk-NU7JSWVA.js";
+
+// src/commands/media-sources/shared.ts
+function driveRefusalFix(input, code) {
+  if (!/drive\.google\.com/i.test(input) || code !== "BAD_REQUEST") return void 0;
+  return `A Google Drive folder is never added by link \u2014 don't retry. Call request_connection with platform "google-drive" and choose "media-folder": the card lets the user pick the folder in the chat (only the Baker team can for now; anyone else is told the team will set it up). A connected result carries the new source's mediaSourceKey; if it is declined, carry on with the rest of the task.`;
+}
+function reportError(err, input) {
+  if (err instanceof ApiError) {
+    const fix = input ? driveRefusalFix(input, err.code) : void 0;
+    writeJson({ ok: false, error: { code: err.code, message: err.message, ...fix ? { fix } : {} } });
+    process.exit(1);
+  }
+  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+function halfState(half) {
+  if (!half) return null;
+  return {
+    status: half.syncStatus === "fetching" || half.syncStatus === "processing" ? "importing" : half.syncStatus,
+    stored: half.storedCount ?? 0,
+    ...half.pendingItems ? { pending: half.pendingItems } : {},
+    ...half.failedItems ? { failed: half.failedItems } : {},
+    ...half.lastSyncedAt ? { lastSyncedAt: new Date(half.lastSyncedAt).toISOString() } : {},
+    ...half.errorMessage ? { error: half.errorMessage } : {}
+  };
+}
+function compactSource(source) {
+  return {
+    key: source.key,
+    platform: source.platform,
+    label: source.label,
+    url: source.profileUrl,
+    autoSync: source.refreshInterval,
+    images: halfState(source.images),
+    videos: halfState(source.videos)
+  };
+}
+function isImporting(source) {
+  return [source.images, source.videos].some(
+    (half) => half?.syncStatus === "fetching" || half?.syncStatus === "processing"
+  );
+}
+
+export {
+  reportError,
+  compactSource,
+  isImporting
+};
+//# sourceMappingURL=chunk-TD2P4HBP.js.map

package/dist/chunk-URIYUZIN.js

@@ -0,0 +1,111 @@
+import {
+  prepareCanvas,
+  unsuppliedPlaceholderAssets
+} from "./chunk-2CD5ZP7M.js";
+import {
+  isSourceStale
+} from "./chunk-XWH7CCBL.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-URIYUZIN.js.map

package/dist/chunk-URIYUZIN.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-VAJBWA2U.js

@@ -0,0 +1,75 @@
+import {
+  openRouterKey
+} from "./chunk-NAWWC5I3.js";
+
+// src/engine/nodes/local/lib/jev.ts
+import { z } from "zod";
+var JEV_MODEL = "typesafe/jev-1.13";
+var ENDPOINT = "https://openrouter.ai/api/v1/systemone";
+var TIMEOUT_MS = 2500;
+var Reply = z.object({
+  answers: z.record(z.string(), z.object({ noul: z.number() })),
+  usage: z.object({ cost: z.number() }).optional()
+});
+var Answer = z.union([
+  z.object({ choice: z.string(), probabilities: z.record(z.string(), z.number()), confidence: z.number() }),
+  z.object({ noul: z.number() })
+]);
+var AnswersReply = z.object({
+  answers: z.record(z.string(), z.unknown()),
+  usage: z.object({ cost: z.number() }).optional()
+});
+function readAnswers(body, ids) {
+  const parsed = AnswersReply.safeParse(body);
+  if (!parsed.success) return null;
+  const answers = [];
+  for (const id of ids) {
+    const answer = Answer.safeParse(parsed.data.answers[id]);
+    if (!answer.success) return null;
+    answers.push(
+      "choice" in answer.data ? { choice: answer.data.choice, probabilities: answer.data.probabilities, confidence: answer.data.confidence } : { noul: answer.data.noul }
+    );
+  }
+  return { answers, costUsd: parsed.data.usage?.cost ?? 0 };
+}
+async function askJevQuestions(questions, onSpend) {
+  const key = openRouterKey();
+  if (questions.length === 0) return [];
+  if (!key) return null;
+  const ids = questions.map((_, i) => `q${i}`);
+  try {
+    const response = await fetch(ENDPOINT, {
+      method: "POST",
+      headers: { authorization: `Bearer ${key}`, "content-type": "application/json" },
+      body: JSON.stringify({
+        model: JEV_MODEL,
+        state: {},
+        questions: Object.fromEntries(questions.map((q, i) => [ids[i], q]))
+      }),
+      signal: AbortSignal.timeout(TIMEOUT_MS)
+    });
+    if (!response.ok) return null;
+    const read = readAnswers(await response.json(), ids);
+    if (!read) return null;
+    onSpend?.({ model: JEV_MODEL, inputTokens: 0, outputTokens: 0, costUsd: read.costUsd });
+    return read.answers;
+  } catch {
+    return null;
+  }
+}
+async function askJev(questions, onSpend) {
+  const answers = await askJevQuestions(
+    questions.map((q) => ({ type: "noul", instructions: q.instructions })),
+    onSpend
+  );
+  if (!answers) return null;
+  const nouls = answers.flatMap((a) => "noul" in a ? [a.noul] : []);
+  return nouls.length === answers.length ? nouls : null;
+}
+
+export {
+  JEV_MODEL,
+  askJevQuestions,
+  askJev
+};
+//# sourceMappingURL=chunk-VAJBWA2U.js.map

package/dist/chunk-VAJBWA2U.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/engine/nodes/local/lib/jev.ts"],"sourcesContent":["/**\n * Jev, the decision model (TypeSafe's, served by OpenRouter at `/api/v1/systemone`): the CLI's\n * one boundary module for it. It reads text and answers typed questions with a probability;\n * it writes nothing. See docs/decision-model.md for when it is the right tool and the call shape.\n */\nimport { z } from \"zod\";\nimport { openRouterKey } from \"../../../../env.ts\";\nimport type { ReviewUsage } from \"./render-review.ts\";\n\n/** Pinned: the thresholds its callers act on were measured against this version. */\nexport const JEV_MODEL = \"typesafe/jev-1.13\";\nconst ENDPOINT = \"https://openrouter.ai/api/v1/systemone\";\n/** Several times its p50 (about 0.3 s): a decision that cannot come back this fast is the caller's fallback. */\nconst TIMEOUT_MS = 2_500;\n\nconst Reply = z.object({\n  answers: z.record(z.string(), z.object({ noul: z.number() })),\n  usage: z.object({ cost: z.number() }).optional(),\n});\n\n/** Each yes/no answer to `ids`, in order, and the call's cost; null when the reply does not answer them all. Pure. */\nexport function readNouls(body: unknown, ids: readonly string[]): { answers: number[]; costUsd: number } | null {\n  const parsed = Reply.safeParse(body);\n  if (!parsed.success) return null;\n  const answers = ids.map((id) => parsed.data.answers[id]?.noul);\n  if (answers.some((a) => a === undefined)) return null;\n  return { answers: answers as number[], costUsd: parsed.data.usage?.cost ?? 0 };\n}\n\n/** One question: a yes/no statement (Noul), or one option of `criteria`, keyed by option (Choice). */\nexport type JevQuestion =\n  | { type: \"noul\"; instructions: Record<string, string> }\n  | { type: \"choice\"; instructions: Record<string, string>; criteria: Record<string, string> };\n\n/** A Noul's probability of yes, or a Choice's pick with the probability of every option. */\nexport type JevAnswer =\n  | { noul: number }\n  | { choice: string; probabilities: Record<string, number>; confidence: number };\n\nconst Answer = z.union([\n  z.object({ choice: z.string(), probabilities: z.record(z.string(), z.number()), confidence: z.number() }),\n  z.object({ noul: z.number() }),\n]);\nconst AnswersReply = z.object({\n  answers: z.record(z.string(), z.unknown()),\n  usage: z.object({ cost: z.number() }).optional(),\n});\n\n/** Each answer to `ids`, in order, and the call's cost; null when the reply does not answer them all. Pure. */\nexport function readAnswers(body: unknown, ids: readonly string[]): { answers: JevAnswer[]; costUsd: number } | null {\n  const parsed = AnswersReply.safeParse(body);\n  if (!parsed.success) return null;\n  const answers: JevAnswer[] = [];\n  for (const id of ids) {\n    const answer = Answer.safeParse(parsed.data.answers[id]);\n    if (!answer.success) return null;\n    answers.push(\n      \"choice\" in answer.data\n        ? { choice: answer.data.choice, probabilities: answer.data.probabilities, confidence: answer.data.confidence }\n        : { noul: answer.data.noul },\n    );\n  }\n  return { answers, costUsd: parsed.data.usage?.cost ?? 0 };\n}\n\n/**\n * Every answer, in order (one request, whatever the mix of Nouls and Choices), or null when Jev\n * could not answer: no key, a timeout, an outage. There is no route to fall back to, so the\n * caller decides what null means.\n */\nexport async function askJevQuestions(\n  questions: readonly JevQuestion[],\n  onSpend?: (usage: ReviewUsage) => void,\n): Promise<JevAnswer[] | null> {\n  const key = openRouterKey();\n  if (questions.length === 0) return [];\n  if (!key) return null;\n  const ids = questions.map((_, i) => `q${i}`);\n  try {\n    const response = await fetch(ENDPOINT, {\n      method: \"POST\",\n      headers: { authorization: `Bearer ${key}`, \"content-type\": \"application/json\" },\n      body: JSON.stringify({\n        model: JEV_MODEL,\n        state: {},\n        questions: Object.fromEntries(questions.map((q, i) => [ids[i], q])),\n      }),\n      signal: AbortSignal.timeout(TIMEOUT_MS),\n    });\n    if (!response.ok) return null;\n    const read = readAnswers(await response.json(), ids);\n    if (!read) return null;\n    onSpend?.({ model: JEV_MODEL, inputTokens: 0, outputTokens: 0, costUsd: read.costUsd });\n    return read.answers;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * The probability that each statement is true, in order (a Noul each, one request), or null when\n * Jev could not answer: no key, a timeout, an outage. There is no route to fall back to, so the\n * caller decides what null means.\n */\nexport async function askJev(\n  questions: ReadonlyArray<{ instructions: Record<string, string> }>,\n  onSpend?: (usage: ReviewUsage) => void,\n): Promise<number[] | null> {\n  const answers = await askJevQuestions(\n    questions.map((q) => ({ type: \"noul\", instructions: q.instructions })),\n    onSpend,\n  );\n  if (!answers) return null;\n  const nouls = answers.flatMap((a) => (\"noul\" in a ? [a.noul] : []));\n  return nouls.length === answers.length ? nouls : null;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-VBHDZSI5.js

@@ -0,0 +1,57 @@
+import {
+  formEventKey
+} from "./chunk-SSJK7FEV.js";
+import {
+  flowNodeTriggers
+} from "./chunk-XWH7CCBL.js";
+
+// ../api/src/analytics/flowEventKeys.ts
+function flowNodes(node, acc = []) {
+  if (!node || typeof node !== "object") return acc;
+  const record = node;
+  acc.push(record);
+  if (Array.isArray(record.children)) for (const child of record.children) flowNodes(child, acc);
+  return acc;
+}
+function flowEventKeys(tree, slug) {
+  const primary = [];
+  const secondary = [];
+  const nodes = flowNodes(tree).filter((node) => typeof node.id === "string" && node.id !== "");
+  if (nodes.length === 0) return [];
+  for (const node of nodes) {
+    const id = node.id;
+    const triggers = flowNodeTriggers(node.nodeData);
+    for (const triggerId of triggers.available) {
+      const candidate = {
+        eventKey: formEventKey(slug, id, triggerId),
+        nodeId: id,
+        nodeName: typeof node.name === "string" ? node.name : id,
+        nodeType: triggers.type,
+        triggerId,
+        isCompletion: triggers.completion === triggerId
+      };
+      (candidate.isCompletion ? primary : secondary).push(candidate);
+    }
+  }
+  return [
+    ...primary,
+    ...secondary,
+    {
+      eventKey: `submit:${slug}`,
+      nodeId: null,
+      nodeName: "the Form ran out of steps",
+      nodeType: null,
+      triggerId: null,
+      // A Form reaching its last node is as primary as an outcome gets for a
+      // Form with no widget in it — but it never fires on one that ends in a
+      // booking widget or a redirect, so it does not lead the list.
+      isCompletion: false
+    }
+  ];
+}
+
+export {
+  flowNodes,
+  flowEventKeys
+};
+//# sourceMappingURL=chunk-VBHDZSI5.js.map