@koda-sl/baker-cli 0.476.0 → 0.477.0

package/dist/chunk-NFDAIY6J.js

@@ -1,191 +0,0 @@
-import {
-  hintLines,
-  splitHints
-} from "./chunk-D5FY4FAK.js";
-import {
-  isNotConnectedError,
-  writeJsonEnvelope
-} from "./chunk-CGOVXSSY.js";
-import {
-  ApiError,
-  apiPost
-} from "./chunk-JLCK7K6Y.js";
-import {
-  requireChatId,
-  resolveChatId
-} from "./chunk-G3UCXCC2.js";
-
-// src/commands/ga4/shared.ts
-import { readFileSync } from "fs";
-function failValidation(message) {
-  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
-  process.exit(1);
-}
-function requireTarget(args, entity) {
-  const positional = Array.isArray(args._) ? args._[0] : void 0;
-  const target = args.id ?? args.target ?? positional;
-  if (typeof target !== "string" || target.length === 0) {
-    failValidation(`pass the ${entity} id as the positional argument`);
-  }
-  return target;
-}
-function readJsonSource(args, flag) {
-  const inline = args[flag];
-  const file = args.file;
-  const raw = typeof file === "string" && file.length > 0 ? readFileSync(file, "utf8") : typeof inline === "string" && inline.length > 0 ? inline : void 0;
-  if (raw === void 0) {
-    failValidation(`pass --${flag} with inline JSON or --file with a path to a JSON file`);
-  }
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return failValidation(`--${flag} is not valid JSON`);
-  }
-}
-function asObject(value, flag, index) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    failValidation(
-      index === void 0 ? `--${flag} must be a JSON object` : `--${flag}[${index}] must be a JSON object`
-    );
-  }
-  return value;
-}
-function loadJsonArg(args, flag = "json") {
-  return asObject(readJsonSource(args, flag), flag);
-}
-function loadJsonPayloads(args) {
-  const parsed = readJsonSource(args, "json");
-  if (!Array.isArray(parsed)) {
-    return [asObject(parsed, "json")];
-  }
-  if (parsed.length === 0) {
-    failValidation("--json is an empty list \u2014 pass at least one definition");
-  }
-  return parsed.map((entry, index) => asObject(entry, "json", index));
-}
-var RETRYABLE_CODES = /* @__PURE__ */ new Set(["RATE_LIMITED", "UNAVAILABLE", "INTERNAL_ERROR", "NETWORK_ERROR", "TIMEOUT"]);
-function handleError(err) {
-  if (err instanceof ApiError) {
-    const readOnly = err.code === "FORBIDDEN" && /read the property but not change it/i.test(err.message);
-    writeJsonEnvelope({
-      ok: false,
-      error: {
-        code: err.code,
-        message: err.message,
-        ...readOnly ? {
-          fix: {
-            action: "reconnect",
-            explanation: "The Google Analytics connection is read-only. Ask the user to reconnect Google Analytics \u2014 in the dashboard, Brain \u2192 Integrations \u2192 Platforms \u2192 Google Analytics \u2014 which grants the permission to change the property. Reporting (`baker ga4 query`, `baker ga4 audit`) keeps working meanwhile, so carry on with the rest of the job and tell them what you will set up once they have reconnected. Don't claim anything was configured."
-          }
-        } : err.code === "UNAUTHORIZED" || err.code === "FORBIDDEN" && isNotConnectedError(err.code, err.message) ? {
-          fix: {
-            action: "request_connection",
-            explanation: 'Google Analytics is not connected for this company yet, or no property has been picked. Don\'t send the user to Settings \u2014 call the `request_connection` tool with { platform: "google-analytics", reason } and they connect and pick their property from inside the chat. If the `request_connection` call fails, say so plainly and give the exact route: dashboard \u2192 Brain \u2192 Integrations \u2192 Platforms \u2192 Google Analytics. Then carry on with the rest of the task.'
-          }
-        } : {},
-        retryable: RETRYABLE_CODES.has(err.code)
-      }
-    });
-    process.exit(1);
-  }
-  writeJsonEnvelope({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error", retryable: true } });
-  process.exit(1);
-}
-var STAGE_HINTS = [
-  "Staged only \u2014 nothing has changed in Google Analytics yet. These apply when the chat completes, and an applied change takes effect on the property immediately: there is no version to publish afterwards and no undo. Say the changes are ready and take effect when the user completes the chat \u2014 not that they are done already."
-];
-var WARNING_HINT = "Read the warnings above before telling the user this is ready.";
-async function stageOp(op) {
-  const chatId = requireChatId();
-  try {
-    const { data, hints } = splitHints(await apiPost("/api/ga4/draft/stage", { chatId, op }));
-    writeJsonEnvelope({
-      ok: true,
-      data,
-      hints: [...hints, ...STAGE_HINTS, ...data.warnings.length > 0 ? [WARNING_HINT] : []]
-    });
-  } catch (err) {
-    handleError(err);
-  }
-}
-async function stageOps(ops) {
-  const [only] = ops;
-  if (ops.length === 1 && only) {
-    await stageOp(only);
-    return;
-  }
-  const chatId = requireChatId();
-  try {
-    const { data, hints } = splitHints(
-      await apiPost("/api/ga4/draft/stage-batch", { chatId, ops })
-    );
-    writeJsonEnvelope({
-      ok: true,
-      data,
-      hints: [...hints, ...STAGE_HINTS, ...data.ops.some((op) => op.warnings.length > 0) ? [WARNING_HINT] : []]
-    });
-  } catch (err) {
-    handleError(err);
-  }
-}
-async function draftAction(path, body, chat) {
-  const chatId = resolveChatId(chat);
-  try {
-    const { data, hints } = splitHints(await apiPost(path, { chatId, ...body }));
-    writeJsonEnvelope({ ok: true, data, ...hints.length > 0 ? { hints } : {} });
-    return data;
-  } catch (err) {
-    handleError(err);
-  }
-}
-function renderDraft(response) {
-  if (response.count === 0) {
-    return "No Google Analytics changes staged on this chat.";
-  }
-  const lines = [
-    `${response.count} staged Google Analytics change(s)`,
-    ...response.ops.map((op) => {
-      const status = op.result ? ` [${op.result.status}]` : "";
-      return `  ${op.ref}  ${op.summary}${status}`;
-    })
-  ];
-  if (response.status === "applied") {
-    const failed = response.ops.filter((op) => op.result?.status !== "applied");
-    lines.push(
-      "",
-      failed.length === 0 ? "All applied \u2014 these are in effect on the property now." : `${failed.length} of ${response.count} did not apply. The rest are in effect on the property.`
-    );
-  }
-  if (response.publishError) {
-    lines.push("", response.publishError);
-  }
-  return lines.join("\n");
-}
-async function draftList(json, chat) {
-  const chatId = resolveChatId(chat);
-  try {
-    const response = await apiPost("/api/ga4/draft", { chatId });
-    const { data, hints } = splitHints(response);
-    if (json) {
-      writeJsonEnvelope({ ok: true, data, ...hints.length > 0 ? { hints } : {} });
-      return;
-    }
-    process.stdout.write(`${renderDraft(data)}${hintLines(response)}
-`);
-  } catch (err) {
-    handleError(err);
-  }
-}
-
-export {
-  failValidation,
-  requireTarget,
-  loadJsonArg,
-  loadJsonPayloads,
-  handleError,
-  stageOp,
-  stageOps,
-  draftAction,
-  draftList
-};
-//# sourceMappingURL=chunk-NFDAIY6J.js.map

package/dist/chunk-OKHSMDCY.js

@@ -1,494 +0,0 @@
-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-2YXY56FK.js";
-import {
-  registerSchema,
-  writeJson
-} from "./chunk-IWLWY2UD.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-OKHSMDCY.js.map