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

package/dist/chunk-JUAIGJ2A.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/ads/google/service-read-errors.ts"],"sourcesContent":["/**\n * What a refused non-GAQL read (invoices, identity verification, previews, forecast, themes) tells\n * the agent. A refusal that is the account's situation — not on monthly invoicing, no billing\n * setup — is not a failure of the job: the fix says where the answer lives instead and to carry on.\n */\nimport { ApiError } from \"../../../client.ts\";\nimport { handleConnectionError, isNotConnectedError } from \"../../../error-handler.ts\";\nimport { writeAdsJson } from \"../output.ts\";\nimport type { AdsErrorEnvelope } from \"../types.ts\";\n\ninterface KnownRefusal {\n  match: RegExp;\n  code: string;\n  message: string;\n  explanation: string;\n}\n\nconst KNOWN_REFUSALS: KnownRefusal[] = [\n  {\n    match: /BILLING_SETUP_NOT_ON_MONTHLY_INVOICING/,\n    code: \"NOT_INVOICED\",\n    message: \"This account is not billed by monthly invoicing, so Google issues no invoices through the API.\",\n    explanation:\n      \"Degrade, don't abort: the account pays automatically (card or bank), and its receipts are in Google Ads → Billing → Documents for the user to download. Spend itself is readable with `query --preset account-summary`. Carry on with the rest of the job.\",\n  },\n  {\n    match: /no approved billing setup/i,\n    code: \"NO_BILLING_SETUP\",\n    message: \"This account has no approved billing setup, so it has no invoices.\",\n    explanation:\n      \"Degrade, don't abort: nothing is billed to this account yet (or a manager account pays). Carry on with the rest of the job.\",\n  },\n  {\n    match:\n      /BILLING_NOT_ON_MONTHLY_INVOICING|verification is only open to customers with billing setup for monthly invoicing/,\n    code: \"VERIFICATION_NOT_READABLE\",\n    message: \"Google only reports advertiser verification through the API for accounts on monthly invoicing.\",\n    explanation:\n      \"Degrade, don't abort: the status is in Google Ads → Billing → Advertiser verification, where the user can read it. Say that, and carry on with the rest of the job.\",\n  },\n  {\n    match: /UNSUPPORTED_AD_TYPE/,\n    code: \"NO_PREVIEW_FOR_AD_TYPE\",\n    message:\n      \"Google has no shareable preview for this ad type: --ads previews only video ads of Video campaigns, live on YouTube (search, display and Demand Gen ads answer unsupported).\",\n    explanation:\n      \"Degrade, don't abort: preview a Performance Max campaign with --asset-groups, and describe any other ad from its copy (`ads list`, `query --preset ad-copy-performance`). Carry on with the rest of the job.\",\n  },\n];\n\nexport function serviceReadRefusal(message: string): AdsErrorEnvelope | null {\n  const known = KNOWN_REFUSALS.find((refusal) => refusal.match.test(message));\n  if (!known) return null;\n  return {\n    ok: false,\n    error: {\n      code: known.code,\n      message: known.message,\n      fix: { action: \"reject\", explanation: known.explanation },\n      retryable: false,\n    },\n  };\n}\n\n/** Write the error envelope for a failed service read and exit. */\nexport function exitWithServiceReadError(err: unknown): never {\n  if (err instanceof ApiError) {\n    if (isNotConnectedError(err.code, err.message)) handleConnectionError(\"google_ads\", err.message);\n    writeAdsJson(\n      serviceReadRefusal(err.message) ?? {\n        ok: false,\n        error: {\n          code: err.code,\n          message: err.message,\n          fix: { action: \"reject\", explanation: err.message },\n          retryable: err.code === \"RATE_LIMITED\" || err.code === \"UNAVAILABLE\",\n        },\n      },\n    );\n    process.exit(1);\n  }\n  writeAdsJson({\n    ok: false,\n    error: { code: \"NETWORK_ERROR\", message: err instanceof Error ? err.message : \"Unexpected error\" },\n  });\n  process.exit(1);\n}\n"],"mappings":";;;;;;;;;;AAiBA,IAAM,iBAAiC;AAAA,EACrC;AAAA,IACE,OAAO;AAAA,IACP,MAAM;AAAA,IACN,SAAS;AAAA,IACT,aACE;AAAA,EACJ;AAAA,EACA;AAAA,IACE,OAAO;AAAA,IACP,MAAM;AAAA,IACN,SAAS;AAAA,IACT,aACE;AAAA,EACJ;AAAA,EACA;AAAA,IACE,OACE;AAAA,IACF,MAAM;AAAA,IACN,SAAS;AAAA,IACT,aACE;AAAA,EACJ;AAAA,EACA;AAAA,IACE,OAAO;AAAA,IACP,MAAM;AAAA,IACN,SACE;AAAA,IACF,aACE;AAAA,EACJ;AACF;AAEO,SAAS,mBAAmB,SAA0C;AAC3E,QAAM,QAAQ,eAAe,KAAK,CAAC,YAAY,QAAQ,MAAM,KAAK,OAAO,CAAC;AAC1E,MAAI,CAAC,MAAO,QAAO;AACnB,SAAO;AAAA,IACL,IAAI;AAAA,IACJ,OAAO;AAAA,MACL,MAAM,MAAM;AAAA,MACZ,SAAS,MAAM;AAAA,MACf,KAAK,EAAE,QAAQ,UAAU,aAAa,MAAM,YAAY;AAAA,MACxD,WAAW;AAAA,IACb;AAAA,EACF;AACF;AAGO,SAAS,yBAAyB,KAAqB;AAC5D,MAAI,eAAe,UAAU;AAC3B,QAAI,oBAAoB,IAAI,MAAM,IAAI,OAAO,EAAG,uBAAsB,cAAc,IAAI,OAAO;AAC/F;AAAA,MACE,mBAAmB,IAAI,OAAO,KAAK;AAAA,QACjC,IAAI;AAAA,QACJ,OAAO;AAAA,UACL,MAAM,IAAI;AAAA,UACV,SAAS,IAAI;AAAA,UACb,KAAK,EAAE,QAAQ,UAAU,aAAa,IAAI,QAAQ;AAAA,UAClD,WAAW,IAAI,SAAS,kBAAkB,IAAI,SAAS;AAAA,QACzD;AAAA,MACF;AAAA,IACF;AACA,YAAQ,KAAK,CAAC;AAAA,EAChB;AACA,eAAa;AAAA,IACX,IAAI;AAAA,IACJ,OAAO,EAAE,MAAM,iBAAiB,SAAS,eAAe,QAAQ,IAAI,UAAU,mBAAmB;AAAA,EACnG,CAAC;AACD,UAAQ,KAAK,CAAC;AAChB;","names":[]}

package/dist/chunk-K2RYUZ5Y.js

@@ -0,0 +1,51 @@
+import {
+  failApi
+} from "./chunk-XE3WS3QE.js";
+import {
+  HUBSPOT_MISSING_GRANT_MARKER,
+  HUBSPOT_NOT_CONNECTED_MESSAGE
+} from "./chunk-KRIK2JR4.js";
+import {
+  ApiError
+} from "./chunk-HREWXNTO.js";
+import {
+  writeJson
+} from "./chunk-WOTDHRNF.js";
+
+// src/commands/hubspot/refusal.ts
+var CONTINUE = "Keep going with the wider task: say which part you could not read, skip it, and finish everything else. If the `request_connection` call fails, say so plainly and give the exact route: dashboard \u2192 Brain \u2192 Integrations \u2192 Platforms \u2192 HubSpot.";
+function hubspotRefusal(code, message, reason = "so I can count a contact becoming a customer") {
+  if (code === "NOT_FOUND" && message.includes(HUBSPOT_NOT_CONNECTED_MESSAGE)) {
+    return {
+      code: "NO_HUBSPOT_CONNECTION",
+      fix: {
+        action: "request_connection",
+        explanation: `AGENT INSTRUCTION: HubSpot is not connected, and only the user can connect it. Call the \`request_connection\` tool with { platform: "hubspot", reason } \u2014 reason in their words, e.g. "${reason}" \u2014 and they connect it inside the chat; then run this command again. ` + CONTINUE
+      }
+    };
+  }
+  if (code === "FORBIDDEN" && message.includes(HUBSPOT_MISSING_GRANT_MARKER)) {
+    return {
+      code: "HUBSPOT_RECONNECT_REQUIRED",
+      fix: {
+        action: "request_connection",
+        explanation: 'AGENT INSTRUCTION: HubSpot is connected \u2014 do not tell the user it is missing, and do not retry. Its access does not cover this read (it was connected before Baker asked for it, or the access was withdrawn), and only the user can widen it. Call the `request_connection` tool with { platform: "hubspot", reason } naming what you need to read; the card offers them a Reconnect button. Run this command again once they have. ' + CONTINUE
+      }
+    };
+  }
+  return null;
+}
+function failNotConnected(err, reason) {
+  const refusal = err instanceof ApiError ? hubspotRefusal(err.code, err.message, reason) : null;
+  if (err instanceof ApiError && refusal !== null) {
+    writeJson({ ok: false, error: { code: refusal.code, message: err.message, fix: refusal.fix } });
+    process.exit(1);
+  }
+  failApi(err);
+}
+
+export {
+  hubspotRefusal,
+  failNotConnected
+};
+//# sourceMappingURL=chunk-K2RYUZ5Y.js.map

package/dist/chunk-K2RYUZ5Y.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/hubspot/refusal.ts"],"sourcesContent":["import { HUBSPOT_MISSING_GRANT_MARKER, HUBSPOT_NOT_CONNECTED_MESSAGE } from \"@baker/api\";\nimport { ApiError } from \"../../client.ts\";\nimport { writeJson } from \"../../output.ts\";\nimport { failApi } from \"../actions/shared.ts\";\n\nexport interface HubspotRefusal {\n  code: \"NO_HUBSPOT_CONNECTION\" | \"HUBSPOT_RECONNECT_REQUIRED\";\n  fix: { action: \"request_connection\"; explanation: string };\n}\n\nconst CONTINUE =\n  \"Keep going with the wider task: say which part you could not read, skip it, and finish everything else. If the \" +\n  \"`request_connection` call fails, say so plainly and give the exact route: dashboard → Brain → Integrations → \" +\n  \"Platforms → HubSpot.\";\n\n/**\n * The two HubSpot refusals only the user can clear, as the fix the agent\n * relays: the in-chat connect card, which connects HubSpot when nothing is\n * connected and reconnects it when the connection does not allow the read.\n * Every command that reads HubSpot shares this, so `baker hubspot` and\n * `baker analytics sources` cannot answer the same refusal two ways. Null for\n * every other refusal. `reason` is the example the agent words its ask on —\n * pass one that fits the read that was refused.\n *\n * Matched on the backend's own sentences (shared from `@baker/api`), because\n * the status alone does not tell them apart: a 404 is also \"no such source\",\n * and a 403 also \"you cannot change this company\".\n */\nexport function hubspotRefusal(\n  code: string,\n  message: string,\n  reason = \"so I can count a contact becoming a customer\",\n): HubspotRefusal | null {\n  if (code === \"NOT_FOUND\" && message.includes(HUBSPOT_NOT_CONNECTED_MESSAGE)) {\n    return {\n      code: \"NO_HUBSPOT_CONNECTION\",\n      fix: {\n        action: \"request_connection\",\n        explanation:\n          \"AGENT INSTRUCTION: HubSpot is not connected, and only the user can connect it. Call the `request_connection` \" +\n          `tool with { platform: \"hubspot\", reason } — reason in their words, e.g. \"${reason}\" — and they connect it ` +\n          \"inside the chat; then run this command again. \" +\n          CONTINUE,\n      },\n    };\n  }\n  if (code === \"FORBIDDEN\" && message.includes(HUBSPOT_MISSING_GRANT_MARKER)) {\n    return {\n      code: \"HUBSPOT_RECONNECT_REQUIRED\",\n      fix: {\n        action: \"request_connection\",\n        explanation:\n          \"AGENT INSTRUCTION: HubSpot is connected — do not tell the user it is missing, and do not retry. Its access does \" +\n          \"not cover this read (it was connected before Baker asked for it, or the access was withdrawn), and only the user \" +\n          'can widen it. Call the `request_connection` tool with { platform: \"hubspot\", reason } naming what you need to ' +\n          \"read; the card offers them a Reconnect button. Run this command again once they have. \" +\n          CONTINUE,\n      },\n    };\n  }\n  return null;\n}\n\n/**\n * \"No HubSpot connected\" and \"connected, but not for this\" are the most common\n * reasons these commands can't answer, and the agent can fix neither — only the\n * user can. Turn them into the in-chat connect card instead of a bare error.\n */\nexport function failNotConnected(err: unknown, reason?: string): never {\n  const refusal = err instanceof ApiError ? hubspotRefusal(err.code, err.message, reason) : null;\n  if (err instanceof ApiError && refusal !== null) {\n    writeJson({ ok: false, error: { code: refusal.code, message: err.message, fix: refusal.fix } });\n    process.exit(1);\n  }\n  failApi(err);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAUA,IAAM,WACJ;AAiBK,SAAS,eACd,MACA,SACA,SAAS,gDACc;AACvB,MAAI,SAAS,eAAe,QAAQ,SAAS,6BAA6B,GAAG;AAC3E,WAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK;AAAA,QACH,QAAQ;AAAA,QACR,aACE,gMAC4E,MAAM,gFAElF;AAAA,MACJ;AAAA,IACF;AAAA,EACF;AACA,MAAI,SAAS,eAAe,QAAQ,SAAS,4BAA4B,GAAG;AAC1E,WAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK;AAAA,QACH,QAAQ;AAAA,QACR,aACE,+aAIA;AAAA,MACJ;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAOO,SAAS,iBAAiB,KAAc,QAAwB;AACrE,QAAM,UAAU,eAAe,WAAW,eAAe,IAAI,MAAM,IAAI,SAAS,MAAM,IAAI;AAC1F,MAAI,eAAe,YAAY,YAAY,MAAM;AAC/C,cAAU,EAAE,IAAI,OAAO,OAAO,EAAE,MAAM,QAAQ,MAAM,SAAS,IAAI,SAAS,KAAK,QAAQ,IAAI,EAAE,CAAC;AAC9F,YAAQ,KAAK,CAAC;AAAA,EAChB;AACA,UAAQ,GAAG;AACb;","names":[]}

package/dist/chunk-K5OQES4V.js

@@ -0,0 +1,58 @@
+import {
+  readAvatars
+} from "./chunk-LEIQAHWF.js";
+
+// src/commands/canvas/scaffold-static-ad-paths.ts
+import path from "path";
+function resolveScaffoldStaticAdPaths(rawFile, out, cwd = process.cwd(), slug) {
+  const file = rawFile.trim();
+  const imageIsUrl = /^https?:\/\//i.test(file);
+  const imageSource = imageIsUrl ? file : path.resolve(cwd, file);
+  const outPath = out ? path.resolve(cwd, out) : slug ? path.join(cwd, "src", "creatives", slug, `${slug}.canvas.json`) : imageIsUrl ? path.join(cwd, "static-ad.canvas.json") : path.join(path.dirname(imageSource), "static-ad.canvas.json");
+  const blueprintPath = path.join(path.dirname(outPath), "prompt.json");
+  const creativeDir = slug ? path.dirname(outPath) : null;
+  const definitionPath = creativeDir ? path.join(creativeDir, "_definition.md") : null;
+  const referencesDir = creativeDir ? path.join(creativeDir, "references") : null;
+  return { imageIsUrl, imageSource, outPath, blueprintPath, creativeDir, definitionPath, referencesDir };
+}
+var SCAFFOLD_SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+var SCAFFOLD_SLUG_MAX_LENGTH = 100;
+function isValidScaffoldSlug(slug) {
+  return slug.length <= SCAFFOLD_SLUG_MAX_LENGTH && SCAFFOLD_SLUG_PATTERN.test(slug);
+}
+
+// src/commands/avatars/resolveCast.ts
+async function resolveCastAvatar(handle) {
+  try {
+    const avatar = await readAvatars("/api/avatars/get", { handle });
+    if (avatar.status && avatar.status !== "ready") {
+      return {
+        error: `Avatar \`${handle}\` is ${avatar.status}, not ready \u2014 \`baker avatars get ${handle} --wait\` returns the moment it is.`
+      };
+    }
+    if (!avatar.sheetUrl)
+      return { error: `Avatar \`${handle}\` has no identity sheet yet, so the ad cannot ground on their face.` };
+    return { sheetUrl: avatar.sheetUrl, subjectDescription: avatar.subjectDescription, handle };
+  } catch (e) {
+    return {
+      error: `Could not read avatar \`${handle}\`: ${e instanceof Error ? e.message : String(e)}. \`baker avatars list\` shows who there is.`
+    };
+  }
+}
+async function resolveCastAvatars(flag) {
+  const handles = String(flag ?? "").split(",").map((h) => h.trim()).filter(Boolean);
+  const avatars = [];
+  for (const handle of handles) {
+    const resolved = await resolveCastAvatar(handle);
+    if ("error" in resolved) return resolved;
+    avatars.push(resolved);
+  }
+  return { handles, avatars };
+}
+
+export {
+  resolveScaffoldStaticAdPaths,
+  isValidScaffoldSlug,
+  resolveCastAvatars
+};
+//# sourceMappingURL=chunk-K5OQES4V.js.map

package/dist/chunk-K5OQES4V.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/canvas/scaffold-static-ad-paths.ts","../src/commands/avatars/resolveCast.ts"],"sourcesContent":["import path from \"node:path\";\n\nexport type ScaffoldStaticAdPaths = {\n  /** True when the source arg is an http(s) URL — the `original` ingest uses `source: \"url\"`. */\n  imageIsUrl: boolean;\n  /** The image source the emitted canvas reads: a URL kept verbatim, or a resolved local path. */\n  imageSource: string;\n  /** Where the canvas is written. */\n  outPath: string;\n  /** Where the baked blueprint (`prompt.json`) is written — always alongside the canvas. */\n  blueprintPath: string;\n  /**\n   * The creative folder (`src/creatives/<slug>/`) when routing by slug, else null. When set, the\n   * scaffold auto-writes `_definition.md` and copies the source into a committed `references/` dir so\n   * the canvas is portable to a fresh sandbox; without a slug it stays a bare ad-hoc canvas file.\n   */\n  creativeDir: string | null;\n  /** Where `_definition.md` is written (creative-convention only). */\n  definitionPath: string | null;\n  /** Directory for the committed source/reference assets (creative-convention only). */\n  referencesDir: string | null;\n};\n\n/**\n * Derive the image source and output paths from the raw CLI args. A URL is kept\n * verbatim (path.resolve would collapse `//` and mangle it into a bogus local\n * path); a local file resolves against cwd. The URL case has no local dir to\n * anchor outputs to, so they default to `cwd`. The raw arg is trimmed first so a\n * copy-pasted, whitespace-padded URL is still detected as a URL rather than\n * falling through to path.resolve.\n *\n * `slug` routes the canvas into the repo convention `src/creatives/{slug}/`\n * ({slug}.canvas.json + prompt.json beside it) so runs attach to the creative's\n * durable generation history. An explicit `out` wins over `slug`.\n */\nexport function resolveScaffoldStaticAdPaths(\n  rawFile: string,\n  out?: string,\n  cwd: string = process.cwd(),\n  slug?: string,\n): ScaffoldStaticAdPaths {\n  const file = rawFile.trim();\n  const imageIsUrl = /^https?:\\/\\//i.test(file);\n  const imageSource = imageIsUrl ? file : path.resolve(cwd, file);\n  const outPath = out\n    ? path.resolve(cwd, out)\n    : slug\n      ? path.join(cwd, \"src\", \"creatives\", slug, `${slug}.canvas.json`)\n      : imageIsUrl\n        ? path.join(cwd, \"static-ad.canvas.json\")\n        : path.join(path.dirname(imageSource), \"static-ad.canvas.json\");\n  const blueprintPath = path.join(path.dirname(outPath), \"prompt.json\");\n  // The creative convention (auto _definition.md + committed references/) only applies when a slug\n  // routes the canvas into src/creatives/<slug>/; an explicit --out is treated as an ad-hoc canvas.\n  const creativeDir = slug ? path.dirname(outPath) : null;\n  const definitionPath = creativeDir ? path.join(creativeDir, \"_definition.md\") : null;\n  const referencesDir = creativeDir ? path.join(creativeDir, \"references\") : null;\n  return { imageIsUrl, imageSource, outPath, blueprintPath, creativeDir, definitionPath, referencesDir };\n}\n\nexport const SCAFFOLD_SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;\n\n// Mirrors the backend's CREATIVE_SLUG_MAX_LENGTH so a scaffolded creative can\n// always sync + record runs (an over-long slug is rejected server-side).\nexport const SCAFFOLD_SLUG_MAX_LENGTH = 100;\n\nexport function isValidScaffoldSlug(slug: string): boolean {\n  return slug.length <= SCAFFOLD_SLUG_MAX_LENGTH && SCAFFOLD_SLUG_PATTERN.test(slug);\n}\n","import type { AvatarSummary } from \"@baker/api\";\nimport type { CastAvatar } from \"../../engine/scaffold/castAvatar.ts\";\nimport { readAvatars } from \"./transport.ts\";\n\n/** One avatar, ready to cast: its identity sheet and subject description, or why it cannot be. */\nasync function resolveCastAvatar(handle: string): Promise<CastAvatar | { error: string }> {\n  try {\n    const avatar = await readAvatars<AvatarSummary>(\"/api/avatars/get\", { handle });\n    if (avatar.status && avatar.status !== \"ready\") {\n      return {\n        error: `Avatar \\`${handle}\\` is ${avatar.status}, not ready — \\`baker avatars get ${handle} --wait\\` returns the moment it is.`,\n      };\n    }\n    if (!avatar.sheetUrl)\n      return { error: `Avatar \\`${handle}\\` has no identity sheet yet, so the ad cannot ground on their face.` };\n    return { sheetUrl: avatar.sheetUrl, subjectDescription: avatar.subjectDescription, handle };\n  } catch (e) {\n    return {\n      error: `Could not read avatar \\`${handle}\\`: ${e instanceof Error ? e.message : String(e)}. \\`baker avatars list\\` shows who there is.`,\n    };\n  }\n}\n\n/**\n * Resolve a scaffold's `--avatar marta,joan` flag, in order. Called before the billed\n * passes, so a handle that cannot be cast fails for free.\n */\nexport async function resolveCastAvatars(\n  flag: unknown,\n): Promise<{ handles: string[]; avatars: CastAvatar[] } | { error: string }> {\n  const handles = String(flag ?? \"\")\n    .split(\",\")\n    .map((h) => h.trim())\n    .filter(Boolean);\n  const avatars: CastAvatar[] = [];\n  for (const handle of handles) {\n    const resolved = await resolveCastAvatar(handle);\n    if (\"error\" in resolved) return resolved;\n    avatars.push(resolved);\n  }\n  return { handles, avatars };\n}\n"],"mappings":";;;;;AAAA,OAAO,UAAU;AAmCV,SAAS,6BACd,SACA,KACA,MAAc,QAAQ,IAAI,GAC1B,MACuB;AACvB,QAAM,OAAO,QAAQ,KAAK;AAC1B,QAAM,aAAa,gBAAgB,KAAK,IAAI;AAC5C,QAAM,cAAc,aAAa,OAAO,KAAK,QAAQ,KAAK,IAAI;AAC9D,QAAM,UAAU,MACZ,KAAK,QAAQ,KAAK,GAAG,IACrB,OACE,KAAK,KAAK,KAAK,OAAO,aAAa,MAAM,GAAG,IAAI,cAAc,IAC9D,aACE,KAAK,KAAK,KAAK,uBAAuB,IACtC,KAAK,KAAK,KAAK,QAAQ,WAAW,GAAG,uBAAuB;AACpE,QAAM,gBAAgB,KAAK,KAAK,KAAK,QAAQ,OAAO,GAAG,aAAa;AAGpE,QAAM,cAAc,OAAO,KAAK,QAAQ,OAAO,IAAI;AACnD,QAAM,iBAAiB,cAAc,KAAK,KAAK,aAAa,gBAAgB,IAAI;AAChF,QAAM,gBAAgB,cAAc,KAAK,KAAK,aAAa,YAAY,IAAI;AAC3E,SAAO,EAAE,YAAY,aAAa,SAAS,eAAe,aAAa,gBAAgB,cAAc;AACvG;AAEO,IAAM,wBAAwB;AAI9B,IAAM,2BAA2B;AAEjC,SAAS,oBAAoB,MAAuB;AACzD,SAAO,KAAK,UAAU,4BAA4B,sBAAsB,KAAK,IAAI;AACnF;;;AC/DA,eAAe,kBAAkB,QAAyD;AACxF,MAAI;AACF,UAAM,SAAS,MAAM,YAA2B,oBAAoB,EAAE,OAAO,CAAC;AAC9E,QAAI,OAAO,UAAU,OAAO,WAAW,SAAS;AAC9C,aAAO;AAAA,QACL,OAAO,YAAY,MAAM,SAAS,OAAO,MAAM,0CAAqC,MAAM;AAAA,MAC5F;AAAA,IACF;AACA,QAAI,CAAC,OAAO;AACV,aAAO,EAAE,OAAO,YAAY,MAAM,uEAAuE;AAC3G,WAAO,EAAE,UAAU,OAAO,UAAU,oBAAoB,OAAO,oBAAoB,OAAO;AAAA,EAC5F,SAAS,GAAG;AACV,WAAO;AAAA,MACL,OAAO,2BAA2B,MAAM,OAAO,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC,CAAC;AAAA,IAC3F;AAAA,EACF;AACF;AAMA,eAAsB,mBACpB,MAC2E;AAC3E,QAAM,UAAU,OAAO,QAAQ,EAAE,EAC9B,MAAM,GAAG,EACT,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,EACnB,OAAO,OAAO;AACjB,QAAM,UAAwB,CAAC;AAC/B,aAAW,UAAU,SAAS;AAC5B,UAAM,WAAW,MAAM,kBAAkB,MAAM;AAC/C,QAAI,WAAW,SAAU,QAAO;AAChC,YAAQ,KAAK,QAAQ;AAAA,EACvB;AACA,SAAO,EAAE,SAAS,QAAQ;AAC5B;","names":[]}

package/dist/chunk-KAHMADFH.js

@@ -0,0 +1,455 @@
+import {
+  parseBrandTokens
+} from "./chunk-V5HDRJQW.js";
+
+// src/engine/brand/fonts.ts
+import { posix } from "path";
+var GOOGLE_CSS2 = "https://fonts.googleapis.com/css2";
+function parseGoogleFontFaces(css) {
+  const faces = [];
+  const re = /\/\*\s*([\w-]+)\s*\*\/\s*@font-face\s*\{([^}]*)\}/g;
+  for (const match of String(css).matchAll(re)) {
+    const subset = match[1] ?? "";
+    const body = match[2] ?? "";
+    const family = body.match(/font-family\s*:\s*['"]?([^'";]+)['"]?\s*;/i)?.[1]?.trim();
+    const url = body.match(/src\s*:\s*url\(\s*['"]?([^'")]+)['"]?\s*\)/i)?.[1]?.trim();
+    const weight = body.match(/font-weight\s*:\s*(\d{3})\s*;/i)?.[1];
+    if (!family || !url || !weight) continue;
+    faces.push({
+      subset,
+      family,
+      style: body.match(/font-style\s*:\s*([\w-]+)\s*;/i)?.[1]?.trim() ?? "normal",
+      weight: Number(weight),
+      url,
+      unicodeRange: body.match(/unicode-range\s*:\s*([^;]+);/i)?.[1]?.trim() ?? ""
+    });
+  }
+  return faces;
+}
+function fontFileName(face) {
+  const family = face.family.replace(/[^A-Za-z0-9]/g, "");
+  const style = face.style === "italic" ? "italic" : "";
+  return `${family}-${face.weight}${style}-${face.subset}.woff2`;
+}
+function fontFaceHref(face) {
+  return `../brand/fonts/${fontFileName(face)}`;
+}
+function renderFontFaceCss(faces) {
+  return faces.map(
+    (face) => [
+      "@font-face {",
+      `  font-family: '${face.family}';`,
+      `  font-style: ${face.style};`,
+      `  font-weight: ${face.weight};`,
+      "  font-display: swap;",
+      `  src: url('${fontFaceHref(face)}') format('woff2');`,
+      ...face.unicodeRange ? [`  unicode-range: ${face.unicodeRange};`] : [],
+      "}"
+    ].join("\n")
+  ).join("\n");
+}
+var FONT_PROVIDERS = ["google", "fontsource"];
+var FONTSOURCE_API = "https://api.fontsource.org/v1";
+var FONT_STYLES = ["normal", "italic"];
+var ITAL_AXIS = { normal: 0, italic: 1 };
+function fontsourceId(family) {
+  return family.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function fontsourceFaces(meta, weights, subsets, styles = ["normal"]) {
+  const faces = [];
+  for (const subset of subsets.filter((s) => meta.subsets.includes(s))) {
+    for (const weight of weights.filter((w) => meta.weights.includes(w))) {
+      for (const style of styles.filter((style2) => meta.styles.includes(style2))) {
+        const url = meta.variants[String(weight)]?.[style]?.[subset]?.url?.woff2;
+        if (!url) continue;
+        faces.push({
+          subset,
+          family: meta.family,
+          style,
+          weight,
+          url,
+          unicodeRange: meta.unicodeRange?.[subset] ?? "",
+          provider: "fontsource"
+        });
+      }
+    }
+  }
+  return faces;
+}
+function undisambiguatedSubsets(faces) {
+  if (new Set(faces.map((face) => face.subset)).size < 2) return [];
+  return [...new Set(faces.filter((face) => !face.unicodeRange).map((face) => face.subset))];
+}
+function suggestFamilies(wanted, catalogue, limit = 5) {
+  const key = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+  const target = key(wanted);
+  if (!target) return [];
+  const words = target.split(" ");
+  const scored = catalogue.map((family) => {
+    const candidate = key(family);
+    if (candidate === target) return { family, score: 0 };
+    if (candidate.startsWith(target)) return { family, score: 1 };
+    if (candidate.includes(target)) return { family, score: 2 };
+    const shared = words.filter((w) => w.length > 2 && candidate.includes(w)).length;
+    return { family, score: shared > 0 ? 3 + (words.length - shared) : Number.POSITIVE_INFINITY };
+  }).filter((c) => Number.isFinite(c.score)).sort((a, b) => a.score - b.score || a.family.localeCompare(b.family));
+  return scored.slice(0, limit).map((c) => c.family);
+}
+function asFontsourceMeta(body) {
+  if (typeof body !== "object" || body === null) return null;
+  const meta = body;
+  const ok = typeof meta.family === "string" && Array.isArray(meta.weights) && Array.isArray(meta.styles) && Array.isArray(meta.subsets) && typeof meta.variants === "object" && meta.variants !== null;
+  return ok ? meta : null;
+}
+async function probeGoogleFaces(family, lookup) {
+  const got = await lookup(googleFontCssUrl(family, STANDARD_WEIGHTS, FONT_STYLES));
+  if (got.status === "unreachable") return null;
+  return got.status === "served" ? parseGoogleFontFaces(got.css) : [];
+}
+async function resolveFromGoogle(family, weights, subsets, styles, deps) {
+  const google = await deps.lookupGoogleCss(googleFontCssUrl(family, weights, FONT_STYLES));
+  if (google.status === "unreachable") return { ok: false, reason: "unreachable", provider: "google" };
+  if (google.status === "absent") {
+    const served2 = await probeGoogleFaces(family, deps.lookupGoogleCss);
+    if (served2 === null) return { ok: false, reason: "unreachable", provider: "google" };
+    const available = [...new Set(served2.map((face) => face.weight))].sort((a, b) => a - b);
+    return available.length > 0 ? { ok: false, reason: "weight", provider: "google", available } : null;
+  }
+  const served = parseGoogleFontFaces(google.css);
+  if (served.length === 0) return null;
+  const availableStyles = [...new Set(served.map((face) => face.style))].sort();
+  const inSubset = served.filter((face) => subsets.includes(face.subset));
+  const faces = inSubset.filter((face) => styles.includes(face.style)).map((face) => ({ ...face, provider: "google" }));
+  if (faces.length > 0) return { ok: true, provider: "google", faces, availableStyles };
+  return { ok: false, reason: "subset", provider: "google", available: [...new Set(served.map((f) => f.subset))] };
+}
+async function resolveBrandFaces(family, weights, subsets, deps, styles = ["normal"]) {
+  const google = await resolveFromGoogle(family, weights, subsets, styles, deps);
+  if (google) return google;
+  let body;
+  try {
+    body = await deps.fetchJson(`${FONTSOURCE_API}/fonts/${fontsourceId(family)}`);
+  } catch {
+    return { ok: false, reason: "unreachable", provider: "fontsource" };
+  }
+  const meta = asFontsourceMeta(body);
+  if (meta) {
+    const faces = fontsourceFaces(meta, weights, subsets, styles);
+    const ambiguous = undisambiguatedSubsets(faces);
+    if (ambiguous.length > 0) {
+      return { ok: false, reason: "ambiguous-subsets", provider: "fontsource", available: meta.subsets };
+    }
+    if (faces.length > 0) return { ok: true, provider: "fontsource", faces, availableStyles: [...meta.styles].sort() };
+    if (!subsets.some((subset) => meta.subsets.includes(subset))) {
+      return { ok: false, reason: "subset", provider: "fontsource", available: meta.subsets };
+    }
+    return { ok: false, reason: "weight", provider: "fontsource", available: meta.weights };
+  }
+  return { ok: false, reason: "unknown-family" };
+}
+function rebaseFontFaceSrc(block, fromDir, toDir = "src/styles") {
+  return block.replace(/url\(\s*(['"]?)([^'")]+)\1\s*\)/gi, (whole, _quote, href) => {
+    if (!isRepoFontHref(href)) return whole;
+    const target = posix.normalize(posix.join(fromDir, href));
+    return `url('${posix.relative(toDir, target)}')`;
+  });
+}
+function declaredFontFaces(source) {
+  const out = [];
+  for (const rule of stripCssComments(source).matchAll(/@font-face\s*\{[^}]*\}/gi)) {
+    const family = rule[0].match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (!family || rule.index === void 0) continue;
+    out.push({ family: normalizeFamily(family), block: source.slice(rule.index, rule.index + rule[0].length) });
+  }
+  return out;
+}
+function isRepoFontHref(href) {
+  return !/^(?:data:|https?:|\/)/i.test(href);
+}
+function missingFontFiles(urls, available) {
+  return urls.filter(isRepoFontHref).map((url) => posix.basename(url.split("?")[0] ?? "")).filter((file) => !available.has(file));
+}
+function planFontAdoption(sources, families) {
+  const wanted = new Map(families.map((family) => [normalizeFamily(family), family]));
+  const byFamily = /* @__PURE__ */ new Map();
+  for (const { path, source } of sources) {
+    const dir = posix.dirname(path);
+    for (const face of declaredFontFaces(source)) {
+      if (!wanted.has(face.family)) continue;
+      const perFile = byFamily.get(face.family) ?? /* @__PURE__ */ new Map();
+      perFile.set(path, [...perFile.get(path) ?? [], rebaseFontFaceSrc(face.block, dir)]);
+      byFamily.set(face.family, perFile);
+    }
+  }
+  const plans = [];
+  const conflicts = [];
+  for (const [family, perFile] of byFamily) {
+    const display = wanted.get(family) ?? family;
+    const files = [...perFile.keys()];
+    const shapes = new Set([...perFile.values()].map((blocks2) => blocks2.join("\n")));
+    if (shapes.size > 1) {
+      conflicts.push({ family: display, files });
+      continue;
+    }
+    const blocks = perFile.get(files[0] ?? "") ?? [];
+    const urls = blocks.flatMap(
+      (block) => [...block.matchAll(/url\(\s*['"]?([^'")]+)['"]?\s*\)/gi)].map((m) => m[1] ?? "")
+    );
+    plans.push({ family: display, blocks, files, urls });
+  }
+  return { plans, conflicts };
+}
+async function fontsourceCatalogue(deps) {
+  const body = await deps.fetchJson(`${FONTSOURCE_API}/fonts`).catch(() => null);
+  if (!Array.isArray(body)) return [];
+  return body.map((entry) => typeof entry === "object" && entry !== null ? entry.family : null).filter((family) => typeof family === "string");
+}
+function parseWeightAxis(spec) {
+  const axis = spec.match(/wght@([^&]+)/i)?.[1] ?? "";
+  const weights = /* @__PURE__ */ new Set();
+  for (const tuple of axis.split(";")) {
+    const last = tuple.split(",").pop()?.trim() ?? "";
+    const range = last.match(/^(\d{3})\.\.(\d{3})$/);
+    if (range) {
+      for (let w = Number(range[1]); w <= Number(range[2]); w += 100) weights.add(w);
+    } else if (/^\d{3}$/.test(last)) {
+      weights.add(Number(last));
+    }
+  }
+  return [...weights].sort((a, b) => a - b);
+}
+function googleFontRequests(css) {
+  const out = [];
+  for (const link of String(css).matchAll(/fonts\.googleapis\.com\/[^\s"')]+/gi)) {
+    for (const param of link[0].matchAll(/[?&]family=([^&]+)/gi)) {
+      const [namePart, ...specParts] = (param[1] ?? "").split(":");
+      const family = decodeURIComponent((namePart ?? "").replaceAll("+", " ")).trim();
+      if (!family) continue;
+      out.push({ family, weights: parseWeightAxis(specParts.join(":")) });
+    }
+  }
+  return out;
+}
+function resolveFetchWeights(flag, declared) {
+  if (flag) {
+    return String(flag).split(",").map((w) => Number(w.trim())).filter((w) => Number.isInteger(w) && w >= 100 && w <= 900);
+  }
+  return declared?.length ? declared : [400];
+}
+var DEFAULT_SUBSETS = ["latin"];
+function resolveFetchSubsets(flag, selfHosted) {
+  const asked = String(flag ?? "").split(",").map((subset) => subset.trim()).filter(Boolean);
+  const named = flag ? [...new Set(asked)] : selfHosted;
+  return named.length > 0 ? named : [...DEFAULT_SUBSETS];
+}
+function resolveFetchStyles(italic, selfHosted) {
+  return italic || selfHosted.includes("italic") ? ["normal", "italic"] : ["normal"];
+}
+function googleFontCssUrl(family, weights, styles = ["normal"]) {
+  const name = family.trim().split(/\s+/).map(encodeURIComponent).join("+");
+  const sorted = [...new Set(weights)].sort((a, b) => a - b);
+  if (sorted.length === 0) return `${GOOGLE_CSS2}?family=${name}&display=swap`;
+  const wanted = FONT_STYLES.filter((style) => styles.includes(style));
+  const spec = wanted.length > 1 ? `${name}:ital,wght@${wanted.flatMap((style) => sorted.map((w) => `${ITAL_AXIS[style]},${w}`)).join(";")}` : `${name}:wght@${sorted.join(";")}`;
+  return `${GOOGLE_CSS2}?family=${spec}&display=swap`;
+}
+var STANDARD_WEIGHTS = [100, 200, 300, 400, 500, 600, 700, 800, 900];
+async function probeServedWeights(family, fetchCss) {
+  const css = await fetchCss(googleFontCssUrl(family, STANDARD_WEIGHTS));
+  if (css === null) return [];
+  return [...new Set(parseGoogleFontFaces(css).map((face) => face.weight))].sort((a, b) => a - b);
+}
+async function checkFontRequests(requests, fetchCss) {
+  const results = [];
+  for (const request of requests) {
+    const css = await fetchCss(googleFontCssUrl(request.family, request.weights));
+    if (css === null) {
+      const served2 = await probeServedWeights(request.family, fetchCss);
+      results.push({
+        family: request.family,
+        requested: request.weights,
+        served: served2,
+        missing: request.weights.filter((w) => !served2.includes(w)),
+        subsets: [],
+        cause: served2.length === 0 ? "unknown-family" : "unavailable-weight"
+      });
+      continue;
+    }
+    const faces = parseGoogleFontFaces(css);
+    const served = [...new Set(faces.map((f) => f.weight))].sort((a, b) => a - b);
+    results.push({
+      family: request.family,
+      requested: request.weights,
+      served,
+      missing: request.weights.filter((w) => !served.includes(w)),
+      subsets: [...new Set(faces.map((f) => f.subset))]
+    });
+  }
+  return results;
+}
+var GENERIC_FAMILIES = /* @__PURE__ */ new Set([
+  "sans-serif",
+  "serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "ui-sans-serif",
+  "ui-serif",
+  "ui-monospace",
+  "ui-rounded",
+  "arial",
+  "helvetica",
+  "georgia",
+  "times",
+  "courier",
+  "inherit",
+  "initial",
+  "unset"
+]);
+function stripCssComments(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, (block) => block.replace(/[^\n]/g, " "));
+}
+function normalizeFamily(raw) {
+  return raw.trim().replace(/^['"]|['"]$/g, "").trim().toLowerCase();
+}
+function fontFaceFamilies(css) {
+  const out = /* @__PURE__ */ new Set();
+  for (const rule of stripCssComments(css).matchAll(/@font-face\s*\{([^}]*)\}/gi)) {
+    const family = (rule[1] ?? "").match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (family) out.add(normalizeFamily(family));
+  }
+  return out;
+}
+function declaredWeights(body) {
+  const spec = (body.match(/font-weight\s*:\s*([^;}]+)/i)?.[1] ?? "").match(/\d{3}/g) ?? [];
+  if (spec.length !== 2) return spec.map(Number);
+  const range = [];
+  for (let w = Number(spec[0]); w <= Number(spec[1]); w += 100) range.push(w);
+  return range;
+}
+function selfHostedWeights(css, family) {
+  const target = normalizeFamily(family);
+  const weights = /* @__PURE__ */ new Set();
+  for (const rule of stripCssComments(css).matchAll(/@font-face\s*\{([^}]*)\}/gi)) {
+    const body = rule[1] ?? "";
+    const declared = body.match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (!declared || normalizeFamily(declared) !== target) continue;
+    for (const weight of declaredWeights(body)) weights.add(weight);
+  }
+  return [...weights].sort((a, b) => a - b);
+}
+function fontFileSubset(href) {
+  const file = posix.basename((href.split("?")[0] ?? "").split("#")[0] ?? "");
+  return /^[A-Za-z0-9]+-[1-9]00(?:italic)?-([\w-]+)\.woff2$/.exec(file)?.[1] ?? null;
+}
+function selfHostedSubsets(css, family) {
+  const target = normalizeFamily(family);
+  const subsets = /* @__PURE__ */ new Set();
+  for (const rule of stripCssComments(css).matchAll(/@font-face\s*\{([^}]*)\}/gi)) {
+    const body = rule[1] ?? "";
+    const declared = body.match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (!declared || normalizeFamily(declared) !== target) continue;
+    for (const url of body.matchAll(/url\(\s*['"]?([^'")]+)['"]?\s*\)/gi)) {
+      const subset = fontFileSubset(url[1] ?? "");
+      if (subset) subsets.add(subset);
+    }
+  }
+  return [...subsets].sort();
+}
+function selfHostedStyles(css, family) {
+  const target = normalizeFamily(family);
+  const styles = /* @__PURE__ */ new Set();
+  for (const rule of stripCssComments(css).matchAll(/@font-face\s*\{([^}]*)\}/gi)) {
+    const body = rule[1] ?? "";
+    const declared = body.match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (declared && normalizeFamily(declared) === target) styles.add(faceStyle(body));
+  }
+  return [...styles].sort();
+}
+function fontsourceFamilies(css) {
+  const out = /* @__PURE__ */ new Set();
+  for (const imported of stripCssComments(css).matchAll(/@fontsource(-variable)?\/([\w-]+)/gi)) {
+    const slug = imported[2];
+    if (!slug) continue;
+    out.add(`${slug.replaceAll("-", " ")}${imported[1] ? " variable" : ""}`.toLowerCase());
+  }
+  return out;
+}
+function asAuthored(css, normalized) {
+  const escaped = normalized.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const text = stripCssComments(css);
+  return text.match(new RegExp(`["']${escaped}["']`, "i"))?.[0]?.slice(1, -1) ?? text.match(new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`, "i"))?.[0] ?? normalized;
+}
+function unresolvedBrandFamilies(css) {
+  const declared = [...parseBrandTokens(css).fonts].filter((family) => !GENERIC_FAMILIES.has(family));
+  const loaded = fontFaceFamilies(css);
+  return declared.filter((family) => !loaded.has(family)).map((family) => asAuthored(css, family));
+}
+function stripFontFaceBlocks(source, family, styles) {
+  const target = normalizeFamily(family);
+  const ranges = [];
+  for (const rule of stripCssComments(source).matchAll(/@font-face\s*\{([^}]*)\}/gi)) {
+    const body = rule[1] ?? "";
+    const declared = body.match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (!declared || normalizeFamily(declared) !== target || rule.index === void 0) continue;
+    if (styles && !styles.has(faceStyle(body))) continue;
+    ranges.push([rule.index, rule.index + rule[0].length]);
+  }
+  let out = source;
+  for (const [start, end] of ranges.reverse()) out = `${out.slice(0, start)}${out.slice(end)}`;
+  return out.replace(/\n{3,}/g, "\n\n");
+}
+function faceStyle(body) {
+  return body.match(/font-style\s*:\s*([\w-]+)/i)?.[1]?.trim().toLowerCase() ?? "normal";
+}
+function declaredStyles(block) {
+  const styles = /* @__PURE__ */ new Set();
+  for (const rule of stripCssComments(block).matchAll(/@font-face\s*\{([^}]*)\}/gi))
+    styles.add(faceStyle(rule[1] ?? ""));
+  return styles;
+}
+function upsertFontFaceCss(css, family, block) {
+  const styles = declaredStyles(block);
+  const out = stripFontFaceBlocks(css, family, styles.size > 0 ? styles : void 0);
+  const themeAt = stripCssComments(out).search(/@theme\b/);
+  if (themeAt < 0) return `${out.trimEnd()}
+
+${block}
+`;
+  const head = out.slice(0, themeAt).trimEnd();
+  const tail = out.slice(themeAt);
+  return head ? `${head}
+
+${block}
+
+${tail}` : `${block}
+
+${tail}`;
+}
+
+export {
+  fontFileName,
+  renderFontFaceCss,
+  FONT_PROVIDERS,
+  suggestFamilies,
+  resolveBrandFaces,
+  missingFontFiles,
+  planFontAdoption,
+  fontsourceCatalogue,
+  googleFontRequests,
+  resolveFetchWeights,
+  DEFAULT_SUBSETS,
+  resolveFetchSubsets,
+  resolveFetchStyles,
+  checkFontRequests,
+  GENERIC_FAMILIES,
+  selfHostedWeights,
+  selfHostedSubsets,
+  selfHostedStyles,
+  fontsourceFamilies,
+  unresolvedBrandFamilies,
+  stripFontFaceBlocks,
+  upsertFontFaceCss
+};
+//# sourceMappingURL=chunk-KAHMADFH.js.map