@koda-sl/baker-cli 0.458.0 → 0.459.0

package/dist/chunk-CUJ2F472.js

@@ -0,0 +1,31 @@
+import {
+  API_KEY_FORMAT_MESSAGE,
+  isBakerApiKey
+} from "./chunk-3XA4JVMY.js";
+
+// src/engine/client/env.ts
+function credentialsFromEnv(env = process.env) {
+  const url = env.BAKER_API_URL;
+  const apiKey = env.BAKER_API_KEY;
+  if (!url || !apiKey) return null;
+  return { url, apiKey };
+}
+function requireCredentialsFromEnv(env = process.env) {
+  const c = credentialsFromEnv(env);
+  if (!c) {
+    throw new Error("missing BAKER_API_URL and/or BAKER_API_KEY environment variables");
+  }
+  if (!isBakerApiKey(c.apiKey)) {
+    throw new Error(`BAKER_API_KEY invalid: ${API_KEY_FORMAT_MESSAGE}`);
+  }
+  return c;
+}
+function remoteCacheEnabledFromEnv(env = process.env) {
+  return env.BAKER_CANVAS_REMOTE_CACHE !== "off";
+}
+
+export {
+  requireCredentialsFromEnv,
+  remoteCacheEnabledFromEnv
+};
+//# sourceMappingURL=chunk-CUJ2F472.js.map

package/dist/chunk-DMXNT47S.js

@@ -0,0 +1,136 @@
+import {
+  handleConnectionError,
+  needsConnectionFix,
+  writeAdsJson
+} from "./chunk-OAYHDIW2.js";
+import {
+  ApiError
+} from "./chunk-NUHMHZTZ.js";
+import {
+  getEnv
+} from "./chunk-3XA4JVMY.js";
+
+// src/commands/ads/meta/shared.ts
+var DAY_MS = 864e5;
+function metaForbiddenFix(message) {
+  if (message.includes("has not accepted Meta's Lead Generation Terms")) {
+    return {
+      action: "reject",
+      explanation: `${message}
+
+Meta confirmed the Page's terms status using its Page access. Give the Page owner the terms link in the error and ask them to accept it before trying the form or lead ad set again. Do not suggest reconnecting Meta for this refusal; continue with other work that does not require the form or ad set.`
+    };
+  }
+  return {
+    action: "reject",
+    explanation: [
+      message,
+      "This is a permission refusal, not a dead connection, and Meta returns the same code for two causes with opposite remedies. Tell them apart by how much else works before you answer.",
+      "If other reads on this account are ALSO refused (campaigns, ad sets, insights), the connection is short a permission it was never granted. Only the user can widen it, by reconnecting Meta from the dashboard.",
+      "If those reads work and only this object is refused, the asset (pixel/dataset, Page, or catalog) belongs to a Business the connected user holds no role in. Ad-account access does not carry asset access and reconnecting cannot grant it \u2014 the client assigns that asset to the connected user or partner in Meta Business settings, under the asset's own section (Data sources \u2192 Datasets for a pixel).",
+      "Either way do not retry the same call, and do not abort the wider job. Continue with what you can read, and state in your answer that this specific check could not run and why \u2014 never present the task as verified when this step was skipped."
+    ].join("\n\n")
+  };
+}
+function handleMetaError(err) {
+  if (err instanceof ApiError) {
+    if (needsConnectionFix(err.code, err.message)) {
+      handleConnectionError("meta_ads", err.message);
+    }
+    const envelope = {
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        fix: err.code === "FORBIDDEN" ? metaForbiddenFix(err.message) : { action: "reject", explanation: err.message },
+        retryable: err.code === "RATE_LIMITED" || err.code === "UNAVAILABLE" || err.code === "INTERNAL_ERROR"
+      }
+    };
+    writeAdsJson(envelope);
+    process.exit(1);
+  }
+  const message = err instanceof Error ? err.message : "Unexpected error";
+  writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message } });
+  process.exit(1);
+}
+var ACCOUNT_ID_RE = /^(act_)?[0-9]+$/;
+function resolveAccountIdArg(args) {
+  const fromArgs = args["account-id"];
+  const id = fromArgs || getEnv().BAKER_META_AD_ACCOUNT_ID;
+  if (!id) {
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "MISSING_ACCOUNT_ID",
+        message: "Pass --account-id or set BAKER_META_AD_ACCOUNT_ID. Run `baker ads meta accounts` to find IDs."
+      }
+    });
+    process.exit(1);
+  }
+  if (!ACCOUNT_ID_RE.test(id)) {
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "INVALID_ACCOUNT_ID",
+        message: `Invalid account ID "${id}". Expected numeric ID, optionally prefixed with "act_".`
+      }
+    });
+    process.exit(1);
+  }
+  return id.startsWith("act_") ? id : `act_${id}`;
+}
+function getDateRange(args) {
+  const datePreset = args["date-preset"];
+  const since = args.since;
+  const until = args.until;
+  if (since && until) return { since, until };
+  return { datePreset: datePreset ?? "last_7d" };
+}
+function todayIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function daysAgoIso(days) {
+  return new Date(Date.now() - days * DAY_MS).toISOString().slice(0, 10);
+}
+function csvOrJson(args) {
+  return args.output ?? "json";
+}
+var NAME_CONTAINS_ARG = {
+  type: "string",
+  description: "Only rows whose name contains this text, matched by Meta before anything is returned. Start here to find one entity by name: --name-contains octubre --all-statuses"
+};
+function resolveEffectiveStatus(args) {
+  if (args["all-statuses"]) {
+    return void 0;
+  }
+  const explicit = args["effective-status"];
+  if (explicit) {
+    return explicit;
+  }
+  return "ACTIVE";
+}
+function statusFilterHints(rows, effectiveStatus, noun) {
+  if (rows.length > 0 || effectiveStatus === void 0) return [];
+  if (effectiveStatus === "ACTIVE") {
+    return [
+      `No ACTIVE ${noun}. The ACTIVE filter hides paused, archived and in-review ones (under a paused campaign or ad set that is all of them), so this does NOT mean none exist. Re-run with --all-statuses before concluding there are none.`
+    ];
+  }
+  return [
+    `No ${noun} with effective_status ${effectiveStatus}. Re-run with --all-statuses to see every status before concluding there are none.`
+  ];
+}
+
+export {
+  metaForbiddenFix,
+  handleMetaError,
+  resolveAccountIdArg,
+  getDateRange,
+  todayIso,
+  daysAgoIso,
+  csvOrJson,
+  NAME_CONTAINS_ARG,
+  resolveEffectiveStatus,
+  statusFilterHints
+};
+//# sourceMappingURL=chunk-DMXNT47S.js.map

package/dist/chunk-DQZEJV3K.js

@@ -0,0 +1,494 @@
+import {
+  DEFAULT_SUBSETS,
+  FONT_PROVIDERS,
+  checkFontRequests,
+  fontFileName,
+  fontsourceCatalogue,
+  fontsourceFamilies,
+  googleFontRequests,
+  missingFontFiles,
+  planFontAdoption,
+  renderFontFaceCss,
+  resolveBrandFaces,
+  resolveFetchStyles,
+  resolveFetchSubsets,
+  resolveFetchWeights,
+  selfHostedStyles,
+  selfHostedSubsets,
+  selfHostedWeights,
+  stripFontFaceBlocks,
+  suggestFamilies,
+  unresolvedBrandFamilies,
+  upsertFontFaceCss
+} from "./chunk-WAGMHPWG.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-USFTTDIO.js";
+
+// src/commands/brand/fonts.ts
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { defineCommand } from "citty";
+var GLOBAL_CSS = path.join("src", "styles", "global.css");
+var FONTS_DIR = path.join("src", "brand", "fonts");
+var DEFAULT_SUBSETS_LABEL = DEFAULT_SUBSETS.join(",");
+var BROWSER_UA = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/120.0 Safari/537.36";
+registerSchema({
+  command: "brand.fonts.check",
+  description: "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) \u2014 the silent fallback that also fails the client's verify \u2014 then asks Google Fonts what it ACTUALLY serves for every family/weight the stylesheet requests.",
+  args: {}
+});
+registerSchema({
+  command: "brand.fonts.adopt",
+  description: "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.",
+  args: {}
+});
+registerSchema({
+  command: "brand.fonts.fetch",
+  description: "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 \u2014 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.",
+  args: {
+    family: { type: "string", description: 'Font family, e.g. "DM Sans"', required: true },
+    weights: {
+      type: "string",
+      description: "Comma-separated weights (default: the weights global.css already requests or self-hosts, else 400)",
+      required: false
+    },
+    subsets: {
+      type: "string",
+      description: `Comma-separated unicode subsets (default: the subsets global.css already self-hosts, else ${DEFAULT_SUBSETS_LABEL})`,
+      required: false
+    },
+    italic: {
+      type: "boolean",
+      description: "Also self-host the family's italic faces. On automatically when global.css already loads one, so a re-fetch never strands it.",
+      required: false
+    }
+  }
+});
+function fail(code, message, fix) {
+  writeJson({ ok: false, error: { code, message, ...fix ? { fix } : {} } });
+  process.exit(2);
+}
+var REQUEST_TIMEOUT_MS = 15e3;
+async function fetchJson(url) {
+  const res = await fetch(url, {
+    headers: { "User-Agent": BROWSER_UA },
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  if (res.status === 404) return null;
+  if (!res.ok) throw new Error(`Fontsource answered ${res.status}`);
+  return await res.json();
+}
+async function lookupGoogleCss(url) {
+  try {
+    const res = await fetch(url, {
+      headers: { "User-Agent": BROWSER_UA },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+    if (res.ok) return { status: "served", css: await res.text() };
+    return { status: res.status === 400 ? "absent" : "unreachable" };
+  } catch {
+    return { status: "unreachable" };
+  }
+}
+var fetchGoogleCss = async (url) => {
+  const got = await lookupGoogleCss(url);
+  return got.status === "served" ? got.css : null;
+};
+var WIRING_HINT = {
+  written: (family) => `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.`,
+  // Told apart from "no stylesheet" on purpose: they used to share one hint, so
+  // an idempotent re-run instructed the agent to paste a block that was already
+  // in the file, and doing as it was told duplicated the face.
+  "already-wired": (family) => `${GLOBAL_CSS} already loads exactly these faces for "${family}" \u2014 nothing to change.`,
+  "no-stylesheet": () => `No ${GLOBAL_CSS} to write to \u2014 paste the \`fontFace\` block above the @theme block once the stylesheet exists, or the files just downloaded will never load.`
+};
+var PROVIDER_DEPS = { lookupGoogleCss, fetchJson };
+var PROVIDER_LABEL = { google: "Google Fonts", fontsource: "Fontsource" };
+function italicHints(family, wantedStyles, availableStyles, downloadedStyles, provider) {
+  const wanted = wantedStyles.includes("italic");
+  const available = availableStyles.includes("italic");
+  if (wanted && !downloadedStyles.includes("italic")) {
+    return [
+      `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.`
+    ];
+  }
+  if (!wanted && available) {
+    return [
+      `${PROVIDER_LABEL[provider]} also ships an italic for "${family}", which was NOT downloaded. If the brand uses italic anywhere, re-run with \`--italic\` \u2014 otherwise the browser slants the upright face, which is not the same shapes.`
+    ];
+  }
+  return [];
+}
+function fetchHints({
+  family,
+  downloadedWeights,
+  downloadedStyles,
+  incomplete,
+  wiring,
+  provider,
+  wantedStyles,
+  availableStyles
+}) {
+  return [
+    WIRING_HINT[wiring](family),
+    ...italicHints(family, wantedStyles, availableStyles, downloadedStyles, provider),
+    `Record the exact weights (${downloadedWeights.join(", ")}) in src/brand/tokens.json and BRAND.md \u2014 a weight tokens.json lists but nothing loads renders as a synthesized fallback, and verify warns about it.`,
+    ...incomplete.length > 0 ? [
+      // The remedy is provider-specific: only a Google family has an @import
+      // to fall back on, and telling an agent to keep one for a Fontsource
+      // family sends it to write an import Google will 400.
+      provider === "google" ? `PARTIAL: ${incomplete.join(", ")} did not download and is NOT in the \`fontFace\` block. Re-run \`baker brand fonts fetch "${family}" --weights ${incomplete.join(",")}\` \u2014 a Google @import cannot cover those weights, because the build drops it before the page loads.` : `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.`
+    ] : [],
+    `Licensing: ${PROVIDER_LABEL[provider]} carries open-licensed families, which are safe to self-host. A client's own commercial face is not \u2014 confirm before re-hosting one.`
+  ];
+}
+async function wireFontFaceIntoStylesheet(css, family, fontFace) {
+  if (!css) return "no-stylesheet";
+  const wired = upsertFontFaceCss(css, family, fontFace);
+  if (wired === css) return "already-wired";
+  await writeFile(path.resolve(process.cwd(), GLOBAL_CSS), wired);
+  return "written";
+}
+function failResolution(family, weights, outcome) {
+  if (outcome.reason === "unreachable") {
+    return fail(
+      "CATALOGUE_UNREACHABLE",
+      `Could not reach ${PROVIDER_LABEL[outcome.provider]} to ask about "${family}".`,
+      {
+        action: "Run the same command again.",
+        explanation: `${PROVIDER_LABEL[outcome.provider]} did not answer, which is not the same as not having the family \u2014 so nothing was concluded from it. Guessing either way would self-host the wrong build, or report a real family as missing.`,
+        provider: outcome.provider
+      }
+    );
+  }
+  if (outcome.reason === "ambiguous-subsets") {
+    return fail(
+      "SUBSET_AMBIGUOUS",
+      `${PROVIDER_LABEL[outcome.provider]} serves "${family}" in several subsets but reports no unicode-range to tell them apart.`,
+      {
+        action: `Retry with a single --subsets value, e.g. --subsets ${outcome.available[0] ?? "latin"}.`,
+        explanation: "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.",
+        available: outcome.available
+      }
+    );
+  }
+  if (outcome.reason === "subset") {
+    return fail("SUBSET_NOT_SERVED", `${PROVIDER_LABEL[outcome.provider]} has "${family}", but not in that subset.`, {
+      action: `Retry with --subsets set to one it serves: ${outcome.available.join(",")}.`,
+      explanation: "A family is split into unicode subsets and not every family ships every one. The weights you asked for are fine \u2014 only the subset is wrong.",
+      available: outcome.available
+    });
+  }
+  if (outcome.reason === "weight") {
+    return fail(
+      "FONT_NOT_SERVED",
+      `${PROVIDER_LABEL[outcome.provider]} has "${family}", but not at weight ${weights.join("/")}.`,
+      {
+        action: `Retry with --weights set to one of these: ${outcome.available.join(",")}.`,
+        explanation: "The family exists; the weight you asked for is not one it ships.",
+        served: outcome.available
+      }
+    );
+  }
+  return failUnknownFamily(family);
+}
+async function failUnknownFamily(family) {
+  const didYouMean = suggestFamilies(family, await fontsourceCatalogue(PROVIDER_DEPS));
+  return fail("FONT_NOT_SERVED", `No font catalogue carries a family called "${family}".`, {
+    action: didYouMean.length ? `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.` : `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 \u2014 it cannot be downloaded.`,
+    explanation: `Tried ${FONT_PROVIDERS.join(" then ")}. Family names are case- and space-sensitive in every catalogue.`,
+    tried: [...FONT_PROVIDERS],
+    ...didYouMean.length ? { didYouMean } : {}
+  });
+}
+async function listFontFiles() {
+  try {
+    const entries = await readdir(path.resolve(process.cwd(), FONTS_DIR), { withFileTypes: true });
+    return entries.filter((e) => e.isFile()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function readGlobalCss() {
+  try {
+    return await readFile(path.resolve(process.cwd(), GLOBAL_CSS), "utf8");
+  } catch {
+    return "";
+  }
+}
+async function unresolvedAction(css, unresolved) {
+  const { plans } = planFontAdoption(await astroSources(), unresolved);
+  if (plans.length > 0) {
+    const names = plans.map((p) => `"${p.family}"`).join(", ");
+    return `Run \`baker brand fonts adopt\` \u2014 ${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.`;
+  }
+  const viaFontsource = [...fontsourceFamilies(css)];
+  const stranded = unresolved.filter((family) => viaFontsource.includes(family.toLowerCase()));
+  if (stranded.length > 0) {
+    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 \u2014 the import is left pointing at nothing, which fails the build before the font check even runs.`;
+  }
+  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}.`;
+}
+var fontsCheckCommand = defineCommand({
+  meta: {
+    name: "check",
+    description: "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 \u2014 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 \u2014 a weight nobody serves is silently synthesized."
+  },
+  async run() {
+    const css = await readGlobalCss();
+    const requests = googleFontRequests(css);
+    const unresolved = unresolvedBrandFamilies(css);
+    if (unresolved.length > 0) {
+      fail("FONT_NOT_LOADED", `Nothing loads ${unresolved.map((f) => `"${f}"`).join(", ")} in ${GLOBAL_CSS}.`, {
+        action: await unresolvedAction(css, unresolved),
+        explanation: "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 \u2014 measured on a live client site. The client's verify fails on this too.",
+        unresolved
+      });
+    }
+    if (requests.length === 0) {
+      writeJson({
+        ok: true,
+        data: { families: [], selfHosted: true },
+        hints: [
+          `No Google Fonts requested in ${GLOBAL_CSS}, and every brand face is provided by an @font-face \u2014 nothing to verify against Google.`
+        ]
+      });
+      return;
+    }
+    const families = await checkFontRequests(requests, fetchGoogleCss);
+    const broken = families.filter((f) => f.missing.length > 0);
+    if (broken.length > 0) {
+      const summary = broken.map(
+        (f) => f.cause === "unknown-family" ? `${f.family} (no such family on Google Fonts \u2014 check the exact spelling)` : `${f.family} ${f.missing.join("/")} (served: ${f.served.join("/") || "none"})`
+      ).join("; ");
+      fail("FONT_NOT_SERVED", `Google Fonts does not serve: ${summary}`, {
+        action: `Correct the family name or weight in ${GLOBAL_CSS} and src/brand/BRAND.md, picking from the \`served\` weights below.`,
+        explanation: "A requested weight Google does not serve is silently synthesized by the browser, so the page looks subtly wrong with nothing failing.",
+        // The per-family breakdown is the point of the command, so it ships on
+        // the failure path too — otherwise the only remedy is re-running the
+        // command that just failed. Healthy families are included so a
+        // multi-family brand shows what NOT to touch.
+        families
+      });
+    }
+    writeJson({
+      ok: true,
+      data: { families },
+      hints: [
+        "Every requested family and weight is really served by Google.",
+        `To stop depending on Google at page load, run \`baker brand fonts fetch "<family>"\` to self-host into ${FONTS_DIR}.`
+      ]
+    });
+  }
+});
+var fontsFetchCommand = defineCommand({
+  meta: {
+    name: "fetch",
+    description: "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."
+  },
+  args: {
+    family: { type: "positional", required: true, description: 'Font family, e.g. "DM Sans"' },
+    weights: {
+      type: "string",
+      description: "Comma-separated weights (default: the weights global.css already requests or self-hosts, else 400)"
+    },
+    subsets: {
+      type: "string",
+      description: `Comma-separated unicode subsets (default: the subsets global.css already self-hosts, else ${DEFAULT_SUBSETS_LABEL})`
+    },
+    italic: {
+      type: "boolean",
+      description: "Also self-host the family's italic faces (default: on when global.css already loads one, off otherwise)"
+    }
+  },
+  async run({ args }) {
+    const family = String(args.family).trim();
+    if (!family) fail("INVALID_FAMILY", 'Pass a font family, e.g. `baker brand fonts fetch "DM Sans"`.');
+    const css = await readGlobalCss();
+    const declared = googleFontRequests(css).find((r) => r.family.toLowerCase() === family.toLowerCase());
+    const provided = declared?.weights.length ? declared.weights : selfHostedWeights(css, family);
+    const weights = resolveFetchWeights(args.weights, provided);
+    if (weights.length === 0) {
+      fail("INVALID_WEIGHTS", `"${args.weights}" has no usable weight \u2014 pass whole hundreds, e.g. --weights 400,700.`);
+    }
+    const wanted = new Set(resolveFetchSubsets(args.subsets, selfHostedSubsets(css, family)));
+    const styles = resolveFetchStyles(args.italic, selfHostedStyles(css, family));
+    const resolved = await resolveBrandFaces(family, weights, [...wanted], PROVIDER_DEPS, styles);
+    if (!resolved.ok) return failResolution(family, weights, resolved);
+    const faces = resolved.faces;
+    const fontsDir = path.resolve(process.cwd(), FONTS_DIR);
+    await mkdir(fontsDir, { recursive: true });
+    const downloaded = [];
+    for (const face of faces) {
+      const res = await fetch(face.url, {
+        headers: { "User-Agent": BROWSER_UA },
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+      });
+      if (!res.ok) continue;
+      await writeFile(path.join(fontsDir, fontFileName(face)), Buffer.from(await res.arrayBuffer()));
+      downloaded.push(face);
+    }
+    const written = downloaded.map(fontFileName);
+    if (written.length === 0) {
+      fail("DOWNLOAD_FAILED", `Could not download any file for "${family}".`, {
+        action: "Retry; if it keeps failing, keep the Google @import and note it in BRAND.md.",
+        explanation: "The font stylesheet resolved but the font files themselves did not download."
+      });
+    }
+    const fontFace = renderFontFaceCss(downloaded);
+    const downloadedWeights = [...new Set(downloaded.map((f) => f.weight))].sort((a, b) => a - b);
+    const downloadedStyles = [...new Set(downloaded.map((f) => f.style))].sort();
+    const incomplete = weights.filter((w) => !downloadedWeights.includes(w));
+    const wiring = await wireFontFaceIntoStylesheet(css, family, fontFace);
+    writeJson({
+      ok: true,
+      data: {
+        family,
+        provider: resolved.provider,
+        weights: downloadedWeights,
+        styles: downloadedStyles,
+        files: written,
+        fontFace,
+        stylesheet: wiring
+      },
+      hints: fetchHints({
+        family,
+        downloadedWeights,
+        downloadedStyles,
+        incomplete,
+        wiring,
+        provider: resolved.provider,
+        wantedStyles: styles,
+        availableStyles: resolved.availableStyles
+      })
+    });
+  }
+});
+async function astroSources() {
+  const out = [];
+  let entries;
+  try {
+    entries = await readdir("src", { recursive: true, withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".astro")) continue;
+    const file = path.posix.join(entry.parentPath ?? "src", entry.name);
+    try {
+      out.push({ path: file, source: await readFile(file, "utf8") });
+    } catch {
+    }
+  }
+  return out;
+}
+var fontsAdoptCommand = defineCommand({
+  meta: {
+    name: "adopt",
+    description: "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/ \u2014 downloading it again would hand that page a different build of the same face."
+  },
+  async run() {
+    const css = await readGlobalCss();
+    if (!css) fail("NO_STYLESHEET", `There is no ${GLOBAL_CSS} to adopt faces into.`);
+    const unresolved = unresolvedBrandFamilies(css);
+    if (unresolved.length === 0) {
+      writeJson({
+        ok: true,
+        data: { adopted: [], conflicts: [] },
+        hints: [`Every --font-* family in ${GLOBAL_CSS} is already loaded by it \u2014 nothing to adopt.`]
+      });
+      return;
+    }
+    const { plans, conflicts } = planFontAdoption(await astroSources(), unresolved);
+    const available = new Set(await listFontFiles());
+    const adopted = [];
+    const skipped = [];
+    let next = css;
+    for (const plan of plans) {
+      const missing = missingFontFiles(plan.urls, available);
+      if (missing.length > 0) {
+        skipped.push({ family: plan.family, reason: `${missing.join(", ")} is not in ${FONTS_DIR}` });
+        continue;
+      }
+      next = upsertFontFaceCss(next, plan.family, plan.blocks.join("\n"));
+      adopted.push({
+        family: plan.family,
+        files: plan.files,
+        weights: plan.blocks.map((b) => b.match(/font-weight\s*:\s*([^;]+)/i)?.[1]?.trim() ?? "400")
+      });
+    }
+    if (adopted.length === 0) {
+      if (conflicts.length > 0) {
+        fail(
+          "ADOPTION_CONFLICT",
+          `${conflicts.map((c) => `"${c.family}" is declared differently in ${c.files.join(" and ")}`).join("; ")}.`,
+          {
+            action: "Make the declarations match \u2014 same weights, same files \u2014 then re-run. Pick the one whose page renders correctly.",
+            explanation: "One global scope holds one mapping per family, so adopting would silently repaint whichever page lost.",
+            conflicts
+          }
+        );
+      }
+      if (skipped.length > 0) {
+        fail("FONT_FILE_MISSING", `${skipped.map((s) => `${s.family} \u2014 ${s.reason}`).join("; ")}.`, {
+          action: `Add the missing file to ${FONTS_DIR}, or fix the src: url() in the page that declares it, then re-run.`,
+          explanation: "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.",
+          skipped
+        });
+      }
+      fail("NOTHING_TO_ADOPT", `No page declares a face for ${unresolved.map((f) => `"${f}"`).join(", ")}.`, {
+        action: `Self-host it instead: \`baker brand fonts fetch "${unresolved[0]}"\`.`,
+        explanation: "Adopting only moves faces the repo already ships; it never downloads one."
+      });
+    }
+    await writeFile(path.resolve(process.cwd(), GLOBAL_CSS), next);
+    for (const plan of plans.filter((p) => adopted.some((a) => a.family === p.family))) {
+      for (const file of plan.files) {
+        const source = await readFile(file, "utf8");
+        await writeFile(file, stripFontFaceBlocks(source, plan.family));
+      }
+    }
+    writeJson({
+      ok: true,
+      data: { adopted, conflicts, skipped },
+      hints: [
+        `Moved ${adopted.map((a) => `"${a.family}" (${a.weights.join("/")})`).join(", ")} into ${GLOBAL_CSS} and removed the page copies, so every page loads them \u2014 not just the one that declared them.`,
+        ...conflicts.length > 0 ? [
+          `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.`
+        ] : [],
+        ...skipped.length > 0 ? [`SKIPPED: ${skipped.map((s) => `${s.family} \u2014 ${s.reason}`).join("; ")}.`] : [],
+        `Run \`baker brand fonts check\` to confirm nothing is left unresolved.`
+      ]
+    });
+  }
+});
+var fontsCommand = defineCommand({
+  meta: {
+    name: "fonts",
+    description: `Verify and self-host the brand's typefaces.
+
+Start here: \`baker brand fonts check\` \u2014 confirms the fonts the brand claims really load.
+
+Subcommands:
+  baker brand fonts check           \u2014 fail if any --font-* family has nothing loading it, then ask Google what it actually serves for the ones global.css requests
+  baker brand fonts fetch <family>  \u2014 download a family into src/brand/fonts/ and wire its @font-face into src/styles/global.css
+  baker brand fonts adopt           \u2014 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/`
+  },
+  subCommands: {
+    check: fontsCheckCommand,
+    fetch: fontsFetchCommand,
+    adopt: fontsAdoptCommand
+  }
+});
+
+export {
+  fetchJson,
+  lookupGoogleCss,
+  fontsCheckCommand,
+  fontsFetchCommand,
+  fontsAdoptCommand,
+  fontsCommand
+};
+//# sourceMappingURL=chunk-DQZEJV3K.js.map