@koda-sl/baker-cli 0.386.0-dev.8b1f99042 → 0.386.0-dev.d6e55699d

package/dist/chunk-HVJUMQYY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/brand/fonts.ts"],"sourcesContent":["import type { Dirent } from \"node:fs\";\nimport { mkdir, readdir, readFile, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { defineCommand } from \"citty\";\nimport {\n  type BrandFontFace,\n  checkFontRequests,\n  DEFAULT_SUBSETS,\n  type FetchCss,\n  FONT_PROVIDERS,\n  type FontProviderName,\n  type FontStyle,\n  fontFileName,\n  fontsourceCatalogue,\n  fontsourceFamilies,\n  type GoogleCssLookup,\n  googleFontRequests,\n  missingFontFiles,\n  planFontAdoption,\n  type ResolveOutcome,\n  renderFontFaceCss,\n  resolveBrandFaces,\n  resolveFetchStyles,\n  resolveFetchSubsets,\n  resolveFetchWeights,\n  selfHostedStyles,\n  selfHostedSubsets,\n  selfHostedWeights,\n  stripFontFaceBlocks,\n  suggestFamilies,\n  unresolvedBrandFamilies,\n  upsertFontFaceCss,\n} from \"../../engine/brand/fonts.ts\";\nimport { writeJson } from \"../../output.ts\";\nimport { registerSchema } from \"../../schemas.ts\";\n\nconst GLOBAL_CSS = path.join(\"src\", \"styles\", \"global.css\");\nconst FONTS_DIR = path.join(\"src\", \"brand\", \"fonts\");\nconst DEFAULT_SUBSETS_LABEL = DEFAULT_SUBSETS.join(\",\");\n\n// Google serves different CSS per user agent — an old UA gets ttf instead of\n// woff2. Ask as a modern browser so the response is the woff2 set we want.\nconst BROWSER_UA = \"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/120.0 Safari/537.36\";\n\nregisterSchema({\n  command: \"brand.fonts.check\",\n  description:\n    \"Start here when a brand's fonts are 'confirmed' but nobody verified it. Fails if any --font-* family in src/styles/global.css has nothing loading it (no @font-face, no Google import) — the silent fallback that also fails the client's verify — then asks Google Fonts what it ACTUALLY serves for every family/weight the stylesheet requests.\",\n  args: {},\n});\n\nregisterSchema({\n  command: \"brand.fonts.adopt\",\n  description:\n    \"Move brand faces a page already self-hosts into src/styles/global.css, so every page loads them rather than only the page that declared them. Use when `check` reports a family as not loaded but its files are already in src/brand/fonts/. Never downloads: re-fetching would hand that page a different build of the same face.\",\n  args: {},\n});\n\nregisterSchema({\n  command: \"brand.fonts.fetch\",\n  description:\n    \"Download a font into src/brand/fonts/ so the brand stops depending on a third party at page load, and write its @font-face into src/styles/global.css above @theme. Resolves against Google Fonts first, then Fontsource — which carries ~2000 open-licence families Google does not, so a name Google 400s is often still fetchable. Idempotent: re-running replaces that family's faces rather than stacking duplicates.\",\n  args: {\n    family: { type: \"string\", description: 'Font family, e.g. \"DM Sans\"', required: true },\n    weights: {\n      type: \"string\",\n      description: \"Comma-separated weights (default: the weights global.css already requests or self-hosts, else 400)\",\n      required: false,\n    },\n    subsets: {\n      type: \"string\",\n      description: `Comma-separated unicode subsets (default: the subsets global.css already self-hosts, else ${DEFAULT_SUBSETS_LABEL})`,\n      required: false,\n    },\n    italic: {\n      type: \"boolean\",\n      description:\n        \"Also self-host the family's italic faces. On automatically when global.css already loads one, so a re-fetch never strands it.\",\n      required: false,\n    },\n  },\n});\n\nfunction fail(\n  code: string,\n  message: string,\n  fix?: { action: string; explanation: string } & Record<string, unknown>,\n): never {\n  writeJson({ ok: false, error: { code, message, ...(fix ? { fix } : {}) } });\n  process.exit(2);\n}\n\n// A hung request would otherwise stall the agent's whole turn — these commands\n// are on demand, so a bounded wait is strictly better than an open one.\nconst REQUEST_TIMEOUT_MS = 15_000;\n\n/**\n * JSON body from a catalogue API, or null when the catalogue itself answers\n * that there is no such family.\n *\n * Only a 404 is that answer. Every other failure THROWS, because \"Fontsource\n * did not answer\" is not \"Fontsource does not have it\" — collapsed into null it\n * became `unknown-family`, and the agent was told to check the spelling or\n * hand-write an @font-face for a commercial face, on the strength of a 503.\n * Same rule `lookupGoogleCss` follows, and the scaffold's `getJson` mirror.\n */\nexport async function fetchJson(url: string): Promise<unknown> {\n  const res = await fetch(url, {\n    headers: { \"User-Agent\": BROWSER_UA },\n    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),\n  });\n  if (res.status === 404) return null;\n  if (!res.ok) throw new Error(`Fontsource answered ${res.status}`);\n  return await res.json();\n}\n\nexport async function lookupGoogleCss(url: string): Promise<GoogleCssLookup> {\n  try {\n    const res = await fetch(url, {\n      headers: { \"User-Agent\": BROWSER_UA },\n      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),\n    });\n    if (res.ok) return { status: \"served\", css: await res.text() };\n    // Measured: Google answers 400 for a family it does not carry and for a\n    // weight it does not serve, and 200 otherwise. A 429 or a 503 says nothing\n    // about the family, so it must not read as one.\n    return { status: res.status === 400 ? \"absent\" : \"unreachable\" };\n  } catch {\n    return { status: \"unreachable\" };\n  }\n}\n\n/** `check` only asks what Google serves, so it collapses both silences into null. */\nconst fetchGoogleCss: FetchCss = async (url) => {\n  const got = await lookupGoogleCss(url);\n  return got.status === \"served\" ? got.css : null;\n};\n\n/** What became of `global.css` — three outcomes, because two of them read the same. */\ntype Wiring = \"written\" | \"already-wired\" | \"no-stylesheet\";\n\nconst WIRING_HINT: Record<Wiring, (family: string) => string> = {\n  written: (family) =>\n    `Wrote the @font-face for \"${family}\" into ${GLOBAL_CSS}, above @theme. Remove \"${family}\" from the Google @import if one is still there, so the page stops fetching it at load.`,\n  // Told apart from \"no stylesheet\" on purpose: they used to share one hint, so\n  // an idempotent re-run instructed the agent to paste a block that was already\n  // in the file, and doing as it was told duplicated the face.\n  \"already-wired\": (family) => `${GLOBAL_CSS} already loads exactly these faces for \"${family}\" — nothing to change.`,\n  \"no-stylesheet\": () =>\n    `No ${GLOBAL_CSS} to write to — paste the \\`fontFace\\` block above the @theme block once the stylesheet exists, or the files just downloaded will never load.`,\n};\n\n/** The network boundary for every catalogue, in one place. */\nconst PROVIDER_DEPS = { lookupGoogleCss, fetchJson };\n\n/** Catalogue names as a human writes them — the ids are lowercase slugs. */\nconst PROVIDER_LABEL: Record<FontProviderName, string> = { google: \"Google Fonts\", fontsource: \"Fontsource\" };\n\n/**\n * What became of the italic, said out loud either way.\n *\n * Both silences cost something. Asking for an italic a catalogue does not ship\n * and being told nothing reads as success, so the brand keeps promising an\n * italic the browser will synthesize. And NOT asking, when the catalogue has\n * one, is the state most brands are in — the one request already made knows the\n * answer, so saying it costs nothing.\n */\nfunction italicHints(\n  family: string,\n  wantedStyles: readonly FontStyle[],\n  availableStyles: string[],\n  downloadedStyles: string[],\n  provider: FontProviderName,\n): string[] {\n  const wanted = wantedStyles.includes(\"italic\");\n  const available = availableStyles.includes(\"italic\");\n  if (wanted && !downloadedStyles.includes(\"italic\")) {\n    return [\n      `NO ITALIC: ${PROVIDER_LABEL[provider]} does not ship an italic for \"${family}\", so none was written. Drop italic from src/brand/BRAND.md, or the browser will slant the upright face instead.`,\n    ];\n  }\n  if (!wanted && available) {\n    return [\n      `${PROVIDER_LABEL[provider]} also ships an italic for \"${family}\", which was NOT downloaded. If the brand uses italic anywhere, re-run with \\`--italic\\` — otherwise the browser slants the upright face, which is not the same shapes.`,\n    ];\n  }\n  return [];\n}\n\nfunction fetchHints({\n  family,\n  downloadedWeights,\n  downloadedStyles,\n  incomplete,\n  wiring,\n  provider,\n  wantedStyles,\n  availableStyles,\n}: {\n  family: string;\n  downloadedWeights: number[];\n  downloadedStyles: string[];\n  incomplete: number[];\n  wiring: Wiring;\n  provider: FontProviderName;\n  wantedStyles: readonly FontStyle[];\n  availableStyles: string[];\n}): string[] {\n  return [\n    WIRING_HINT[wiring](family),\n    ...italicHints(family, wantedStyles, availableStyles, downloadedStyles, provider),\n    `Record the exact weights (${downloadedWeights.join(\", \")}) in src/brand/tokens.json and BRAND.md — a weight tokens.json lists but nothing loads renders as a synthesized fallback, and verify warns about it.`,\n    ...(incomplete.length > 0\n      ? [\n          // The remedy is provider-specific: only a Google family has an @import\n          // to fall back on, and telling an agent to keep one for a Fontsource\n          // family sends it to write an import Google will 400.\n          provider === \"google\"\n            ? `PARTIAL: ${incomplete.join(\", \")} did not download and is NOT in the \\`fontFace\\` block. Re-run \\`baker brand fonts fetch \"${family}\" --weights ${incomplete.join(\",\")}\\` — a Google @import cannot cover those weights, because the build drops it before the page loads.`\n            : `PARTIAL: ${incomplete.join(\", \")} did not download and is NOT in the \\`fontFace\\` block. ${PROVIDER_LABEL[provider]} does not serve them, so re-run \\`baker brand fonts fetch \"${family}\" --weights ${downloadedWeights.join(\",\")}\\` and record only those weights in src/brand/BRAND.md.`,\n        ]\n      : []),\n    `Licensing: ${PROVIDER_LABEL[provider]} carries open-licensed families, which are safe to self-host. A client's own commercial face is not — confirm before re-hosting one.`,\n  ];\n}\n\n/**\n * Put the downloaded face in charge of the family in `global.css`, and say what\n * happened. `readGlobalCss` yields \"\" when the stylesheet is missing, and a\n * stylesheet holding nothing but a @font-face would be worse than none — so\n * that case writes nothing and the caller says so.\n */\nasync function wireFontFaceIntoStylesheet(css: string, family: string, fontFace: string): Promise<Wiring> {\n  if (!css) return \"no-stylesheet\";\n  const wired = upsertFontFaceCss(css, family, fontFace);\n  if (wired === css) return \"already-wired\";\n  await writeFile(path.resolve(process.cwd(), GLOBAL_CSS), wired);\n  return \"written\";\n}\n\n/**\n * Turn a failed lookup into the one remediation that fits it, then exit.\n *\n * Each reason wants a different sentence, and saying the wrong one is worse\n * than saying nothing: a subset miss reported as a weight miss answered\n * `\"Inter\" exists but not at weight 400 — retry with --weights 400`, which an\n * agent can obey forever without ever getting a different result.\n */\nfunction failResolution(family: string, weights: number[], outcome: ResolveOutcome & { ok: false }): Promise<never> {\n  if (outcome.reason === \"unreachable\") {\n    // Whichever catalogue went quiet, the answer is the same: ask again. On\n    // Google we deliberately do NOT retry against Fontsource — it very likely\n    // has the family, and taking it would swap the foundry for good on the\n    // strength of one failed request.\n    return fail(\n      \"CATALOGUE_UNREACHABLE\",\n      `Could not reach ${PROVIDER_LABEL[outcome.provider]} to ask about \"${family}\".`,\n      {\n        action: \"Run the same command again.\",\n        explanation: `${PROVIDER_LABEL[outcome.provider]} did not answer, which is not the same as not having the family — so nothing was concluded from it. Guessing either way would self-host the wrong build, or report a real family as missing.`,\n        provider: outcome.provider,\n      },\n    );\n  }\n  if (outcome.reason === \"ambiguous-subsets\") {\n    return fail(\n      \"SUBSET_AMBIGUOUS\",\n      `${PROVIDER_LABEL[outcome.provider]} serves \"${family}\" in several subsets but reports no unicode-range to tell them apart.`,\n      {\n        action: `Retry with a single --subsets value, e.g. --subsets ${outcome.available[0] ?? \"latin\"}.`,\n        explanation:\n          \"Two @font-face rules with the same family, style and weight and no unicode-range both claim every character, so the last one silently wins and the other file is downloaded and never read.\",\n        available: outcome.available,\n      },\n    );\n  }\n  if (outcome.reason === \"subset\") {\n    return fail(\"SUBSET_NOT_SERVED\", `${PROVIDER_LABEL[outcome.provider]} has \"${family}\", but not in that subset.`, {\n      action: `Retry with --subsets set to one it serves: ${outcome.available.join(\",\")}.`,\n      explanation:\n        \"A family is split into unicode subsets and not every family ships every one. The weights you asked for are fine — only the subset is wrong.\",\n      available: outcome.available,\n    });\n  }\n  if (outcome.reason === \"weight\") {\n    return fail(\n      \"FONT_NOT_SERVED\",\n      `${PROVIDER_LABEL[outcome.provider]} has \"${family}\", but not at weight ${weights.join(\"/\")}.`,\n      {\n        action: `Retry with --weights set to one of these: ${outcome.available.join(\",\")}.`,\n        explanation: \"The family exists; the weight you asked for is not one it ships.\",\n        served: outcome.available,\n      },\n    );\n  }\n  return failUnknownFamily(family);\n}\n\n/**\n * A name no catalogue knows. `resolveBrandFaces` has already probed Google\n * weight by weight before answering `unknown-family`, so there is nothing left\n * to ask it — re-probing here just spent nine more requests to be told the same\n * thing. The usual cause is not a typo but a family that ships only as variants:\n * a client asks for \"Open Sauce\", which nothing carries, while Fontsource has\n * One, Sans and Two. Nothing can pick between those for the brand, so they go in\n * the error for a human to choose from.\n */\nasync function failUnknownFamily(family: string): Promise<never> {\n  const didYouMean = suggestFamilies(family, await fontsourceCatalogue(PROVIDER_DEPS));\n  return fail(\"FONT_NOT_SERVED\", `No font catalogue carries a family called \"${family}\".`, {\n    action: didYouMean.length\n      ? `Did you mean one of these? ${didYouMean.join(\", \")}. Retry with the exact name, and update the --font-* token in ${GLOBAL_CSS} to match whichever you pick.`\n      : `Check the exact spelling, then retry. If it is a commercial typeface, add the file to ${FONTS_DIR} and write the @font-face by hand — it cannot be downloaded.`,\n    explanation: `Tried ${FONT_PROVIDERS.join(\" then \")}. Family names are case- and space-sensitive in every catalogue.`,\n    tried: [...FONT_PROVIDERS],\n    ...(didYouMean.length ? { didYouMean } : {}),\n  });\n}\n\n/** Filenames actually present in src/brand/fonts/. */\nasync function listFontFiles(): Promise<string[]> {\n  try {\n    const entries = await readdir(path.resolve(process.cwd(), FONTS_DIR), { withFileTypes: true });\n    return entries.filter((e) => e.isFile()).map((e) => e.name);\n  } catch {\n    return [];\n  }\n}\n\nasync function readGlobalCss(): Promise<string> {\n  try {\n    return await readFile(path.resolve(process.cwd(), GLOBAL_CSS), \"utf8\");\n  } catch {\n    return \"\";\n  }\n}\n\n/**\n * Which repair this repo actually needs — the three have different consequences\n * and only one of them is `fetch`.\n *\n * Recommending `fetch` for a family a page already self-hosts is the mistake\n * `adopt` exists to prevent: it downloads a DIFFERENT foundry's build of the\n * same name, so the page that rendered correctly starts rendering something\n * else. And `--font-body: \"Open Sauce\"` on a live client is carried by no\n * catalogue at all, so `fetch` cannot even succeed — while the file sat in\n * src/brand/fonts/ the whole time.\n */\nasync function unresolvedAction(css: string, unresolved: string[]): Promise<string> {\n  const { plans } = planFontAdoption(await astroSources(), unresolved);\n  if (plans.length > 0) {\n    const names = plans.map((p) => `\"${p.family}\"`).join(\", \");\n    return `Run \\`baker brand fonts adopt\\` — ${names} is already self-hosted by ${plans[0]?.files.join(\", \")}, so it only needs moving into ${GLOBAL_CSS} to load on every page. Don't fetch it: that downloads a different build of the same face.`;\n  }\n  const viaFontsource = [...fontsourceFamilies(css)];\n  const stranded = unresolved.filter((family) => viaFontsource.includes(family.toLowerCase()));\n  if (stranded.length > 0) {\n    return `Run \\`baker brand fonts fetch \"${stranded[0]}\"\\` to self-host it. Its only provider is an @fontsource import, and that package does not survive a workspace sync — the import is left pointing at nothing, which fails the build before the font check even runs.`;\n  }\n  return `Run \\`baker brand fonts fetch \"${unresolved[0]}\"\\` to self-host it, which writes the @font-face for you. For a face no catalogue carries, add an @font-face pointing at a file in ${FONTS_DIR}.`;\n}\n\nexport const fontsCheckCommand = defineCommand({\n  meta: {\n    name: \"check\",\n    description:\n      \"Verify the brand's fonts really exist. First: every --font-* family in src/styles/global.css must be provided by a local @font-face, or it renders as a fallback on every page — a Google @import does not provide one here, the build drops it before the page loads. Then, for families still requested from Google, ask Google what it actually serves — a weight nobody serves is silently synthesized.\",\n  },\n  async run() {\n    const css = await readGlobalCss();\n    const requests = googleFontRequests(css);\n\n    // Asked first, and asked of every brand — including the ones with no Google\n    // import at all. This command used to answer `selfHosted: true` for those,\n    // which is the one answer that is never safe: a `--font-*` token with no\n    // @font-face and no import is a family nothing hosts, and the page has been\n    // rendering a fallback ever since. 56 of 60 client repos have no Google\n    // import, so that was the answer almost everyone got.\n    const unresolved = unresolvedBrandFamilies(css);\n    if (unresolved.length > 0) {\n      fail(\"FONT_NOT_LOADED\", `Nothing loads ${unresolved.map((f) => `\"${f}\"`).join(\", \")} in ${GLOBAL_CSS}.`, {\n        action: await unresolvedAction(css, unresolved),\n        explanation:\n          \"The family is declared as a brand font but no @font-face provides it, so every page silently renders a fallback. A Google @import does not count: Astro merges component CSS ahead of global.css into one inlined <style>, so the import lands after rules and the browser drops it — measured on a live client site. The client's verify fails on this too.\",\n        unresolved,\n      });\n    }\n\n    if (requests.length === 0) {\n      writeJson({\n        ok: true,\n        data: { families: [], selfHosted: true },\n        hints: [\n          `No Google Fonts requested in ${GLOBAL_CSS}, and every brand face is provided by an @font-face — nothing to verify against Google.`,\n        ],\n      });\n      return;\n    }\n\n    const families = await checkFontRequests(requests, fetchGoogleCss);\n    const broken = families.filter((f) => f.missing.length > 0);\n\n    if (broken.length > 0) {\n      const summary = broken\n        .map((f) =>\n          f.cause === \"unknown-family\"\n            ? `${f.family} (no such family on Google Fonts — check the exact spelling)`\n            : `${f.family} ${f.missing.join(\"/\")} (served: ${f.served.join(\"/\") || \"none\"})`,\n        )\n        .join(\"; \");\n      fail(\"FONT_NOT_SERVED\", `Google Fonts does not serve: ${summary}`, {\n        action: `Correct the family name or weight in ${GLOBAL_CSS} and src/brand/BRAND.md, picking from the \\`served\\` weights below.`,\n        explanation:\n          \"A requested weight Google does not serve is silently synthesized by the browser, so the page looks subtly wrong with nothing failing.\",\n        // The per-family breakdown is the point of the command, so it ships on\n        // the failure path too — otherwise the only remedy is re-running the\n        // command that just failed. Healthy families are included so a\n        // multi-family brand shows what NOT to touch.\n        families,\n      });\n    }\n\n    writeJson({\n      ok: true,\n      data: { families },\n      hints: [\n        \"Every requested family and weight is really served by Google.\",\n        `To stop depending on Google at page load, run \\`baker brand fonts fetch \"<family>\"\\` to self-host into ${FONTS_DIR}.`,\n      ],\n    });\n  },\n});\n\nexport const fontsFetchCommand = defineCommand({\n  meta: {\n    name: \"fetch\",\n    description:\n      \"Download a font from Google Fonts or Fontsource into src/brand/fonts/ and write its @font-face into src/styles/global.css above @theme, so the family actually loads. Use when a brand font should be self-hosted rather than requested from a third party on every page load.\",\n  },\n  args: {\n    family: { type: \"positional\", required: true, description: 'Font family, e.g. \"DM Sans\"' },\n    weights: {\n      type: \"string\",\n      description: \"Comma-separated weights (default: the weights global.css already requests or self-hosts, else 400)\",\n    },\n    subsets: {\n      type: \"string\",\n      description: `Comma-separated unicode subsets (default: the subsets global.css already self-hosts, else ${DEFAULT_SUBSETS_LABEL})`,\n    },\n    italic: {\n      type: \"boolean\",\n      description:\n        \"Also self-host the family's italic faces (default: on when global.css already loads one, off otherwise)\",\n    },\n  },\n  async run({ args }) {\n    const family = String(args.family).trim();\n    if (!family) fail(\"INVALID_FAMILY\", 'Pass a font family, e.g. `baker brand fonts fetch \"DM Sans\"`.');\n\n    const css = await readGlobalCss();\n    const declared = googleFontRequests(css).find((r) => r.family.toLowerCase() === family.toLowerCase());\n    // Self-hosted weights count as \"already requested\". Once the first fetch\n    // has been done and the Google @import removed — which the hints tell the\n    // agent to do — the stylesheet's own @font-face rules are the only surviving\n    // record of which weights this brand uses.\n    const provided = declared?.weights.length ? declared.weights : selfHostedWeights(css, family);\n    const weights = resolveFetchWeights(args.weights, provided);\n    if (weights.length === 0) {\n      fail(\"INVALID_WEIGHTS\", `\"${args.weights}\" has no usable weight — pass whole hundreds, e.g. --weights 400,700.`);\n    }\n\n    // Self-hosted subsets count the same way self-hosted weights do above. The\n    // family's rules are REPLACED, so defaulting a re-run to latin deleted the\n    // latin-ext face an earlier `--subsets latin,latin-ext` downloaded and\n    // orphaned its file — nothing fails, the family stays resolved, and every\n    // accented character quietly falls back.\n    const wanted = new Set(resolveFetchSubsets(args.subsets, selfHostedSubsets(css, family)));\n    // An italic already in the stylesheet turns this on by itself. `fetch` has\n    // no `--no-italic`, so the family can only ever gain its italic here, never\n    // lose one to a flag nobody passed.\n    const styles = resolveFetchStyles(args.italic, selfHostedStyles(css, family));\n\n    const resolved = await resolveBrandFaces(family, weights, [...wanted], PROVIDER_DEPS, styles);\n    if (!resolved.ok) return failResolution(family, weights, resolved);\n    const faces = resolved.faces;\n\n    const fontsDir = path.resolve(process.cwd(), FONTS_DIR);\n    await mkdir(fontsDir, { recursive: true });\n\n    // Only faces whose file really landed may appear in the @font-face block —\n    // a rule pointing at a file that failed to download is exactly the silent\n    // fallback this command exists to prevent.\n    const downloaded: BrandFontFace[] = [];\n    for (const face of faces) {\n      const res = await fetch(face.url, {\n        headers: { \"User-Agent\": BROWSER_UA },\n        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),\n      });\n      if (!res.ok) continue;\n      await writeFile(path.join(fontsDir, fontFileName(face)), Buffer.from(await res.arrayBuffer()));\n      downloaded.push(face);\n    }\n    const written = downloaded.map(fontFileName);\n\n    if (written.length === 0) {\n      fail(\"DOWNLOAD_FAILED\", `Could not download any file for \"${family}\".`, {\n        action: \"Retry; if it keeps failing, keep the Google @import and note it in BRAND.md.\",\n        explanation: \"The font stylesheet resolved but the font files themselves did not download.\",\n      });\n    }\n\n    const fontFace = renderFontFaceCss(downloaded);\n    const downloadedWeights = [...new Set(downloaded.map((f) => f.weight))].sort((a, b) => a - b);\n    const downloadedStyles = [...new Set(downloaded.map((f) => f.style))].sort();\n    const incomplete = weights.filter((w) => !downloadedWeights.includes(w));\n\n    // Wire the face up here rather than handing back a block to paste. The\n    // download above is a real side effect, so a skipped paste left the repo\n    // with the files on disk and nothing loading them — a state that looks done,\n    // renders as a fallback, and only surfaces when the client's verify fails.\n    const wiring = await wireFontFaceIntoStylesheet(css, family, fontFace);\n\n    writeJson({\n      ok: true,\n      data: {\n        family,\n        provider: resolved.provider,\n        weights: downloadedWeights,\n        styles: downloadedStyles,\n        files: written,\n        fontFace,\n        stylesheet: wiring,\n      },\n      hints: fetchHints({\n        family,\n        downloadedWeights,\n        downloadedStyles,\n        incomplete,\n        wiring,\n        provider: resolved.provider,\n        wantedStyles: styles,\n        availableStyles: resolved.availableStyles,\n      }),\n    });\n  },\n});\n\n/** Every `.astro` under src/, so a face declared in any page or component is found. */\nasync function astroSources(): Promise<{ path: string; source: string }[]> {\n  const out: { path: string; source: string }[] = [];\n  let entries: Dirent[];\n  try {\n    entries = await readdir(\"src\", { recursive: true, withFileTypes: true });\n  } catch {\n    return out;\n  }\n  for (const entry of entries) {\n    if (!entry.isFile() || !entry.name.endsWith(\".astro\")) continue;\n    const file = path.posix.join(entry.parentPath ?? \"src\", entry.name);\n    try {\n      out.push({ path: file, source: await readFile(file, \"utf8\") });\n    } catch {\n      // A file that cannot be read is a file this command leaves alone.\n    }\n  }\n  return out;\n}\n\nexport const fontsAdoptCommand = defineCommand({\n  meta: {\n    name: \"adopt\",\n    description:\n      \"Move brand faces a page already self-hosts into src/styles/global.css, so every page loads them instead of just that one. Use when `check` reports a family as not loaded but the font files are already in src/brand/fonts/ — downloading it again would hand that page a different build of the same face.\",\n  },\n  async run() {\n    const css = await readGlobalCss();\n    if (!css) fail(\"NO_STYLESHEET\", `There is no ${GLOBAL_CSS} to adopt faces into.`);\n\n    const unresolved = unresolvedBrandFamilies(css);\n    if (unresolved.length === 0) {\n      writeJson({\n        ok: true,\n        data: { adopted: [], conflicts: [] },\n        hints: [`Every --font-* family in ${GLOBAL_CSS} is already loaded by it — nothing to adopt.`],\n      });\n      return;\n    }\n\n    const { plans, conflicts } = planFontAdoption(await astroSources(), unresolved);\n    const available = new Set(await listFontFiles());\n    const adopted: { family: string; files: string[]; weights: string[] }[] = [];\n    const skipped: { family: string; reason: string }[] = [];\n    let next = css;\n\n    for (const plan of plans) {\n      // A rule pointing at a file that is not there is the same silent fallback\n      // this command exists to remove, so the whole family is left alone.\n      const missing = missingFontFiles(plan.urls, available);\n      if (missing.length > 0) {\n        skipped.push({ family: plan.family, reason: `${missing.join(\", \")} is not in ${FONTS_DIR}` });\n        continue;\n      }\n      next = upsertFontFaceCss(next, plan.family, plan.blocks.join(\"\\n\"));\n      adopted.push({\n        family: plan.family,\n        files: plan.files,\n        weights: plan.blocks.map((b) => b.match(/font-weight\\s*:\\s*([^;]+)/i)?.[1]?.trim() ?? \"400\"),\n      });\n    }\n\n    if (adopted.length === 0) {\n      // Three different facts used to share one sentence. \"No page declares it\"\n      // is false whenever a plan was skipped or conflicted — a page declares it\n      // fine — and the `fetch` it recommended downloads the very substitute\n      // build this command exists to avoid. Say which one actually happened.\n      if (conflicts.length > 0) {\n        fail(\n          \"ADOPTION_CONFLICT\",\n          `${conflicts.map((c) => `\"${c.family}\" is declared differently in ${c.files.join(\" and \")}`).join(\"; \")}.`,\n          {\n            action:\n              \"Make the declarations match — same weights, same files — then re-run. Pick the one whose page renders correctly.\",\n            explanation:\n              \"One global scope holds one mapping per family, so adopting would silently repaint whichever page lost.\",\n            conflicts,\n          },\n        );\n      }\n      if (skipped.length > 0) {\n        fail(\"FONT_FILE_MISSING\", `${skipped.map((s) => `${s.family} — ${s.reason}`).join(\"; \")}.`, {\n          action: `Add the missing file to ${FONTS_DIR}, or fix the src: url() in the page that declares it, then re-run.`,\n          explanation:\n            \"The page declares the face but points at a file that is not in the repo, so the rule renders as a fallback. Moving it into the stylesheet would spread that fallback to every page.\",\n          skipped,\n        });\n      }\n      fail(\"NOTHING_TO_ADOPT\", `No page declares a face for ${unresolved.map((f) => `\"${f}\"`).join(\", \")}.`, {\n        action: `Self-host it instead: \\`baker brand fonts fetch \"${unresolved[0]}\"\\`.`,\n        explanation: \"Adopting only moves faces the repo already ships; it never downloads one.\",\n      });\n    }\n\n    await writeFile(path.resolve(process.cwd(), GLOBAL_CSS), next);\n    for (const plan of plans.filter((p) => adopted.some((a) => a.family === p.family))) {\n      for (const file of plan.files) {\n        const source = await readFile(file, \"utf8\");\n        await writeFile(file, stripFontFaceBlocks(source, plan.family));\n      }\n    }\n\n    writeJson({\n      ok: true,\n      data: { adopted, conflicts, skipped },\n      hints: [\n        `Moved ${adopted.map((a) => `\"${a.family}\" (${a.weights.join(\"/\")})`).join(\", \")} into ${GLOBAL_CSS} and removed the page copies, so every page loads them — not just the one that declared them.`,\n        ...(conflicts.length > 0\n          ? [\n              `CONFLICT: ${conflicts.map((c) => `\"${c.family}\" is declared differently in ${c.files.join(\" and \")}`).join(\"; \")}. One global scope can hold only one mapping, so pick which files the family should use and make the declarations match before re-running.`,\n            ]\n          : []),\n        ...(skipped.length > 0 ? [`SKIPPED: ${skipped.map((s) => `${s.family} — ${s.reason}`).join(\"; \")}.`] : []),\n        `Run \\`baker brand fonts check\\` to confirm nothing is left unresolved.`,\n      ],\n    });\n  },\n});\n\nexport const fontsCommand = defineCommand({\n  meta: {\n    name: \"fonts\",\n    description: `Verify and self-host the brand's typefaces.\n\nStart here: \\`baker brand fonts check\\` — confirms the fonts the brand claims really load.\n\nSubcommands:\n  baker brand fonts check           — fail if any --font-* family has nothing loading it, then ask Google what it actually serves for the ones global.css requests\n  baker brand fonts fetch <family>  — download a family into src/brand/fonts/ and wire its @font-face into src/styles/global.css\n  baker brand fonts adopt           — move faces a page already self-hosts into global.css, so every page loads them. Try this BEFORE fetch when the font files are already in src/brand/fonts/`,\n  },\n  subCommands: {\n    check: fontsCheckCommand,\n    fetch: fontsFetchCommand,\n    adopt: fontsAdoptCommand,\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,SAAS,OAAO,SAAS,UAAU,iBAAiB;AACpD,OAAO,UAAU;AACjB,SAAS,qBAAqB;AAiC9B,IAAM,aAAa,KAAK,KAAK,OAAO,UAAU,YAAY;AAC1D,IAAM,YAAY,KAAK,KAAK,OAAO,SAAS,OAAO;AACnD,IAAM,wBAAwB,gBAAgB,KAAK,GAAG;AAItD,IAAM,aAAa;AAEnB,eAAe;AAAA,EACb,SAAS;AAAA,EACT,aACE;AAAA,EACF,MAAM,CAAC;AACT,CAAC;AAED,eAAe;AAAA,EACb,SAAS;AAAA,EACT,aACE;AAAA,EACF,MAAM,CAAC;AACT,CAAC;AAED,eAAe;AAAA,EACb,SAAS;AAAA,EACT,aACE;AAAA,EACF,MAAM;AAAA,IACJ,QAAQ,EAAE,MAAM,UAAU,aAAa,+BAA+B,UAAU,KAAK;AAAA,IACrF,SAAS;AAAA,MACP,MAAM;AAAA,MACN,aAAa;AAAA,MACb,UAAU;AAAA,IACZ;AAAA,IACA,SAAS;AAAA,MACP,MAAM;AAAA,MACN,aAAa,6FAA6F,qBAAqB;AAAA,MAC/H,UAAU;AAAA,IACZ;AAAA,IACA,QAAQ;AAAA,MACN,MAAM;AAAA,MACN,aACE;AAAA,MACF,UAAU;AAAA,IACZ;AAAA,EACF;AACF,CAAC;AAED,SAAS,KACP,MACA,SACA,KACO;AACP,YAAU,EAAE,IAAI,OAAO,OAAO,EAAE,MAAM,SAAS,GAAI,MAAM,EAAE,IAAI,IAAI,CAAC,EAAG,EAAE,CAAC;AAC1E,UAAQ,KAAK,CAAC;AAChB;AAIA,IAAM,qBAAqB;AAY3B,eAAsB,UAAU,KAA+B;AAC7D,QAAM,MAAM,MAAM,MAAM,KAAK;AAAA,IAC3B,SAAS,EAAE,cAAc,WAAW;AAAA,IACpC,QAAQ,YAAY,QAAQ,kBAAkB;AAAA,EAChD,CAAC;AACD,MAAI,IAAI,WAAW,IAAK,QAAO;AAC/B,MAAI,CAAC,IAAI,GAAI,OAAM,IAAI,MAAM,uBAAuB,IAAI,MAAM,EAAE;AAChE,SAAO,MAAM,IAAI,KAAK;AACxB;AAEA,eAAsB,gBAAgB,KAAuC;AAC3E,MAAI;AACF,UAAM,MAAM,MAAM,MAAM,KAAK;AAAA,MAC3B,SAAS,EAAE,cAAc,WAAW;AAAA,MACpC,QAAQ,YAAY,QAAQ,kBAAkB;AAAA,IAChD,CAAC;AACD,QAAI,IAAI,GAAI,QAAO,EAAE,QAAQ,UAAU,KAAK,MAAM,IAAI,KAAK,EAAE;AAI7D,WAAO,EAAE,QAAQ,IAAI,WAAW,MAAM,WAAW,cAAc;AAAA,EACjE,QAAQ;AACN,WAAO,EAAE,QAAQ,cAAc;AAAA,EACjC;AACF;AAGA,IAAM,iBAA2B,OAAO,QAAQ;AAC9C,QAAM,MAAM,MAAM,gBAAgB,GAAG;AACrC,SAAO,IAAI,WAAW,WAAW,IAAI,MAAM;AAC7C;AAKA,IAAM,cAA0D;AAAA,EAC9D,SAAS,CAAC,WACR,6BAA6B,MAAM,UAAU,UAAU,2BAA2B,MAAM;AAAA;AAAA;AAAA;AAAA,EAI1F,iBAAiB,CAAC,WAAW,GAAG,UAAU,2CAA2C,MAAM;AAAA,EAC3F,iBAAiB,MACf,MAAM,UAAU;AACpB;AAGA,IAAM,gBAAgB,EAAE,iBAAiB,UAAU;AAGnD,IAAM,iBAAmD,EAAE,QAAQ,gBAAgB,YAAY,aAAa;AAW5G,SAAS,YACP,QACA,cACA,iBACA,kBACA,UACU;AACV,QAAM,SAAS,aAAa,SAAS,QAAQ;AAC7C,QAAM,YAAY,gBAAgB,SAAS,QAAQ;AACnD,MAAI,UAAU,CAAC,iBAAiB,SAAS,QAAQ,GAAG;AAClD,WAAO;AAAA,MACL,cAAc,eAAe,QAAQ,CAAC,iCAAiC,MAAM;AAAA,IAC/E;AAAA,EACF;AACA,MAAI,CAAC,UAAU,WAAW;AACxB,WAAO;AAAA,MACL,GAAG,eAAe,QAAQ,CAAC,8BAA8B,MAAM;AAAA,IACjE;AAAA,EACF;AACA,SAAO,CAAC;AACV;AAEA,SAAS,WAAW;AAAA,EAClB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GASa;AACX,SAAO;AAAA,IACL,YAAY,MAAM,EAAE,MAAM;AAAA,IAC1B,GAAG,YAAY,QAAQ,cAAc,iBAAiB,kBAAkB,QAAQ;AAAA,IAChF,6BAA6B,kBAAkB,KAAK,IAAI,CAAC;AAAA,IACzD,GAAI,WAAW,SAAS,IACpB;AAAA;AAAA;AAAA;AAAA,MAIE,aAAa,WACT,YAAY,WAAW,KAAK,IAAI,CAAC,6FAA6F,MAAM,eAAe,WAAW,KAAK,GAAG,CAAC,6GACvK,YAAY,WAAW,KAAK,IAAI,CAAC,2DAA2D,eAAe,QAAQ,CAAC,8DAA8D,MAAM,eAAe,kBAAkB,KAAK,GAAG,CAAC;AAAA,IACxO,IACA,CAAC;AAAA,IACL,cAAc,eAAe,QAAQ,CAAC;AAAA,EACxC;AACF;AAQA,eAAe,2BAA2B,KAAa,QAAgB,UAAmC;AACxG,MAAI,CAAC,IAAK,QAAO;AACjB,QAAM,QAAQ,kBAAkB,KAAK,QAAQ,QAAQ;AACrD,MAAI,UAAU,IAAK,QAAO;AAC1B,QAAM,UAAU,KAAK,QAAQ,QAAQ,IAAI,GAAG,UAAU,GAAG,KAAK;AAC9D,SAAO;AACT;AAUA,SAAS,eAAe,QAAgB,SAAmB,SAAyD;AAClH,MAAI,QAAQ,WAAW,eAAe;AAKpC,WAAO;AAAA,MACL;AAAA,MACA,mBAAmB,eAAe,QAAQ,QAAQ,CAAC,kBAAkB,MAAM;AAAA,MAC3E;AAAA,QACE,QAAQ;AAAA,QACR,aAAa,GAAG,eAAe,QAAQ,QAAQ,CAAC;AAAA,QAChD,UAAU,QAAQ;AAAA,MACpB;AAAA,IACF;AAAA,EACF;AACA,MAAI,QAAQ,WAAW,qBAAqB;AAC1C,WAAO;AAAA,MACL;AAAA,MACA,GAAG,eAAe,QAAQ,QAAQ,CAAC,YAAY,MAAM;AAAA,MACrD;AAAA,QACE,QAAQ,uDAAuD,QAAQ,UAAU,CAAC,KAAK,OAAO;AAAA,QAC9F,aACE;AAAA,QACF,WAAW,QAAQ;AAAA,MACrB;AAAA,IACF;AAAA,EACF;AACA,MAAI,QAAQ,WAAW,UAAU;AAC/B,WAAO,KAAK,qBAAqB,GAAG,eAAe,QAAQ,QAAQ,CAAC,SAAS,MAAM,8BAA8B;AAAA,MAC/G,QAAQ,8CAA8C,QAAQ,UAAU,KAAK,GAAG,CAAC;AAAA,MACjF,aACE;AAAA,MACF,WAAW,QAAQ;AAAA,IACrB,CAAC;AAAA,EACH;AACA,MAAI,QAAQ,WAAW,UAAU;AAC/B,WAAO;AAAA,MACL;AAAA,MACA,GAAG,eAAe,QAAQ,QAAQ,CAAC,SAAS,MAAM,wBAAwB,QAAQ,KAAK,GAAG,CAAC;AAAA,MAC3F;AAAA,QACE,QAAQ,6CAA6C,QAAQ,UAAU,KAAK,GAAG,CAAC;AAAA,QAChF,aAAa;AAAA,QACb,QAAQ,QAAQ;AAAA,MAClB;AAAA,IACF;AAAA,EACF;AACA,SAAO,kBAAkB,MAAM;AACjC;AAWA,eAAe,kBAAkB,QAAgC;AAC/D,QAAM,aAAa,gBAAgB,QAAQ,MAAM,oBAAoB,aAAa,CAAC;AACnF,SAAO,KAAK,mBAAmB,8CAA8C,MAAM,MAAM;AAAA,IACvF,QAAQ,WAAW,SACf,8BAA8B,WAAW,KAAK,IAAI,CAAC,iEAAiE,UAAU,kCAC9H,yFAAyF,SAAS;AAAA,IACtG,aAAa,SAAS,eAAe,KAAK,QAAQ,CAAC;AAAA,IACnD,OAAO,CAAC,GAAG,cAAc;AAAA,IACzB,GAAI,WAAW,SAAS,EAAE,WAAW,IAAI,CAAC;AAAA,EAC5C,CAAC;AACH;AAGA,eAAe,gBAAmC;AAChD,MAAI;AACF,UAAM,UAAU,MAAM,QAAQ,KAAK,QAAQ,QAAQ,IAAI,GAAG,SAAS,GAAG,EAAE,eAAe,KAAK,CAAC;AAC7F,WAAO,QAAQ,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI;AAAA,EAC5D,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;AAEA,eAAe,gBAAiC;AAC9C,MAAI;AACF,WAAO,MAAM,SAAS,KAAK,QAAQ,QAAQ,IAAI,GAAG,UAAU,GAAG,MAAM;AAAA,EACvE,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAaA,eAAe,iBAAiB,KAAa,YAAuC;AAClF,QAAM,EAAE,MAAM,IAAI,iBAAiB,MAAM,aAAa,GAAG,UAAU;AACnE,MAAI,MAAM,SAAS,GAAG;AACpB,UAAM,QAAQ,MAAM,IAAI,CAAC,MAAM,IAAI,EAAE,MAAM,GAAG,EAAE,KAAK,IAAI;AACzD,WAAO,0CAAqC,KAAK,8BAA8B,MAAM,CAAC,GAAG,MAAM,KAAK,IAAI,CAAC,kCAAkC,UAAU;AAAA,EACvJ;AACA,QAAM,gBAAgB,CAAC,GAAG,mBAAmB,GAAG,CAAC;AACjD,QAAM,WAAW,WAAW,OAAO,CAAC,WAAW,cAAc,SAAS,OAAO,YAAY,CAAC,CAAC;AAC3F,MAAI,SAAS,SAAS,GAAG;AACvB,WAAO,kCAAkC,SAAS,CAAC,CAAC;AAAA,EACtD;AACA,SAAO,kCAAkC,WAAW,CAAC,CAAC,sIAAsI,SAAS;AACvM;AAEO,IAAM,oBAAoB,cAAc;AAAA,EAC7C,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,aACE;AAAA,EACJ;AAAA,EACA,MAAM,MAAM;AACV,UAAM,MAAM,MAAM,cAAc;AAChC,UAAM,WAAW,mBAAmB,GAAG;AAQvC,UAAM,aAAa,wBAAwB,GAAG;AAC9C,QAAI,WAAW,SAAS,GAAG;AACzB,WAAK,mBAAmB,iBAAiB,WAAW,IAAI,CAAC,MAAM,IAAI,CAAC,GAAG,EAAE,KAAK,IAAI,CAAC,OAAO,UAAU,KAAK;AAAA,QACvG,QAAQ,MAAM,iBAAiB,KAAK,UAAU;AAAA,QAC9C,aACE;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH;AAEA,QAAI,SAAS,WAAW,GAAG;AACzB,gBAAU;AAAA,QACR,IAAI;AAAA,QACJ,MAAM,EAAE,UAAU,CAAC,GAAG,YAAY,KAAK;AAAA,QACvC,OAAO;AAAA,UACL,gCAAgC,UAAU;AAAA,QAC5C;AAAA,MACF,CAAC;AACD;AAAA,IACF;AAEA,UAAM,WAAW,MAAM,kBAAkB,UAAU,cAAc;AACjE,UAAM,SAAS,SAAS,OAAO,CAAC,MAAM,EAAE,QAAQ,SAAS,CAAC;AAE1D,QAAI,OAAO,SAAS,GAAG;AACrB,YAAM,UAAU,OACb;AAAA,QAAI,CAAC,MACJ,EAAE,UAAU,mBACR,GAAG,EAAE,MAAM,sEACX,GAAG,EAAE,MAAM,IAAI,EAAE,QAAQ,KAAK,GAAG,CAAC,aAAa,EAAE,OAAO,KAAK,GAAG,KAAK,MAAM;AAAA,MACjF,EACC,KAAK,IAAI;AACZ,WAAK,mBAAmB,gCAAgC,OAAO,IAAI;AAAA,QACjE,QAAQ,wCAAwC,UAAU;AAAA,QAC1D,aACE;AAAA;AAAA;AAAA;AAAA;AAAA,QAKF;AAAA,MACF,CAAC;AAAA,IACH;AAEA,cAAU;AAAA,MACR,IAAI;AAAA,MACJ,MAAM,EAAE,SAAS;AAAA,MACjB,OAAO;AAAA,QACL;AAAA,QACA,0GAA0G,SAAS;AAAA,MACrH;AAAA,IACF,CAAC;AAAA,EACH;AACF,CAAC;AAEM,IAAM,oBAAoB,cAAc;AAAA,EAC7C,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,aACE;AAAA,EACJ;AAAA,EACA,MAAM;AAAA,IACJ,QAAQ,EAAE,MAAM,cAAc,UAAU,MAAM,aAAa,8BAA8B;AAAA,IACzF,SAAS;AAAA,MACP,MAAM;AAAA,MACN,aAAa;AAAA,IACf;AAAA,IACA,SAAS;AAAA,MACP,MAAM;AAAA,MACN,aAAa,6FAA6F,qBAAqB;AAAA,IACjI;AAAA,IACA,QAAQ;AAAA,MACN,MAAM;AAAA,MACN,aACE;AAAA,IACJ;AAAA,EACF;AAAA,EACA,MAAM,IAAI,EAAE,KAAK,GAAG;AAClB,UAAM,SAAS,OAAO,KAAK,MAAM,EAAE,KAAK;AACxC,QAAI,CAAC,OAAQ,MAAK,kBAAkB,+DAA+D;AAEnG,UAAM,MAAM,MAAM,cAAc;AAChC,UAAM,WAAW,mBAAmB,GAAG,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,YAAY,MAAM,OAAO,YAAY,CAAC;AAKpG,UAAM,WAAW,UAAU,QAAQ,SAAS,SAAS,UAAU,kBAAkB,KAAK,MAAM;AAC5F,UAAM,UAAU,oBAAoB,KAAK,SAAS,QAAQ;AAC1D,QAAI,QAAQ,WAAW,GAAG;AACxB,WAAK,mBAAmB,IAAI,KAAK,OAAO,4EAAuE;AAAA,IACjH;AAOA,UAAM,SAAS,IAAI,IAAI,oBAAoB,KAAK,SAAS,kBAAkB,KAAK,MAAM,CAAC,CAAC;AAIxF,UAAM,SAAS,mBAAmB,KAAK,QAAQ,iBAAiB,KAAK,MAAM,CAAC;AAE5E,UAAM,WAAW,MAAM,kBAAkB,QAAQ,SAAS,CAAC,GAAG,MAAM,GAAG,eAAe,MAAM;AAC5F,QAAI,CAAC,SAAS,GAAI,QAAO,eAAe,QAAQ,SAAS,QAAQ;AACjE,UAAM,QAAQ,SAAS;AAEvB,UAAM,WAAW,KAAK,QAAQ,QAAQ,IAAI,GAAG,SAAS;AACtD,UAAM,MAAM,UAAU,EAAE,WAAW,KAAK,CAAC;AAKzC,UAAM,aAA8B,CAAC;AACrC,eAAW,QAAQ,OAAO;AACxB,YAAM,MAAM,MAAM,MAAM,KAAK,KAAK;AAAA,QAChC,SAAS,EAAE,cAAc,WAAW;AAAA,QACpC,QAAQ,YAAY,QAAQ,kBAAkB;AAAA,MAChD,CAAC;AACD,UAAI,CAAC,IAAI,GAAI;AACb,YAAM,UAAU,KAAK,KAAK,UAAU,aAAa,IAAI,CAAC,GAAG,OAAO,KAAK,MAAM,IAAI,YAAY,CAAC,CAAC;AAC7F,iBAAW,KAAK,IAAI;AAAA,IACtB;AACA,UAAM,UAAU,WAAW,IAAI,YAAY;AAE3C,QAAI,QAAQ,WAAW,GAAG;AACxB,WAAK,mBAAmB,oCAAoC,MAAM,MAAM;AAAA,QACtE,QAAQ;AAAA,QACR,aAAa;AAAA,MACf,CAAC;AAAA,IACH;AAEA,UAAM,WAAW,kBAAkB,UAAU;AAC7C,UAAM,oBAAoB,CAAC,GAAG,IAAI,IAAI,WAAW,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,MAAM,IAAI,CAAC;AAC5F,UAAM,mBAAmB,CAAC,GAAG,IAAI,IAAI,WAAW,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,EAAE,KAAK;AAC3E,UAAM,aAAa,QAAQ,OAAO,CAAC,MAAM,CAAC,kBAAkB,SAAS,CAAC,CAAC;AAMvE,UAAM,SAAS,MAAM,2BAA2B,KAAK,QAAQ,QAAQ;AAErE,cAAU;AAAA,MACR,IAAI;AAAA,MACJ,MAAM;AAAA,QACJ;AAAA,QACA,UAAU,SAAS;AAAA,QACnB,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO;AAAA,QACP;AAAA,QACA,YAAY;AAAA,MACd;AAAA,MACA,OAAO,WAAW;AAAA,QAChB;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,UAAU,SAAS;AAAA,QACnB,cAAc;AAAA,QACd,iBAAiB,SAAS;AAAA,MAC5B,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AACF,CAAC;AAGD,eAAe,eAA4D;AACzE,QAAM,MAA0C,CAAC;AACjD,MAAI;AACJ,MAAI;AACF,cAAU,MAAM,QAAQ,OAAO,EAAE,WAAW,MAAM,eAAe,KAAK,CAAC;AAAA,EACzE,QAAQ;AACN,WAAO;AAAA,EACT;AACA,aAAW,SAAS,SAAS;AAC3B,QAAI,CAAC,MAAM,OAAO,KAAK,CAAC,MAAM,KAAK,SAAS,QAAQ,EAAG;AACvD,UAAM,OAAO,KAAK,MAAM,KAAK,MAAM,cAAc,OAAO,MAAM,IAAI;AAClE,QAAI;AACF,UAAI,KAAK,EAAE,MAAM,MAAM,QAAQ,MAAM,SAAS,MAAM,MAAM,EAAE,CAAC;AAAA,IAC/D,QAAQ;AAAA,IAER;AAAA,EACF;AACA,SAAO;AACT;AAEO,IAAM,oBAAoB,cAAc;AAAA,EAC7C,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,aACE;AAAA,EACJ;AAAA,EACA,MAAM,MAAM;AACV,UAAM,MAAM,MAAM,cAAc;AAChC,QAAI,CAAC,IAAK,MAAK,iBAAiB,eAAe,UAAU,uBAAuB;AAEhF,UAAM,aAAa,wBAAwB,GAAG;AAC9C,QAAI,WAAW,WAAW,GAAG;AAC3B,gBAAU;AAAA,QACR,IAAI;AAAA,QACJ,MAAM,EAAE,SAAS,CAAC,GAAG,WAAW,CAAC,EAAE;AAAA,QACnC,OAAO,CAAC,4BAA4B,UAAU,mDAA8C;AAAA,MAC9F,CAAC;AACD;AAAA,IACF;AAEA,UAAM,EAAE,OAAO,UAAU,IAAI,iBAAiB,MAAM,aAAa,GAAG,UAAU;AAC9E,UAAM,YAAY,IAAI,IAAI,MAAM,cAAc,CAAC;AAC/C,UAAM,UAAoE,CAAC;AAC3E,UAAM,UAAgD,CAAC;AACvD,QAAI,OAAO;AAEX,eAAW,QAAQ,OAAO;AAGxB,YAAM,UAAU,iBAAiB,KAAK,MAAM,SAAS;AACrD,UAAI,QAAQ,SAAS,GAAG;AACtB,gBAAQ,KAAK,EAAE,QAAQ,KAAK,QAAQ,QAAQ,GAAG,QAAQ,KAAK,IAAI,CAAC,cAAc,SAAS,GAAG,CAAC;AAC5F;AAAA,MACF;AACA,aAAO,kBAAkB,MAAM,KAAK,QAAQ,KAAK,OAAO,KAAK,IAAI,CAAC;AAClE,cAAQ,KAAK;AAAA,QACX,QAAQ,KAAK;AAAA,QACb,OAAO,KAAK;AAAA,QACZ,SAAS,KAAK,OAAO,IAAI,CAAC,MAAM,EAAE,MAAM,4BAA4B,IAAI,CAAC,GAAG,KAAK,KAAK,KAAK;AAAA,MAC7F,CAAC;AAAA,IACH;AAEA,QAAI,QAAQ,WAAW,GAAG;AAKxB,UAAI,UAAU,SAAS,GAAG;AACxB;AAAA,UACE;AAAA,UACA,GAAG,UAAU,IAAI,CAAC,MAAM,IAAI,EAAE,MAAM,gCAAgC,EAAE,MAAM,KAAK,OAAO,CAAC,EAAE,EAAE,KAAK,IAAI,CAAC;AAAA,UACvG;AAAA,YACE,QACE;AAAA,YACF,aACE;AAAA,YACF;AAAA,UACF;AAAA,QACF;AAAA,MACF;AACA,UAAI,QAAQ,SAAS,GAAG;AACtB,aAAK,qBAAqB,GAAG,QAAQ,IAAI,CAAC,MAAM,GAAG,EAAE,MAAM,WAAM,EAAE,MAAM,EAAE,EAAE,KAAK,IAAI,CAAC,KAAK;AAAA,UAC1F,QAAQ,2BAA2B,SAAS;AAAA,UAC5C,aACE;AAAA,UACF;AAAA,QACF,CAAC;AAAA,MACH;AACA,WAAK,oBAAoB,+BAA+B,WAAW,IAAI,CAAC,MAAM,IAAI,CAAC,GAAG,EAAE,KAAK,IAAI,CAAC,KAAK;AAAA,QACrG,QAAQ,oDAAoD,WAAW,CAAC,CAAC;AAAA,QACzE,aAAa;AAAA,MACf,CAAC;AAAA,IACH;AAEA,UAAM,UAAU,KAAK,QAAQ,QAAQ,IAAI,GAAG,UAAU,GAAG,IAAI;AAC7D,eAAW,QAAQ,MAAM,OAAO,CAAC,MAAM,QAAQ,KAAK,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,GAAG;AAClF,iBAAW,QAAQ,KAAK,OAAO;AAC7B,cAAM,SAAS,MAAM,SAAS,MAAM,MAAM;AAC1C,cAAM,UAAU,MAAM,oBAAoB,QAAQ,KAAK,MAAM,CAAC;AAAA,MAChE;AAAA,IACF;AAEA,cAAU;AAAA,MACR,IAAI;AAAA,MACJ,MAAM,EAAE,SAAS,WAAW,QAAQ;AAAA,MACpC,OAAO;AAAA,QACL,SAAS,QAAQ,IAAI,CAAC,MAAM,IAAI,EAAE,MAAM,MAAM,EAAE,QAAQ,KAAK,GAAG,CAAC,GAAG,EAAE,KAAK,IAAI,CAAC,SAAS,UAAU;AAAA,QACnG,GAAI,UAAU,SAAS,IACnB;AAAA,UACE,aAAa,UAAU,IAAI,CAAC,MAAM,IAAI,EAAE,MAAM,gCAAgC,EAAE,MAAM,KAAK,OAAO,CAAC,EAAE,EAAE,KAAK,IAAI,CAAC;AAAA,QACnH,IACA,CAAC;AAAA,QACL,GAAI,QAAQ,SAAS,IAAI,CAAC,YAAY,QAAQ,IAAI,CAAC,MAAM,GAAG,EAAE,MAAM,WAAM,EAAE,MAAM,EAAE,EAAE,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;AAAA,QACxG;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AACF,CAAC;AAEM,IAAM,eAAe,cAAc;AAAA,EACxC,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQf;AAAA,EACA,aAAa;AAAA,IACX,OAAO;AAAA,IACP,OAAO;AAAA,IACP,OAAO;AAAA,EACT;AACF,CAAC;","names":[]}

package/dist/chunk-I3DIZWN5.js

@@ -0,0 +1,97 @@
+import {
+  JEV_MODEL,
+  askJev
+} from "./chunk-MGKHFGLV.js";
+
+// src/engine/lib/remembered-nouls.ts
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+
+// src/engine/lib/file-lock.ts
+import { randomUUID } from "crypto";
+import { mkdir, rename, rm, stat, writeFile } from "fs/promises";
+import path from "path";
+var LOCK_STALE_MS = 1e4;
+var LOCK_WAIT_MS = 20;
+async function updateLockedFile(file, change) {
+  await mkdir(path.dirname(file), { recursive: true });
+  const lock = `${file}.lock`;
+  await acquireLock(lock);
+  try {
+    const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(temp, await change(), "utf8");
+    await rename(temp, file);
+  } finally {
+    await rm(lock, { force: true });
+  }
+}
+async function acquireLock(lock) {
+  for (; ; ) {
+    try {
+      await writeFile(lock, String(process.pid), { flag: "wx" });
+      return;
+    } catch (e) {
+      if (e.code !== "EEXIST") throw e;
+    }
+    const held = await stat(lock).catch(() => null);
+    if (held && Date.now() - held.mtimeMs > LOCK_STALE_MS) await rm(lock, { force: true });
+    await new Promise((resolve) => setTimeout(resolve, LOCK_WAIT_MS));
+  }
+}
+
+// src/engine/lib/remembered-nouls.ts
+var PER_REQUEST = 200;
+var MAX_REMEMBERED = 2e4;
+function keyOf(question) {
+  return createHash("sha256").update(JSON.stringify([JEV_MODEL, question.instructions])).digest("hex").slice(0, 32);
+}
+async function remembered(file) {
+  const parsed = await readFile(file, "utf8").then(JSON.parse, () => ({}));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+  return Object.fromEntries(
+    Object.entries(parsed).filter((e) => typeof e[1] === "number")
+  );
+}
+async function rememberedNouls(questions, opts) {
+  if (questions.length === 0) return [];
+  const keys = questions.map(keyOf);
+  const known = opts.file ? await remembered(opts.file) : {};
+  const missing = [...new Set(keys.filter((k) => known[k] === void 0))];
+  const byKey = new Map(questions.map((q, i) => [keys[i], q]));
+  const batches = [];
+  for (let i = 0; i < missing.length; i += PER_REQUEST) batches.push(missing.slice(i, i + PER_REQUEST));
+  const answered = await Promise.all(
+    batches.map((batch) => opts.ask(batch.flatMap((k) => byKey.get(k) ?? [])).catch(() => null))
+  );
+  if (answered.some((a) => a === null || a.length === 0)) return null;
+  const fresh = {};
+  batches.forEach((batch, b) => {
+    batch.forEach((k, i) => {
+      const answer = answered[b]?.[i];
+      if (answer !== void 0) fresh[k] = answer;
+    });
+  });
+  const all = { ...known, ...fresh };
+  const file = opts.file;
+  if (file && missing.length > 0) {
+    await updateLockedFile(file, async () => {
+      const kept = Object.entries({ ...await remembered(file), ...fresh }).slice(-MAX_REMEMBERED);
+      return JSON.stringify(Object.fromEntries(kept));
+    }).catch(() => void 0);
+  }
+  const answers = keys.map((k) => all[k]);
+  return answers.every((a) => a !== void 0) ? answers : null;
+}
+function jevAsker(onSpend) {
+  return (questions) => askJev(questions, onSpend);
+}
+function rememberedJev(file, onSpend) {
+  const ask = jevAsker(onSpend);
+  return (questions) => rememberedNouls(questions, { ask, file });
+}
+
+export {
+  updateLockedFile,
+  rememberedJev
+};
+//# sourceMappingURL=chunk-I3DIZWN5.js.map

package/dist/chunk-I3DIZWN5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/engine/lib/remembered-nouls.ts","../src/engine/lib/file-lock.ts"],"sourcesContent":["/**\n * Yes/no answers from the decision model (Jev, `askJev`), asked in batches and remembered by\n * question, so the same text asked the same question gets the same answer on every run. A gate\n * that counts findings (the landing critique's block count, an idea's warnings) must not flip\n * because Jev answered 0.69 one run and 0.71 the next.\n */\nimport { createHash } from \"node:crypto\";\nimport { readFile } from \"node:fs/promises\";\nimport { askJev, JEV_MODEL } from \"../nodes/local/lib/jev.ts\";\nimport type { ReviewUsage } from \"../nodes/local/lib/render-review.ts\";\nimport { updateLockedFile } from \"./file-lock.ts\";\n\nexport type NoulQuestion = { instructions: Record<string, string> };\n/** Each question's probability, in order, or null when no answer came back. */\nexport type AskNouls = (questions: readonly NoulQuestion[]) => Promise<number[] | null>;\n\n/** Several hundred fit in one request at the same latency; this keeps each well inside Jev's context. */\nconst PER_REQUEST = 200;\n/** The file never grows past this many answers; the oldest are dropped first. */\nconst MAX_REMEMBERED = 20_000;\n\nfunction keyOf(question: NoulQuestion): string {\n  return createHash(\"sha256\")\n    .update(JSON.stringify([JEV_MODEL, question.instructions]))\n    .digest(\"hex\")\n    .slice(0, 32);\n}\n\nasync function remembered(file: string): Promise<Record<string, number>> {\n  const parsed: unknown = await readFile(file, \"utf8\").then(JSON.parse, () => ({}));\n  if (!parsed || typeof parsed !== \"object\" || Array.isArray(parsed)) return {};\n  return Object.fromEntries(\n    Object.entries(parsed as Record<string, unknown>).filter((e): e is [string, number] => typeof e[1] === \"number\"),\n  );\n}\n\n/**\n * The probability each statement is true, in order: from `file` when asked before, else from\n * `ask`, in requests of `PER_REQUEST` sent at once. Null when any request failed, so the caller\n * takes its fallback for the whole decision rather than half of it. Never throws.\n */\nexport async function rememberedNouls(\n  questions: readonly NoulQuestion[],\n  opts: { ask: AskNouls; file?: string },\n): Promise<number[] | null> {\n  if (questions.length === 0) return [];\n  const keys = questions.map(keyOf);\n  const known = opts.file ? await remembered(opts.file) : {};\n  const missing = [...new Set(keys.filter((k) => known[k] === undefined))];\n  const byKey = new Map(questions.map((q, i) => [keys[i], q]));\n  const batches: string[][] = [];\n  for (let i = 0; i < missing.length; i += PER_REQUEST) batches.push(missing.slice(i, i + PER_REQUEST));\n  const answered = await Promise.all(\n    batches.map((batch) => opts.ask(batch.flatMap((k) => byKey.get(k) ?? [])).catch(() => null)),\n  );\n  if (answered.some((a) => a === null || a.length === 0)) return null;\n  const fresh: Record<string, number> = {};\n  batches.forEach((batch, b) => {\n    batch.forEach((k, i) => {\n      const answer = answered[b]?.[i];\n      if (answer !== undefined) fresh[k] = answer;\n    });\n  });\n  const all = { ...known, ...fresh };\n  const file = opts.file;\n  if (file && missing.length > 0) {\n    // Read again under the lock: another caller sharing the file may have written its answers since.\n    await updateLockedFile(file, async () => {\n      const kept = Object.entries({ ...(await remembered(file)), ...fresh }).slice(-MAX_REMEMBERED);\n      return JSON.stringify(Object.fromEntries(kept));\n    }).catch(() => undefined);\n  }\n  const answers = keys.map((k) => all[k]);\n  return answers.every((a): a is number => a !== undefined) ? answers : null;\n}\n\n/** The real decision model, its spend reported to `onSpend`. */\nexport function jevAsker(onSpend?: (usage: ReviewUsage) => void): AskNouls {\n  return (questions) => askJev(questions, onSpend);\n}\n\n/** The real decision model behind the answers kept in `file`: what every CLI caller asks through. */\nexport function rememberedJev(file: string, onSpend?: (usage: ReviewUsage) => void): AskNouls {\n  const ask = jevAsker(onSpend);\n  return (questions) => rememberedNouls(questions, { ask, file });\n}\n","/**\n * Change a JSON file that several processes (or several calls in one) update at once: read,\n * change and write it whole under a lock file, through a temp file renamed into place, so no\n * writer erases another's entries and no reader sees half a file.\n */\nimport { randomUUID } from \"node:crypto\";\nimport { mkdir, rename, rm, stat, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\n\nconst LOCK_STALE_MS = 10_000;\nconst LOCK_WAIT_MS = 20;\n\n/** Run `change` with `file` locked, and write what it returns as the file's whole new content. */\nexport async function updateLockedFile(file: string, change: () => Promise<string>): Promise<void> {\n  await mkdir(path.dirname(file), { recursive: true });\n  const lock = `${file}.lock`;\n  await acquireLock(lock);\n  try {\n    const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;\n    await writeFile(temp, await change(), \"utf8\");\n    await rename(temp, file);\n  } finally {\n    await rm(lock, { force: true });\n  }\n}\n\nasync function acquireLock(lock: string): Promise<void> {\n  for (;;) {\n    try {\n      await writeFile(lock, String(process.pid), { flag: \"wx\" });\n      return;\n    } catch (e) {\n      if ((e as NodeJS.ErrnoException).code !== \"EEXIST\") throw e;\n    }\n    // A process that died holding the lock leaves it behind: a lock this old is no one's.\n    const held = await stat(lock).catch(() => null);\n    if (held && Date.now() - held.mtimeMs > LOCK_STALE_MS) await rm(lock, { force: true });\n    await new Promise((resolve) => setTimeout(resolve, LOCK_WAIT_MS));\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-IJMWEO4P.js

@@ -0,0 +1,57 @@
+// src/commands/avatars/profile.ts
+var TEXT_FIELDS = [
+  ["subject", "subjectDescription"],
+  ["persona", "persona"],
+  ["speech", "speech"],
+  ["accent", "accent"],
+  ["motion", "motion"],
+  ["wardrobe", "wardrobe"],
+  ["setting", "setting"]
+];
+function parseGuardrails(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  return [
+    ...new Set(
+      value.split(",").map((rule) => rule.trim()).filter((rule) => rule.length > 0)
+    )
+  ];
+}
+function buildProfilePatch(args) {
+  const patch = {};
+  for (const [flag, field] of TEXT_FIELDS) {
+    const value = args[flag];
+    if (typeof value === "string") {
+      Object.assign(patch, { [field]: value.trim() });
+    }
+  }
+  const guardrails = parseGuardrails(args.guardrails);
+  if (guardrails) {
+    patch.guardrails = guardrails;
+  }
+  return patch;
+}
+function hasProfileEdit(patch) {
+  return Object.keys(patch).length > 0;
+}
+function mergeProfile(current, patch) {
+  const merged = { ...current };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value.length === 0) {
+      if (key !== "subjectDescription") {
+        delete merged[key];
+      }
+      continue;
+    }
+    Object.assign(merged, { [key]: value });
+  }
+  return merged;
+}
+
+export {
+  buildProfilePatch,
+  hasProfileEdit,
+  mergeProfile
+};
+//# sourceMappingURL=chunk-IJMWEO4P.js.map

package/dist/chunk-IJMWEO4P.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/avatars/profile.ts"],"sourcesContent":["import type { AvatarProfile } from \"@baker/api\";\n\n/**\n * A partial edit of an avatar's written profile.\n *\n * `update` sends the profile whole — the backend replaces it rather than\n * merging — so an agent that passes `--persona` alone would wipe the subject\n * description, which is the one field the identity depends on. The CLI reads\n * the stored profile first and merges this patch over it.\n */\nexport type AvatarProfilePatch = Partial<AvatarProfile>;\n\n/** Written-profile flags, in the order they read on the command line. */\nexport const PROFILE_FLAGS = [\n  \"subject\",\n  \"persona\",\n  \"speech\",\n  \"accent\",\n  \"motion\",\n  \"wardrobe\",\n  \"setting\",\n  \"guardrails\",\n] as const;\n\ntype AvatarProfileTextField = Exclude<keyof AvatarProfile, \"guardrails\">;\n\nconst TEXT_FIELDS: ReadonlyArray<[flag: string, field: AvatarProfileTextField]> = [\n  [\"subject\", \"subjectDescription\"],\n  [\"persona\", \"persona\"],\n  [\"speech\", \"speech\"],\n  [\"accent\", \"accent\"],\n  [\"motion\", \"motion\"],\n  [\"wardrobe\", \"wardrobe\"],\n  [\"setting\", \"setting\"],\n];\n\n/**\n * Split a `--guardrails \"never a, never b\"` flag into single rules.\n *\n * Returns undefined when the flag was omitted so the caller can tell \"leave the\n * stored rules alone\" from \"clear them\" (an empty string).\n */\nexport function parseGuardrails(value: unknown): string[] | undefined {\n  if (typeof value !== \"string\") {\n    return undefined;\n  }\n  return [\n    ...new Set(\n      value\n        .split(\",\")\n        .map((rule) => rule.trim())\n        .filter((rule) => rule.length > 0),\n    ),\n  ];\n}\n\n/** Read the profile flags a caller actually passed. Omitted flags stay absent. */\nexport function buildProfilePatch(args: Record<string, unknown>): AvatarProfilePatch {\n  const patch: AvatarProfilePatch = {};\n  for (const [flag, field] of TEXT_FIELDS) {\n    const value = args[flag];\n    if (typeof value === \"string\") {\n      Object.assign(patch, { [field]: value.trim() });\n    }\n  }\n  const guardrails = parseGuardrails(args.guardrails);\n  if (guardrails) {\n    patch.guardrails = guardrails;\n  }\n  return patch;\n}\n\nexport function hasProfileEdit(patch: AvatarProfilePatch): boolean {\n  return Object.keys(patch).length > 0;\n}\n\n/**\n * Merge a patch over the stored profile. An empty value clears the field it\n * names — except `subjectDescription`, which the identity sheet was fused from\n * and can only ever be replaced, never removed (`update` rejects the empty\n * flag outright, so this is the second line of defence).\n */\nexport function mergeProfile(current: AvatarProfile, patch: AvatarProfilePatch): AvatarProfile {\n  const merged: AvatarProfile = { ...current };\n  for (const [key, value] of Object.entries(patch) as [keyof AvatarProfile, string | string[]][]) {\n    if (value.length === 0) {\n      if (key !== \"subjectDescription\") {\n        delete merged[key];\n      }\n      continue;\n    }\n    Object.assign(merged, { [key]: value });\n  }\n  return merged;\n}\n"],"mappings":";AA0BA,IAAM,cAA4E;AAAA,EAChF,CAAC,WAAW,oBAAoB;AAAA,EAChC,CAAC,WAAW,SAAS;AAAA,EACrB,CAAC,UAAU,QAAQ;AAAA,EACnB,CAAC,UAAU,QAAQ;AAAA,EACnB,CAAC,UAAU,QAAQ;AAAA,EACnB,CAAC,YAAY,UAAU;AAAA,EACvB,CAAC,WAAW,SAAS;AACvB;AAQO,SAAS,gBAAgB,OAAsC;AACpE,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO;AAAA,EACT;AACA,SAAO;AAAA,IACL,GAAG,IAAI;AAAA,MACL,MACG,MAAM,GAAG,EACT,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,EACzB,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC;AAAA,IACrC;AAAA,EACF;AACF;AAGO,SAAS,kBAAkB,MAAmD;AACnF,QAAM,QAA4B,CAAC;AACnC,aAAW,CAAC,MAAM,KAAK,KAAK,aAAa;AACvC,UAAM,QAAQ,KAAK,IAAI;AACvB,QAAI,OAAO,UAAU,UAAU;AAC7B,aAAO,OAAO,OAAO,EAAE,CAAC,KAAK,GAAG,MAAM,KAAK,EAAE,CAAC;AAAA,IAChD;AAAA,EACF;AACA,QAAM,aAAa,gBAAgB,KAAK,UAAU;AAClD,MAAI,YAAY;AACd,UAAM,aAAa;AAAA,EACrB;AACA,SAAO;AACT;AAEO,SAAS,eAAe,OAAoC;AACjE,SAAO,OAAO,KAAK,KAAK,EAAE,SAAS;AACrC;AAQO,SAAS,aAAa,SAAwB,OAA0C;AAC7F,QAAM,SAAwB,EAAE,GAAG,QAAQ;AAC3C,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,KAAK,GAAiD;AAC9F,QAAI,MAAM,WAAW,GAAG;AACtB,UAAI,QAAQ,sBAAsB;AAChC,eAAO,OAAO,GAAG;AAAA,MACnB;AACA;AAAA,IACF;AACA,WAAO,OAAO,QAAQ,EAAE,CAAC,GAAG,GAAG,MAAM,CAAC;AAAA,EACxC;AACA,SAAO;AACT;","names":[]}

package/dist/chunk-IMORFIUT.js

@@ -0,0 +1,207 @@
+import {
+  nodeParamsPreview
+} from "./chunk-NHU33T2S.js";
+import {
+  creativeSlugFromCanvasPath,
+  parseDefinitionSeriesPlace,
+  parseDefinitionSourceFields,
+  parseDefinitionStrategyFields
+} from "./chunk-RRIAHUWP.js";
+import {
+  prepareCanvas
+} from "./chunk-QKE7GXZ7.js";
+import {
+  BackendClient
+} from "./chunk-KZUHRZ2C.js";
+import {
+  nodeDependencies
+} from "./chunk-66USKCVY.js";
+import {
+  requireCredentialsFromEnv
+} from "./chunk-U7BBXM67.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-IMORFIUT.js.map

package/dist/chunk-IMORFIUT.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":[]}