@koda-sl/baker-cli 0.150.0-dev.a970fa118 → 0.150.0

package/dist/cli.js

@@ -36,7 +36,7 @@ import {
   toModelSafeImage,
   ulid,
   validateCanvasDeep
-} from "./chunk-JBDSJZBZ.js";
+} from "./chunk-OO5BDH3J.js";
 import {
   csvOrJson,
   daysAgoIso,
@@ -15369,11 +15369,46 @@ function resolveFetchWeights(flag, declared) {
   return declared?.length ? declared : [400];
 }
 function googleFontCssUrl(family, weights) {
-  const name = family.trim().replace(/\s+/g, "+");
+  const name = family.trim().split(/\s+/).map(encodeURIComponent).join("+");
   const axis = [...new Set(weights)].sort((a, b) => a - b).join(";");
   const spec = axis ? `${name}:wght@${axis}` : name;
   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 probes = await Promise.all(
+    STANDARD_WEIGHTS.map(async (weight) => await fetchCss(googleFontCssUrl(family, [weight])) ? weight : null)
+  );
+  return probes.filter((w) => w !== null);
+}
+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;
+}
 
 // src/commands/brand/fonts.ts
 var GLOBAL_CSS = path.join("src", "styles", "global.css");
@@ -15406,19 +15441,19 @@ function fail(code, message, fix) {
   writeJson({ ok: false, error: { code, message, ...fix ? { fix } : {} } });
   process.exit(2);
 }
+var REQUEST_TIMEOUT_MS = 15e3;
 async function fetchGoogleCss(url) {
   try {
-    const res = await fetch(url, { headers: { "User-Agent": BROWSER_UA } });
+    const res = await fetch(url, {
+      headers: { "User-Agent": BROWSER_UA },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
     if (!res.ok) return null;
     return await res.text();
   } catch {
     return null;
   }
 }
-async function diagnoseUnserved(family) {
-  const bare = await fetchGoogleCss(googleFontCssUrl(family, []));
-  return bare === null ? "unknown-family" : "unavailable-weight";
-}
 async function readGlobalCss() {
   try {
     return await readFile(path.resolve(process.cwd(), GLOBAL_CSS), "utf8");
@@ -15444,41 +15479,20 @@ var fontsCheckCommand = defineCommand85({
       });
       return;
     }
-    const families = [];
-    const unavailable = [];
-    for (const request of requests) {
-      const url = googleFontCssUrl(request.family, request.weights);
-      const served = await fetchGoogleCss(url);
-      if (served === null) {
-        const cause = await diagnoseUnserved(request.family);
-        unavailable.push(
-          cause === "unknown-family" ? `${request.family} (no such family on Google Fonts \u2014 check the exact spelling)` : `${request.family} ${request.weights.join("/")} (the family exists, these weights do not)`
-        );
-        families.push({
-          family: request.family,
-          requested: request.weights,
-          served: [],
-          missing: request.weights,
-          cause
-        });
-        continue;
-      }
-      const faces = parseGoogleFontFaces(served);
-      const servedWeights = [...new Set(faces.map((f) => f.weight))].sort((a, b) => a - b);
-      const missing = request.weights.filter((w) => !servedWeights.includes(w));
-      if (missing.length > 0) unavailable.push(`${request.family} ${missing.join("/")}`);
-      families.push({
-        family: request.family,
-        requested: request.weights,
-        served: servedWeights,
-        missing,
-        subsets: [...new Set(faces.map((f) => f.subset))]
-      });
-    }
-    if (unavailable.length > 0) {
-      fail("FONT_NOT_SERVED", `Google Fonts does not serve: ${unavailable.join("; ")}`, {
-        action: `Correct the family name or weight in ${GLOBAL_CSS} and src/brand/BRAND.md, or run \`baker brand fonts fetch\` for a weight that does exist.`,
-        explanation: "A requested weight Google does not serve is silently synthesized by the browser, so the page looks subtly wrong with nothing failing."
+    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({
@@ -15515,16 +15529,18 @@ var fontsFetchCommand = defineCommand85({
     );
     const servedCss = await fetchGoogleCss(googleFontCssUrl(family, weights));
     if (servedCss === null) {
-      const cause = await diagnoseUnserved(family);
+      const [diagnosis] = await checkFontRequests([{ family, weights }], fetchGoogleCss);
+      const served = diagnosis?.served ?? [];
       fail(
         "FONT_NOT_SERVED",
-        cause === "unknown-family" ? `Google Fonts has no family called "${family}".` : `"${family}" exists on Google Fonts but not at weight ${weights.join("/")}.`,
-        cause === "unknown-family" ? {
+        served.length === 0 ? `Google Fonts has no family called "${family}".` : `"${family}" exists on Google Fonts but not at weight ${weights.join("/")}.`,
+        served.length === 0 ? {
           action: "Check the exact family name at fonts.google.com, then retry.",
           explanation: "Family names are case- and space-sensitive in the Google Fonts API."
         } : {
-          action: `Run \`baker brand fonts check\` to see which weights this family really ships, then retry with --weights set to one of those.`,
-          explanation: "Google rejects the whole request when one requested weight does not exist."
+          action: `Retry with --weights set to one of these: ${served.join(",")}.`,
+          explanation: "Google rejects the whole request when one requested weight does not exist.",
+          served
         }
       );
     }
@@ -15539,7 +15555,10 @@ var fontsFetchCommand = defineCommand85({
     await mkdir(fontsDir, { recursive: true });
     const downloaded = [];
     for (const face of faces) {
-      const res = await fetch(face.url, { headers: { "User-Agent": BROWSER_UA } });
+      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);