@koda-sl/baker-cli 0.449.0 → 0.450.0-dev.b454c3dd2

package/dist/chunk-VL43TNIP.js

@@ -0,0 +1,455 @@
+import {
+  parseBrandTokens
+} from "./chunk-ZDMTXQ2Q.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-VL43TNIP.js.map

package/dist/chunk-VLMBTPXU.js

@@ -0,0 +1,51 @@
+import {
+  failApi
+} from "./chunk-SJYEY5MV.js";
+import {
+  HUBSPOT_MISSING_GRANT_MARKER,
+  HUBSPOT_NOT_CONNECTED_MESSAGE
+} from "./chunk-7EPXVICM.js";
+import {
+  ApiError
+} from "./chunk-XBOK23HI.js";
+import {
+  writeJson
+} from "./chunk-NU7JSWVA.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-VLMBTPXU.js.map

package/dist/chunk-VNUNE5AB.js

@@ -0,0 +1,160 @@
+import {
+  IDEA_VIDEO_FORMATS,
+  figuresIn,
+  unsourcedClaims
+} from "./chunk-4QEY2L6U.js";
+import {
+  AD_SPEC_SCHEMA
+} from "./chunk-PZXCWSKV.js";
+
+// src/commands/creatives/make-model.ts
+import { parse, parseDocument, Scalar, visit } from "yaml";
+var REFERENCE_CANDIDATES = 6;
+function isVideoIdea(idea) {
+  return IDEA_VIDEO_FORMATS.includes(idea.format);
+}
+var BY_TEMPERATURE = {
+  cold: { audienceTemperature: "0_cold", excludeBrandReliant: true },
+  warm: { audienceTemperature: "1_warm_engaged,2_hot_visited", excludeBrandReliant: true },
+  hot: { audienceTemperature: "3_customer" }
+};
+function referenceSearchFor(idea, temperature, excludeAdvertiser) {
+  return {
+    query: idea.message,
+    scope: "followed-first",
+    platform: "meta",
+    format: "static",
+    formatPattern: idea.format,
+    awareness: idea.awareness,
+    ...BY_TEMPERATURE[temperature],
+    ...excludeAdvertiser ? { excludeAdvertiser } : {},
+    maxPerAdvertiser: 1,
+    limit: REFERENCE_CANDIDATES,
+    diverse: true
+  };
+}
+function referenceSearchesFor(idea, temperature, excludeAdvertiser) {
+  const strict = referenceSearchFor(idea, temperature, excludeAdvertiser);
+  const { awareness: _awareness, ...anyStage } = strict;
+  const { audienceTemperature: _temperature, excludeBrandReliant: _reliant, ...anyViewer } = anyStage;
+  const { query: _query, ...winners } = anyStage;
+  const { query: _anyQuery, ...anyWinners } = anyViewer;
+  return [
+    strict,
+    anyStage,
+    { ...anyViewer, scope: "all" },
+    { ...winners, sort: "winner" },
+    { ...anyWinners, scope: "all", sort: "winner" }
+  ];
+}
+function pooledCandidates(searches, limit) {
+  const seen = /* @__PURE__ */ new Set();
+  const pooled = [];
+  for (const candidate of searches.flat()) {
+    if (!candidate.ad_id || seen.has(candidate.ad_id)) continue;
+    seen.add(candidate.ad_id);
+    pooled.push(candidate);
+  }
+  return pooled.slice(0, limit);
+}
+function fitsIdea(fit) {
+  return fit.verdict !== "reject" && missingElements(fit).length === 0;
+}
+function missingElements(fit) {
+  return fit.load_bearing.filter((l) => l.have === "missing" && !l.ours?.trim()).map((l) => l.element);
+}
+function definitionFieldsOf(idea, evidence) {
+  return {
+    idea: idea.id,
+    message: idea.message,
+    ...evidence !== "explore" ? { evidence } : {},
+    angle: idea.angle,
+    persona: idea.who,
+    awareness: idea.awareness,
+    hypothesis: idea.why
+  };
+}
+var FRONTMATTER = /^---\r?\n([\s\S]*?\r?\n)?---/;
+function readsAsText11(text) {
+  try {
+    return parse(text, { version: "1.1" }) === text;
+  } catch {
+    return false;
+  }
+}
+function setDefinitionFields(raw, fields) {
+  const match = raw.match(FRONTMATTER);
+  if (!match) return raw;
+  const doc = parseDocument(match[1] ?? "");
+  if (doc.errors.length > 0) return raw;
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === void 0) continue;
+    const node = doc.createNode(value);
+    visit(node, {
+      Scalar(_, scalar) {
+        if (typeof scalar.value === "string" && !readsAsText11(scalar.value)) {
+          scalar.type = Scalar.QUOTE_DOUBLE;
+        }
+      }
+    });
+    doc.set(key, node);
+  }
+  return `---
+${doc.toString()}---${raw.slice(match[0].length)}`;
+}
+function setSpecMessage(specJson, message) {
+  const spec = JSON.parse(specJson);
+  return `${JSON.stringify({ ...spec, message }, null, 2)}
+`;
+}
+function withFitConcept(specJson, seeded) {
+  const spec = JSON.parse(specJson);
+  const held = spec.concept;
+  if (held?.reference_ad_id) return specJson;
+  return `${JSON.stringify({ ...spec, ...seeded }, null, 2)}
+`;
+}
+function unsourcedCopyLines(specJson, corpus) {
+  const spec = JSON.parse(specJson);
+  const figures = figuresIn(corpus);
+  const lines = Array.isArray(spec.copy) ? spec.copy : [];
+  return lines.flatMap((line) => {
+    const text = typeof line === "object" && line !== null ? line.text : void 0;
+    return typeof text === "string" && unsourcedClaims(text, figures).length > 0 ? [text] : [];
+  });
+}
+var PHOTO_FORMATS = /photo|lifestyle|before_after|ugc|product|selfie|street/;
+function ideaSpec(idea, who) {
+  const container = idea.format.replace(/_/g, " ");
+  return {
+    schema: AD_SPEC_SCHEMA,
+    viewer: { who },
+    message: idea.message,
+    copy: [{ text: "[TODO: the headline, in the customer's words]", lettering: "designed", role: "headline" }],
+    scene: {
+      description: `[TODO: what the viewer sees, as a ${container}, that shows: ${idea.message}]`,
+      look: PHOTO_FORMATS.test(idea.format) ? "photo" : "designed"
+    },
+    colors: [],
+    references: [],
+    logo: false,
+    third_party_brands: [],
+    scene_text: [],
+    mechanism: []
+  };
+}
+
+export {
+  isVideoIdea,
+  referenceSearchesFor,
+  pooledCandidates,
+  fitsIdea,
+  missingElements,
+  definitionFieldsOf,
+  setDefinitionFields,
+  setSpecMessage,
+  withFitConcept,
+  unsourcedCopyLines,
+  ideaSpec
+};
+//# sourceMappingURL=chunk-VNUNE5AB.js.map