@koda-sl/baker-cli 0.530.0 → 0.532.0

package/dist/chunk-SEC6FPWC.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-CREEY2FS.js";
-import {
-  registerSchema,
-  writeJson
-} from "./chunk-FSGJSREN.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. A client's own typeface is licensed for its landings and ads too \u2014 self-host it without asking about rights.`
-  ];
-}
-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-SEC6FPWC.js.map

package/dist/chunk-SJAUMPL3.js

@@ -1,46 +0,0 @@
-import {
-  ApiError
-} from "./chunk-B4UVJCJ4.js";
-import {
-  writeJson
-} from "./chunk-FSGJSREN.js";
-
-// src/commands/testimonials/sources/shared.ts
-function reportError(err) {
-  if (err instanceof ApiError) {
-    writeJson({ ok: false, error: { code: err.code, message: err.message } });
-    process.exit(1);
-  }
-  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
-  process.exit(1);
-}
-function reportInvalid(issue) {
-  writeJson({
-    ok: false,
-    error: {
-      code: "VALIDATION_ERROR",
-      message: issue ? `${issue.path.map(String).join(".") || "input"}: ${issue.message}` : "Invalid request"
-    }
-  });
-  process.exit(1);
-}
-function compactSource(source) {
-  return {
-    id: source.id,
-    platform: source.platform,
-    label: source.label,
-    ...source.pageUrl ? { url: source.pageUrl } : {},
-    status: source.status,
-    reviews: source.reviews,
-    autoSync: source.refreshInterval,
-    ...source.lastSyncedAt ? { lastSyncedAt: new Date(source.lastSyncedAt).toISOString() } : {},
-    ...source.error ? { error: source.error } : {}
-  };
-}
-
-export {
-  reportError,
-  reportInvalid,
-  compactSource
-};
-//# sourceMappingURL=chunk-SJAUMPL3.js.map