@koda-sl/baker-cli 0.223.0 → 0.224.0-dev.33d1391b8

package/README.md

@@ -5521,15 +5521,18 @@ baker brand fonts fetch "Inter" --subsets latin,latin-ext  # add accented-glyph
 - **`check`** runs two checks in order. First, every `--font-*` family in `src/styles/global.css` must be provided by an `@font-face` or a Google import; a family provided by nothing exits 2 with `FONT_NOT_LOADED` and lists them at `error.fix.unresolved`. Then, for the families requested from Google, it asks Google what it *actually* serves and reports `requested` / `served` / `missing` plus the available unicode subsets, exiting 2 with `FONT_NOT_SERVED` when the brand asks for something Google won't serve — distinguishing an unknown family name from a family that exists at other weights, since the fix differs.
 - **`check` used to pass on the worst case.** With no Google `@import` it answered `selfHosted: true` without looking at whether anything hosted the font, so a stylesheet declaring `--font-sans: "Inter"` and loading nothing was reported healthy. Measured across the client fleet, 56 of 60 repos have no Google import, so that was the answer almost everyone got; the only thing that caught it was the scaffold validator at verify time.
 - **Failures carry the numbers, so nothing needs a second call.** `check`'s error keeps the full per-family breakdown at `error.fix.families` (healthy families included, so a multi-family brand shows what not to touch), and both commands probe the standard weights to report the ones that *do* exist at `error.fix.served` — the remediation is "retry with one of these" rather than "run `check`", which would be the command that just failed.
-- **`fetch`** downloads the family into `src/brand/fonts/` **and writes its `@font-face` into `global.css` above `@theme`**, so the family loads without a second step. It is idempotent — re-running replaces that family's faces rather than stacking duplicates — and it leaves other families, and any commented-out block, untouched. Defaults to the `latin` subset; `--subsets latin,latin-ext` adds accented-glyph coverage for Spanish and Portuguese copy. One file per weight *and* subset, since Google ships them separately and `unicode-range` is carried through verbatim.
-- **A re-run keeps the weights the stylesheet already self-hosts.** `fetch` puts the downloaded faces *in charge* of the family, so it has to know which weights already exist — and the first fetch is what removes the Google `@import`, leaving the stylesheet's own `@font-face` rules as the only surviving record of them. It reads those. Passing `--weights` on a re-run therefore **narrows** the family to exactly what you passed: every other weight is dropped from the stylesheet and its file orphaned, with nothing failing, because the family stays resolved either way. A variable face declared as a range (`font-weight: 100 900`) counts as every step in that range, not as its first number — read as `100` alone, a re-fetch replaced the whole range with a single hairline rule.
+- **`fetch`** downloads the family into `src/brand/fonts/` **and writes its `@font-face` into `global.css` above `@theme`**, so the family loads without a second step. It is idempotent — re-running replaces that family's faces rather than stacking duplicates — and it leaves other families, any commented-out block, and any face it cannot itself write untouched. Defaults to the subsets the family already self-hosts, else `latin`; `--subsets latin,latin-ext` adds accented-glyph coverage for Spanish and Portuguese copy. One file per weight *and* subset, since Google ships them separately and `unicode-range` is carried through verbatim.
+- **A re-run keeps the weights and subsets the stylesheet already self-hosts.** `fetch` puts the downloaded faces *in charge* of the family, so it has to know which weights already exist — and the first fetch is what removes the Google `@import`, leaving the stylesheet's own `@font-face` rules as the only surviving record of them. It reads those. Passing `--weights` on a re-run therefore **narrows** the family to exactly what you passed: every other weight is dropped from the stylesheet and its file orphaned, with nothing failing, because the family stays resolved either way. A variable face declared as a range (`font-weight: 100 900`) counts as every step in that range, not as its first number — read as `100` alone, a re-fetch replaced the whole range with a single hairline rule. `--subsets` works the same way and for the same reason: the default is what the family already self-hosts (read back from the file names `fetch` wrote), so a bare re-run after `--subsets latin,latin-ext` no longer drops the latin-ext face and leaves accented copy on a fallback.
+- **`--italic` self-hosts the family's italic too, and a stylesheet that already loads one turns it on by itself.** There is deliberately no `--no-italic`: `--weights` and `--subsets` narrow because a brand really does drop a weight, but narrowing an italic away is the silent loss this path exists to prevent — delete the rule if you mean it. A face `fetch` cannot write is never deleted either, so a hand-made `oblique` survives untouched.
+- **It always asks the catalogue about italic, and says what it found.** The request costs the same either way, so when a family ships an italic the brand did not take, that goes in the hints — and when you ask for one the catalogue does not ship, that goes in the hints too, instead of reading as success while the browser slants the upright face. Which styles landed comes back as `data.styles`.
 - **Drop the family from the Google `@import` afterwards** — otherwise the page self-hosts *and* still calls Google. Record the weights in `src/brand/BRAND.md` in the same change. (`fetch` used to only print the block for you to paste; the download happened either way, so a skipped paste left the files on disk with nothing loading them. One client repo had 44 font files and zero `@font-face` rules.)
 - **The written `src:` is relative to `global.css` (`../brand/fonts/…`) on purpose — keep it that way.** A root-relative `/src/brand/fonts/…` reads to the bundler as a path something else already serves, so the file never lands in the published build and every page 404s it. That failure is silent: an unfetchable face falls back to a system font, so the site just renders off-brand. Kept relative, the bundler resolves it on disk, content-hashes it, and ships it. The scaffold's `validate-public-asset-refs` blocks the root-relative form.
 - **`adopt`** moves brand faces a page already self-hosts into `global.css`. A `--font-*` token in `@theme` is global, but a page's own `<style>` ships only with that page — so one page declaring the face leaves every other page on a fallback, which is invisible unless you happen to load one of them. It never downloads: re-fetching the same family would hand the working page a different build of the face. Refuses a family that two files declare differently (`ADOPTION_CONFLICT`) and one whose files are not in `src/brand/fonts/` (`FONT_FILE_MISSING`); `NOTHING_TO_ADOPT` means no page declares it at all, and that one is genuinely a `fetch`.
 - **`check` tells you which of the two to run.** Its `error.fix.action` says `adopt` when a page already self-hosts the family and `fetch` when nothing does — worth following, because reaching for `fetch` on a face the repo already ships is the exact substitution `adopt` exists to prevent.
 - **The scaffold sync adopts too, unattended.** The `2026-08-20-wire-unresolved-brand-fonts` migration runs the same planner at the front of every sync, before it asks any catalogue, so a client whose brand face lives in one page's `<style>` is repaired without anyone opening a Session. It diverges in one place: a conflict there falls through to downloading rather than refusing, because refusing would leave that client frozen out of every future scaffold update with nobody watching to reconcile it. It draws the Google-outage line in the same place, and has to: an unreachable catalogue is reported as *retryable*, which is what stops the migration runner recording — and so permanently disabling — a repair that only hit a bad minute.
 - **Two catalogues, Google first.** `fetch` resolves against Google Fonts, then Fontsource — which carries open-licence families Google does not (Open Sauce One, and ~2000 more). Google wins a family both carry, so a re-run can never swap which foundry's file the brand ships; the winner is reported as `data.provider`. When no catalogue has the name, the error carries `fix.didYouMean` — a client asking for "Open Sauce" gets back One / Sans / Two rather than a dead end.
-- **Leaving Google takes more than one refusal.** Google answers `400` both to a name it has never heard of *and* to a weight it does not ship, so one rejection cannot mean "try elsewhere" — read that way, `fetch "Lato" --weights 400,500` self-hosted Fontsource's Lato, because Google has no Lato 500. On a refusal the command re-asks Google one weight at a time, and if the family exists at any of them it fails `FONT_NOT_SERVED` with `fix.served` rather than switching foundry. Note Google's API is **case-sensitive** (`family=roboto` → 400, `family=Roboto` → 200), so a mis-cased name is one of the ways a Google family ends up being looked for elsewhere.
+- **Google refuses a request only when EVERY tuple in it is missing.** Measured, not assumed: `Lato:wght@400;500` answers **200 with 400 alone** — the missing weight is silently dropped, not rejected — while `Lato:wght@500` on its own is a `400`. So a refusal is true both of a name Google has never heard of *and* of a family asked for at weights it does not ship, and one rejection cannot mean "try elsewhere": read that way, `fetch "Lato" --weights 500` self-hosts Fontsource's Lato. On a refusal the command re-asks Google **once, for all nine standard weights**, and if the family exists at any of them it fails `FONT_NOT_SERVED` with `fix.served` rather than switching foundry. Note Google's API is **case-sensitive** (`family=roboto` → 400, `family=Roboto` → 200), so a mis-cased name is one of the ways a Google family ends up being looked for elsewhere.
+- **That probe is one request, and it matters that it is.** It used to fan out nine concurrent requests per family, on the belief above. Google answers a rapid series of requests with **`400`** — indistinguishable from "does not carry it" — so a three-family brand firing 27 requests could be told a real family is unknown, and act on it by self-hosting another foundry's build. The same fan-out ran unattended in the scaffold's wiring migration, where the substitute gets committed to the client repo.
 - **An unanswered catalogue is never a verdict, on either of them.** A lookup that times out or 5xxs fails `CATALOGUE_UNREACHABLE` (with `fix.provider`) and asks you to re-run, instead of self-hosting a different foundry's build on the strength of one failed request. That holds for Fontsource too: only its `404` means "no such family", so an outage there can no longer surface as "no font catalogue carries a family called X" — advice that would send you to check the spelling, or to hand-write an `@font-face` for a face Fontsource has.
 - **Multi-subset Fontsource families need the API's `unicode-range`, and get it.** Two `@font-face` rules with the same family, style and weight and no range both claim every character, so the later silently wins and the other file is downloaded, fingerprinted, shipped and never read. The ~120 families Fontsource hosts itself are single-subset with no range (nothing to disambiguate); the ~1976 it mirrors from Google are multi-subset and carry the map, which `fetch` now emits. If a multi-subset family ever reports no range, `fetch` fails `SUBSET_AMBIGUOUS` rather than writing two rules that cannot both apply.
 - **Licensing:** Google Fonts and Fontsource carry open-licensed families, safe to self-host. A client's own commercial typeface is not — confirm before re-hosting one.

package/dist/cli.js

@@ -21272,24 +21272,28 @@ function renderFontFaceCss(faces) {
 }
 var FONT_PROVIDERS = ["google", "fontsource"];
 var FONTSOURCE_API = "https://api.fontsource.org/v1";
+var FONT_STYLES = ["normal", "italic"];
+var ITAL_AXIS = { normal: 0, italic: 1 };
 function fontsourceId(family) {
   return family.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
-function fontsourceFaces(meta, weights, subsets) {
+function fontsourceFaces(meta, weights, subsets, styles = ["normal"]) {
   const faces = [];
   for (const subset of subsets.filter((s) => meta.subsets.includes(s))) {
     for (const weight of weights.filter((w) => meta.weights.includes(w))) {
-      const url = meta.variants[String(weight)]?.normal?.[subset]?.url?.woff2;
-      if (!url) continue;
-      faces.push({
-        subset,
-        family: meta.family,
-        style: "normal",
-        weight,
-        url,
-        unicodeRange: meta.unicodeRange?.[subset] ?? "",
-        provider: "fontsource"
-      });
+      for (const style of styles.filter((style2) => meta.styles.includes(style2))) {
+        const url = meta.variants[String(weight)]?.[style]?.[subset]?.url?.woff2;
+        if (!url) continue;
+        faces.push({
+          subset,
+          family: meta.family,
+          style,
+          weight,
+          url,
+          unicodeRange: meta.unicodeRange?.[subset] ?? "",
+          provider: "fontsource"
+        });
+      }
     }
   }
   return faces;
@@ -21319,29 +21323,30 @@ function asFontsourceMeta(body) {
   const ok = typeof meta.family === "string" && Array.isArray(meta.weights) && Array.isArray(meta.styles) && Array.isArray(meta.subsets) && typeof meta.variants === "object" && meta.variants !== null;
   return ok ? meta : null;
 }
-async function probeGoogleWeights(family, lookup) {
-  const probes = await Promise.all(
-    STANDARD_WEIGHTS.map(async (weight) => ({ weight, got: await lookup(googleFontCssUrl(family, [weight])) }))
-  );
-  if (probes.some((probe) => probe.got.status === "unreachable")) return null;
-  return probes.filter((probe) => probe.got.status === "served").map((probe) => probe.weight);
+async function probeGoogleFaces(family, lookup) {
+  const got = await lookup(googleFontCssUrl(family, STANDARD_WEIGHTS, FONT_STYLES));
+  if (got.status === "unreachable") return null;
+  return got.status === "served" ? parseGoogleFontFaces(got.css) : [];
 }
-async function resolveFromGoogle(family, weights, subsets, deps) {
-  const google = await deps.lookupGoogleCss(googleFontCssUrl(family, weights));
+async function resolveFromGoogle(family, weights, subsets, styles, deps) {
+  const google = await deps.lookupGoogleCss(googleFontCssUrl(family, weights, FONT_STYLES));
   if (google.status === "unreachable") return { ok: false, reason: "unreachable", provider: "google" };
   if (google.status === "absent") {
-    const served2 = await probeGoogleWeights(family, deps.lookupGoogleCss);
+    const served2 = await probeGoogleFaces(family, deps.lookupGoogleCss);
     if (served2 === null) return { ok: false, reason: "unreachable", provider: "google" };
-    return served2.length > 0 ? { ok: false, reason: "weight", provider: "google", available: served2 } : null;
+    const available = [...new Set(served2.map((face) => face.weight))].sort((a, b) => a - b);
+    return available.length > 0 ? { ok: false, reason: "weight", provider: "google", available } : null;
   }
   const served = parseGoogleFontFaces(google.css);
   if (served.length === 0) return null;
-  const faces = served.filter((face) => subsets.includes(face.subset)).map((face) => ({ ...face, provider: "google" }));
-  if (faces.length > 0) return { ok: true, provider: "google", faces };
+  const availableStyles = [...new Set(served.map((face) => face.style))].sort();
+  const inSubset = served.filter((face) => subsets.includes(face.subset));
+  const faces = inSubset.filter((face) => styles.includes(face.style)).map((face) => ({ ...face, provider: "google" }));
+  if (faces.length > 0) return { ok: true, provider: "google", faces, availableStyles };
   return { ok: false, reason: "subset", provider: "google", available: [...new Set(served.map((f) => f.subset))] };
 }
-async function resolveBrandFaces(family, weights, subsets, deps) {
-  const google = await resolveFromGoogle(family, weights, subsets, deps);
+async function resolveBrandFaces(family, weights, subsets, deps, styles = ["normal"]) {
+  const google = await resolveFromGoogle(family, weights, subsets, styles, deps);
   if (google) return google;
   let body;
   try {
@@ -21351,12 +21356,12 @@ async function resolveBrandFaces(family, weights, subsets, deps) {
   }
   const meta = asFontsourceMeta(body);
   if (meta) {
-    const faces = fontsourceFaces(meta, weights, subsets);
+    const faces = fontsourceFaces(meta, weights, subsets, styles);
     const ambiguous = undisambiguatedSubsets(faces);
     if (ambiguous.length > 0) {
       return { ok: false, reason: "ambiguous-subsets", provider: "fontsource", available: meta.subsets };
     }
-    if (faces.length > 0) return { ok: true, provider: "fontsource", faces };
+    if (faces.length > 0) return { ok: true, provider: "fontsource", faces, availableStyles: [...meta.styles].sort() };
     if (!subsets.some((subset) => meta.subsets.includes(subset))) {
       return { ok: false, reason: "subset", provider: "fontsource", available: meta.subsets };
     }
@@ -21453,18 +21458,28 @@ function resolveFetchWeights(flag, declared) {
   }
   return declared?.length ? declared : [400];
 }
-function googleFontCssUrl(family, weights) {
+var DEFAULT_SUBSETS = ["latin"];
+function resolveFetchSubsets(flag, selfHosted) {
+  const asked = String(flag ?? "").split(",").map((subset) => subset.trim()).filter(Boolean);
+  const named = flag ? [...new Set(asked)] : selfHosted;
+  return named.length > 0 ? named : [...DEFAULT_SUBSETS];
+}
+function resolveFetchStyles(italic, selfHosted) {
+  return italic || selfHosted.includes("italic") ? ["normal", "italic"] : ["normal"];
+}
+function googleFontCssUrl(family, weights, styles = ["normal"]) {
   const name = family.trim().split(/\s+/).map(encodeURIComponent).join("+");
-  const axis = [...new Set(weights)].sort((a, b) => a - b).join(";");
-  const spec = axis ? `${name}:wght@${axis}` : name;
+  const sorted = [...new Set(weights)].sort((a, b) => a - b);
+  if (sorted.length === 0) return `${GOOGLE_CSS2}?family=${name}&display=swap`;
+  const wanted = FONT_STYLES.filter((style) => styles.includes(style));
+  const spec = wanted.length > 1 ? `${name}:ital,wght@${wanted.flatMap((style) => sorted.map((w) => `${ITAL_AXIS[style]},${w}`)).join(";")}` : `${name}:wght@${sorted.join(";")}`;
   return `${GOOGLE_CSS2}?family=${spec}&display=swap`;
 }
 var STANDARD_WEIGHTS = [100, 200, 300, 400, 500, 600, 700, 800, 900];
 async function probeServedWeights(family, fetchCss) {
-  const probes = await Promise.all(
-    STANDARD_WEIGHTS.map(async (weight) => await fetchCss(googleFontCssUrl(family, [weight])) ? weight : null)
-  );
-  return probes.filter((w) => w !== null);
+  const css = await fetchCss(googleFontCssUrl(family, STANDARD_WEIGHTS));
+  if (css === null) return [];
+  return [...new Set(parseGoogleFontFaces(css).map((face) => face.weight))].sort((a, b) => a - b);
 }
 async function checkFontRequests(requests, fetchCss) {
   const results = [];
@@ -21546,6 +21561,34 @@ function selfHostedWeights(css, family) {
   }
   return [...weights].sort((a, b) => a - b);
 }
+function fontFileSubset(href) {
+  const file = posix.basename((href.split("?")[0] ?? "").split("#")[0] ?? "");
+  return /^[A-Za-z0-9]+-[1-9]00(?:italic)?-([\w-]+)\.woff2$/.exec(file)?.[1] ?? null;
+}
+function selfHostedSubsets(css, family) {
+  const target = normalizeFamily(family);
+  const subsets = /* @__PURE__ */ new Set();
+  for (const rule of stripCssComments(css).matchAll(/@font-face\s*\{([^}]*)\}/gi)) {
+    const body = rule[1] ?? "";
+    const declared = body.match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (!declared || normalizeFamily(declared) !== target) continue;
+    for (const url of body.matchAll(/url\(\s*['"]?([^'")]+)['"]?\s*\)/gi)) {
+      const subset = fontFileSubset(url[1] ?? "");
+      if (subset) subsets.add(subset);
+    }
+  }
+  return [...subsets].sort();
+}
+function selfHostedStyles(css, family) {
+  const target = normalizeFamily(family);
+  const styles = /* @__PURE__ */ new Set();
+  for (const rule of stripCssComments(css).matchAll(/@font-face\s*\{([^}]*)\}/gi)) {
+    const body = rule[1] ?? "";
+    const declared = body.match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (declared && normalizeFamily(declared) === target) styles.add(faceStyle(body));
+  }
+  return [...styles].sort();
+}
 function fontsourceFamilies(css) {
   const out = /* @__PURE__ */ new Set();
   for (const imported of stripCssComments(css).matchAll(/@fontsource(-variable)?\/([\w-]+)/gi)) {
@@ -21566,21 +21609,32 @@ function unresolvedBrandFamilies(css) {
   for (const request of googleFontRequests(stripCssComments(css))) loaded.add(normalizeFamily(request.family));
   return declared.filter((family) => !loaded.has(family)).map((family) => asAuthored(css, family));
 }
-function stripFontFaceBlocks(source, family) {
+function stripFontFaceBlocks(source, family, styles) {
   const target = normalizeFamily(family);
   const ranges = [];
-  for (const rule of stripCssComments(source).matchAll(/@font-face\s*\{[^}]*\}/gi)) {
-    const declared = rule[0].match(/font-family\s*:\s*([^;]+)/i)?.[1];
-    if (declared && normalizeFamily(declared) === target && rule.index !== void 0) {
-      ranges.push([rule.index, rule.index + rule[0].length]);
-    }
+  for (const rule of stripCssComments(source).matchAll(/@font-face\s*\{([^}]*)\}/gi)) {
+    const body = rule[1] ?? "";
+    const declared = body.match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (!declared || normalizeFamily(declared) !== target || rule.index === void 0) continue;
+    if (styles && !styles.has(faceStyle(body))) continue;
+    ranges.push([rule.index, rule.index + rule[0].length]);
   }
   let out = source;
   for (const [start, end] of ranges.reverse()) out = `${out.slice(0, start)}${out.slice(end)}`;
   return out.replace(/\n{3,}/g, "\n\n");
 }
+function faceStyle(body) {
+  return body.match(/font-style\s*:\s*([\w-]+)/i)?.[1]?.trim().toLowerCase() ?? "normal";
+}
+function declaredStyles(block) {
+  const styles = /* @__PURE__ */ new Set();
+  for (const rule of stripCssComments(block).matchAll(/@font-face\s*\{([^}]*)\}/gi))
+    styles.add(faceStyle(rule[1] ?? ""));
+  return styles;
+}
 function upsertFontFaceCss(css, family, block) {
-  const out = stripFontFaceBlocks(css, family);
+  const styles = declaredStyles(block);
+  const out = stripFontFaceBlocks(css, family, styles.size > 0 ? styles : void 0);
   const themeAt = stripCssComments(out).search(/@theme\b/);
   if (themeAt < 0) return `${out.trimEnd()}
 
@@ -21600,7 +21654,7 @@ ${tail}`;
 // src/commands/brand/fonts.ts
 var GLOBAL_CSS = path2.join("src", "styles", "global.css");
 var FONTS_DIR = path2.join("src", "brand", "fonts");
-var DEFAULT_SUBSETS = "latin";
+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",
@@ -21624,7 +21678,12 @@ registerSchema({
     },
     subsets: {
       type: "string",
-      description: `Comma-separated unicode subsets (default: ${DEFAULT_SUBSETS})`,
+      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
     }
   }
@@ -21669,15 +21728,34 @@ var WIRING_HINT = {
 };
 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
+  provider,
+  wantedStyles,
+  availableStyles
 }) {
   return [
     WIRING_HINT[wiring](family),
+    ...italicHints(family, wantedStyles, availableStyles, downloadedStyles, provider),
     `Record the exact weights (${downloadedWeights.join(", ")}) in src/brand/BRAND.md \u2014 a weight listed there but not downloaded renders as a synthesized fallback.`,
     ...incomplete.length > 0 ? [
       // The remedy is provider-specific: only a Google family has an @import
@@ -21838,7 +21916,14 @@ var fontsFetchCommand = defineCommand93({
       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: ${DEFAULT_SUBSETS})` }
+    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();
@@ -21850,10 +21935,9 @@ var fontsFetchCommand = defineCommand93({
     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(
-      String(args.subsets ?? DEFAULT_SUBSETS).split(",").map((s) => s.trim()).filter(Boolean)
-    );
-    const resolved = await resolveBrandFaces(family, weights, [...wanted], PROVIDER_DEPS);
+    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 = path2.resolve(process.cwd(), FONTS_DIR);
@@ -21877,6 +21961,7 @@ var fontsFetchCommand = defineCommand93({
     }
     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({
@@ -21885,11 +21970,21 @@ var fontsFetchCommand = defineCommand93({
         family,
         provider: resolved.provider,
         weights: downloadedWeights,
+        styles: downloadedStyles,
         files: written,
         fontFace,
         stylesheet: wiring
       },
-      hints: fetchHints({ family, downloadedWeights, incomplete, wiring, provider: resolved.provider })
+      hints: fetchHints({
+        family,
+        downloadedWeights,
+        downloadedStyles,
+        incomplete,
+        wiring,
+        provider: resolved.provider,
+        wantedStyles: styles,
+        availableStyles: resolved.availableStyles
+      })
     });
   }
 });