@json-to-office/jto 0.8.3 → 0.9.0

package/dist/cli.js

@@ -1180,6 +1180,150 @@ var init_logger = __esm({
 });
 
 // src/server/services/generator.ts
+import {
+  collectFontNamesFromDocx,
+  collectFontNamesFromPptx,
+  POPULAR_GOOGLE_FONTS,
+  getUpstreamOverride,
+  isSafeFont as isSafeFont2
+} from "@json-to-office/shared";
+function collectReferencedNames(config2, customThemes, adapterName) {
+  const collect = adapterName === "docx" ? collectFontNamesFromDocx : collectFontNamesFromPptx;
+  const names = /* @__PURE__ */ new Set();
+  for (const n of collect(config2)) names.add(n);
+  for (const theme of Object.values(customThemes ?? {})) {
+    for (const n of collect(theme)) names.add(n);
+  }
+  return names;
+}
+function collectReferencedWeights(config2, customThemes) {
+  const weights = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (node == null) return;
+    if (Array.isArray(node)) {
+      for (const item of node) visit(item);
+      return;
+    }
+    if (typeof node === "object") {
+      for (const [k, v] of Object.entries(node)) {
+        if (k === "fontWeight" && typeof v === "number" && v >= 100 && v <= 900) {
+          weights.add(v);
+        } else {
+          visit(v);
+        }
+      }
+    }
+  };
+  visit(config2);
+  for (const theme of Object.values(customThemes ?? {})) visit(theme);
+  return weights;
+}
+function collectReferencedItalic(config2, customThemes) {
+  let found = false;
+  const visit = (node) => {
+    if (found || node == null) return;
+    if (Array.isArray(node)) {
+      for (const item of node) visit(item);
+      return;
+    }
+    if (typeof node === "object") {
+      for (const [k, v] of Object.entries(node)) {
+        if (k === "italic" && v === true) {
+          found = true;
+          return;
+        }
+        visit(v);
+      }
+    }
+  };
+  visit(config2);
+  if (!found) {
+    for (const theme of Object.values(customThemes ?? {})) {
+      visit(theme);
+      if (found) break;
+    }
+  }
+  return found;
+}
+function autoGoogleFontEntries(names, skipFamilies, referencedWeights, referencedItalic, warnings) {
+  const googleByLower = new Map(
+    POPULAR_GOOGLE_FONTS.map((f) => [f.family.toLowerCase(), f])
+  );
+  const entries = [];
+  for (const name of names) {
+    if (isSafeFont2(name)) continue;
+    if (skipFamilies.has(name.toLowerCase())) continue;
+    const match = googleByLower.get(name.toLowerCase());
+    if (!match) continue;
+    const wanted = (() => {
+      if (!referencedWeights || referencedWeights.size === 0) {
+        const filtered2 = match.weights.filter((w) => w === 400 || w === 700);
+        if (filtered2.length > 0) return filtered2;
+        return match.weights.length > 0 ? [Math.min(...match.weights)] : [400];
+      }
+      const want = /* @__PURE__ */ new Set([400, ...referencedWeights]);
+      const filtered = match.weights.filter((w) => want.has(w));
+      return filtered.length > 0 ? filtered : [400];
+    })();
+    const override = getUpstreamOverride(match.family);
+    if (override) {
+      const overrideWantedSet = (() => {
+        if (!referencedWeights || referencedWeights.size === 0) {
+          return /* @__PURE__ */ new Set([400, 700]);
+        }
+        return /* @__PURE__ */ new Set([400, ...referencedWeights]);
+      })();
+      const keepItalic = referencedItalic !== false;
+      const variants = override.variants.filter(
+        (v) => overrideWantedSet.has(v.weight) && (keepItalic || !v.italic)
+      );
+      let selected = variants;
+      if (selected.length === 0) {
+        const missing = [...overrideWantedSet].filter((w) => !override.variants.some((v) => v.weight === w)).sort((a, b) => a - b);
+        warnings?.push(
+          `FONT_WEIGHT_NOT_IN_OVERRIDE: family "${match.family}" \u2014 referenced weight(s) ${missing.join(", ")} not in upstream override (has ${override.variants.map((v) => v.weight).filter((w, i, a) => a.indexOf(w) === i).sort((a, b) => a - b).join(", ")}). Fetching all override variants as a fallback.`
+        );
+        selected = override.variants;
+      }
+      entries.push({
+        id: match.family,
+        family: match.family,
+        sources: selected.map(
+          (v) => v.kind === "variable" ? {
+            kind: "variable",
+            url: v.url,
+            weight: v.weight,
+            italic: v.italic ?? false,
+            ...v.axes ? { axes: v.axes } : {}
+          } : {
+            kind: "url",
+            url: v.url,
+            weight: v.weight,
+            italic: v.italic ?? false
+          }
+        )
+      });
+      continue;
+    }
+    entries.push({
+      id: match.family,
+      family: match.family,
+      sources: [
+        {
+          kind: "google",
+          family: match.family,
+          weights: wanted,
+          // Only request italics when the catalog advertises them. Requesting
+          // italics for a family without italic variants (e.g. Inter) makes
+          // Google return 404s that surface as `FONT_WEIGHT_UNAVAILABLE`
+          // warnings and confuse diagnostics.
+          italics: match.hasItalic
+        }
+      ]
+    });
+  }
+  return entries;
+}
 var GeneratorService;
 var init_generator = __esm({
   "src/server/services/generator.ts"() {
@@ -1201,10 +1345,55 @@ var init_generator = __esm({
       async generate(request) {
         const { jsonDefinition, customThemes, options } = request;
         const config2 = typeof jsonDefinition === "string" ? JSON.parse(jsonDefinition) : jsonDefinition;
-        const bypassCache = options?.bypassCache === true;
+        const referencedNames = collectReferencedNames(
+          config2,
+          customThemes,
+          this.adapter.name
+        );
+        const referencedWeights = collectReferencedWeights(config2, customThemes);
+        const referencedItalic = collectReferencedItalic(config2, customThemes);
+        const callerFonts = options?.fonts;
+        const callerExtraEntriesRaw = callerFonts?.extraEntries;
+        const callerExtraEntries = Array.isArray(
+          callerExtraEntriesRaw
+        ) ? callerExtraEntriesRaw : [];
+        const callerStrict = typeof callerFonts?.strict === "boolean" ? callerFonts.strict : void 0;
+        const rawMode = callerFonts?.mode;
+        const fontMode = rawMode === "substitute" || rawMode === "custom" ? rawMode : void 0;
+        const rawSub = callerFonts?.substitution;
+        const fontSubstitution = rawSub && typeof rawSub === "object" && !Array.isArray(rawSub) ? rawSub : void 0;
+        const callerFamilies = new Set(
+          callerExtraEntries.map((e) => e.family.toLowerCase())
+        );
+        const overrideWarnings = [];
+        const autoEntries = fontMode === "substitute" ? [] : autoGoogleFontEntries(
+          referencedNames,
+          callerFamilies,
+          referencedWeights,
+          referencedItalic,
+          overrideWarnings
+        );
+        const extraEntries = [...callerExtraEntries, ...autoEntries];
+        if (callerExtraEntries.length > 0) {
+          const googleFamiliesLower = new Set(
+            POPULAR_GOOGLE_FONTS.map((f) => f.family.toLowerCase())
+          );
+          for (const e of callerExtraEntries) {
+            const lower = e.family.toLowerCase();
+            if (googleFamiliesLower.has(lower) && referencedNames.has(e.family)) {
+              overrideWarnings.push(
+                `[FONT_OVERRIDE_LOCAL] ${e.family}: caller-supplied source used; Google Fonts auto-fetch skipped for this family.`
+              );
+            }
+          }
+        }
+        const bypassCache = options?.bypassCache === true || extraEntries.length > 0;
         const cacheKeyData = {
           config: config2,
-          customThemes: customThemes && Object.keys(customThemes).length > 0 ? customThemes : null
+          customThemes: customThemes && Object.keys(customThemes).length > 0 ? customThemes : null,
+          fontMode: fontMode ?? null,
+          fontSubstitution: fontSubstitution ?? null,
+          fontStrict: callerStrict ?? null
         };
         const cacheKey = this.cacheService.generateCacheKey(cacheKeyData);
         const hasDynamicContent = this.cacheService.hasDynamicContent(config2);
@@ -1226,24 +1415,68 @@ var init_generator = __esm({
         });
         const registry = PluginRegistry.getInstance();
         let buffer;
+        const resolvedFonts = [];
+        const needsFontOpts = extraEntries.length > 0 || fontMode !== void 0 || fontSubstitution !== void 0 || callerStrict !== void 0;
+        const fontOpts = needsFontOpts ? {
+          ...extraEntries.length > 0 && { extraEntries },
+          ...fontMode && { mode: fontMode },
+          ...fontSubstitution && { substitution: fontSubstitution },
+          ...callerStrict !== void 0 && { strict: callerStrict },
+          onResolved: (r) => {
+            resolvedFonts.push(...r);
+          }
+        } : void 0;
         if (registry.hasPlugins()) {
           const plugins = registry.getPlugins();
           const generator = await this.adapter.createGenerator(plugins, {
-            customThemes
+            customThemes,
+            fonts: fontOpts
           });
           buffer = await generator.generateBuffer(config2);
         } else {
-          buffer = await this.adapter.generateBuffer(config2, { customThemes });
+          buffer = await this.adapter.generateBuffer(config2, {
+            customThemes,
+            fonts: fontOpts
+          });
         }
         this.cacheService.set(cacheKey, buffer, config2, {
           bypassCache: bypassCache || hasDynamicContent
         });
+        const CANONICAL_WEIGHTS = /* @__PURE__ */ new Set([
+          100,
+          200,
+          300,
+          400,
+          500,
+          600,
+          700,
+          800,
+          900
+        ]);
+        const nonCanonical = [...referencedWeights].filter(
+          (w) => !CANONICAL_WEIGHTS.has(w)
+        );
+        const extraWarnings = overrideWarnings.map((message) => ({
+          component: "fontRegistry",
+          message,
+          severity: "info",
+          context: { code: "FONT_OVERRIDE_LOCAL" }
+        }));
+        for (const w of nonCanonical) {
+          extraWarnings.push({
+            component: "fontRegistry",
+            message: `[FONT_NONCANONICAL_WEIGHT] fontWeight ${w} is not one of 100/200/.../900; render path rounds to Regular or Bold via bold-only fallback.`,
+            severity: "info",
+            context: { code: "FONT_NONCANONICAL_WEIGHT" }
+          });
+        }
         return {
           filename: `${config2.metadata?.title || this.adapter.label}${this.adapter.extension}`,
           fileId: Date.now().toString(),
           buffer,
           cached: false,
-          warnings: null
+          warnings: extraWarnings.length > 0 ? extraWarnings : null,
+          resolvedFonts
         };
       }
       async validate(jsonDefinition) {
@@ -1368,20 +1601,414 @@ var init_cache = __esm({
   }
 });
 
+// src/server/services/font-staging/noop-stager.ts
+var NoopFontStager;
+var init_noop_stager = __esm({
+  "src/server/services/font-staging/noop-stager.ts"() {
+    "use strict";
+    init_esm_shims();
+    NoopFontStager = class {
+      async stage() {
+        return {
+          envOverrides: {},
+          cleanup: async () => {
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/server/services/font-staging/types.ts
+function nextStagingId() {
+  counter += 1;
+  return `${process.pid}-${counter}`;
+}
+function safeFilenamePart(s) {
+  return s.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 48);
+}
+var counter;
+var init_types = __esm({
+  "src/server/services/font-staging/types.ts"() {
+    "use strict";
+    init_esm_shims();
+    counter = 0;
+  }
+});
+
+// src/server/services/font-staging/fontconfig-stager.ts
+import { promises as fs10 } from "fs";
+import path13 from "path";
+import {
+  synthesizeFamilyName,
+  rewriteFontFamilyName
+} from "@json-to-office/shared";
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+var SYSTEM_FONTS_CONF_CANDIDATES, FontconfigStager;
+var init_fontconfig_stager = __esm({
+  "src/server/services/font-staging/fontconfig-stager.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_types();
+    SYSTEM_FONTS_CONF_CANDIDATES = [
+      "/etc/fonts/fonts.conf",
+      "/opt/homebrew/etc/fonts/fonts.conf",
+      "/usr/local/etc/fonts/fonts.conf"
+    ];
+    FontconfigStager = class {
+      async stage(fonts, tempDir) {
+        const id = nextStagingId();
+        const fontsDir = path13.join(tempDir, "fonts");
+        await fs10.mkdir(fontsDir, { recursive: true });
+        let serial = 0;
+        for (const r of fonts) {
+          if (r.sources.length === 0) continue;
+          for (const s of r.sources) {
+            serial += 1;
+            const suffix = s.italic ? "i" : "r";
+            const synth = synthesizeFamilyName(r.family, s.weight, s.italic);
+            const data = synth.family === r.family ? s.data : rewriteFontFamilyName(s.data, synth.family);
+            const name = `${safeFilenamePart(synth.family)}-${s.weight}${suffix}-${id}-${serial}.ttf`;
+            await fs10.writeFile(path13.join(fontsDir, name), data);
+          }
+        }
+        await fs10.chmod(fontsDir, 365).catch(() => {
+        });
+        const includeLines = await this.pickSystemIncludes();
+        const cacheDir = path13.join(tempDir, "fc-cache");
+        await fs10.mkdir(cacheDir, { recursive: true });
+        const configPath = path13.join(tempDir, "fontconfig.xml");
+        const configXml = [
+          '<?xml version="1.0"?>',
+          '<!DOCTYPE fontconfig SYSTEM "fonts.dtd">',
+          "<fontconfig>",
+          `  <dir>${escapeXml(fontsDir)}</dir>`,
+          `  <cachedir>${escapeXml(cacheDir)}</cachedir>`,
+          ...includeLines,
+          "</fontconfig>",
+          ""
+        ].join("\n");
+        await fs10.writeFile(configPath, configXml, "utf8");
+        return {
+          envOverrides: {
+            FONTCONFIG_FILE: configPath,
+            XDG_CACHE_HOME: cacheDir
+          },
+          cleanup: async () => {
+          }
+        };
+      }
+      async pickSystemIncludes() {
+        for (const candidate of SYSTEM_FONTS_CONF_CANDIDATES) {
+          try {
+            await fs10.access(candidate);
+            return [
+              `  <include ignore_missing="yes">${escapeXml(candidate)}</include>`
+            ];
+          } catch {
+          }
+        }
+        return [`  <include ignore_missing="yes">/etc/fonts/fonts.conf</include>`];
+      }
+    };
+  }
+});
+
+// src/server/services/font-staging/windows-stager.ts
+import { promises as fs11 } from "fs";
+import path14 from "path";
+import {
+  synthesizeFamilyName as synthesizeFamilyName2,
+  rewriteFontFamilyName as rewriteFontFamilyName2
+} from "@json-to-office/shared";
+async function getGdiBindings() {
+  if (cachedBindings) return cachedBindings;
+  const koffi = await import("koffi");
+  const mod = koffi.default ?? koffi;
+  const gdi32 = mod.load("gdi32.dll");
+  cachedBindings = {
+    addFont: gdi32.func("int __stdcall AddFontResourceW(str16)"),
+    removeFont: gdi32.func("bool __stdcall RemoveFontResourceW(str16)")
+  };
+  return cachedBindings;
+}
+var cachedBindings, WindowsFontStager;
+var init_windows_stager = __esm({
+  "src/server/services/font-staging/windows-stager.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_types();
+    cachedBindings = null;
+    WindowsFontStager = class {
+      async stage(fonts, tempDir) {
+        const id = nextStagingId();
+        const fontsDir = path14.join(tempDir, "fonts");
+        await fs11.mkdir(fontsDir, { recursive: true });
+        const stagedPaths = [];
+        let serial = 0;
+        for (const r of fonts) {
+          if (r.sources.length === 0) continue;
+          for (const s of r.sources) {
+            serial += 1;
+            const suffix = s.italic ? "i" : "r";
+            const synth = synthesizeFamilyName2(r.family, s.weight, s.italic);
+            const data = synth.family === r.family ? s.data : rewriteFontFamilyName2(s.data, synth.family);
+            const name = `${safeFilenamePart(synth.family)}-${s.weight}${suffix}-${id}-${serial}.ttf`;
+            const fullPath = path14.join(fontsDir, name);
+            await fs11.writeFile(fullPath, data);
+            stagedPaths.push(fullPath);
+          }
+        }
+        if (stagedPaths.length === 0) {
+          return { envOverrides: {}, cleanup: async () => {
+          } };
+        }
+        const { addFont, removeFont } = await getGdiBindings();
+        const registered = [];
+        for (const p of stagedPaths) {
+          const added = addFont(p);
+          if (added > 0) registered.push(p);
+        }
+        let cleaned = false;
+        return {
+          envOverrides: {
+            // Force GDI backend so the freshly-registered fonts are visible.
+            // Skia on Windows uses DirectWrite which does not reliably see
+            // fonts added via AddFontResourceW.
+            SAL_DISABLE_SKIA: "1"
+          },
+          cleanup: async () => {
+            if (cleaned) return;
+            cleaned = true;
+            for (const p of registered) {
+              try {
+                removeFont(p);
+              } catch {
+              }
+            }
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/server/services/font-staging/macos-stager.ts
+import { promises as fs12 } from "fs";
+import path15 from "path";
+import {
+  synthesizeFamilyName as synthesizeFamilyName3,
+  rewriteFontFamilyName as rewriteFontFamilyName3
+} from "@json-to-office/shared";
+var PYTHON_MACRO, REGISTRY_MOD_XCU, MacOSCoreTextStager;
+var init_macos_stager = __esm({
+  "src/server/services/font-staging/macos-stager.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_types();
+    PYTHON_MACRO = `# Auto-generated by @json-to-office/jto. Runs inside soffice on OnStartApp
+# to make staged fonts visible to LibreOffice's font enumeration. macOS 26
+# blocks Session/Persistent CT registration for unsigned callers, but
+# Process scope still works from inside the target process \u2014 which is
+# exactly where this macro runs.
+import os
+import sys
+import ctypes
+import ctypes.util
+
+
+def _log(msg):
+    # soffice swallows Python stdout in headless mode; stderr surfaces to
+    # the parent's pipe. The stager doesn't read this today but the
+    # converter logs stderr on failure, which is how we'll debug.
+    sys.stderr.write("[jto-font-register] " + msg + "\\n")
+
+
+def register(*_args):
+    paths_env = os.environ.get("JTO_FONT_PATHS", "")
+    if not paths_env:
+        return
+    try:
+        cf = ctypes.CDLL(ctypes.util.find_library("CoreFoundation"))
+        ct = ctypes.CDLL(ctypes.util.find_library("CoreText"))
+    except Exception as e:
+        _log("failed to load CoreFoundation/CoreText: " + repr(e))
+        return
+    cf.CFURLCreateFromFileSystemRepresentation.argtypes = [
+        ctypes.c_void_p, ctypes.c_char_p, ctypes.c_long, ctypes.c_bool,
+    ]
+    cf.CFURLCreateFromFileSystemRepresentation.restype = ctypes.c_void_p
+    cf.CFRelease.argtypes = [ctypes.c_void_p]
+    ct.CTFontManagerRegisterFontsForURL.argtypes = [
+        ctypes.c_void_p, ctypes.c_uint32, ctypes.c_void_p,
+    ]
+    ct.CTFontManagerRegisterFontsForURL.restype = ctypes.c_bool
+
+    kCTFontManagerScopeProcess = 1
+    registered = 0
+    for p in paths_env.split(os.pathsep):
+        if not p:
+            continue
+        try:
+            b = p.encode("utf-8")
+            url = cf.CFURLCreateFromFileSystemRepresentation(
+                None, b, len(b), False
+            )
+            if not url:
+                _log("CFURL failed for " + p)
+                continue
+            ok = ct.CTFontManagerRegisterFontsForURL(
+                url, kCTFontManagerScopeProcess, None
+            )
+            cf.CFRelease(url)
+            if ok:
+                registered += 1
+            else:
+                _log("CT register returned false for " + p)
+        except Exception as e:
+            _log("exception registering " + p + ": " + repr(e))
+    _log("registered " + str(registered) + " font(s) at Process scope")
+
+
+# Expose under "register" (event-binding URL) and module-level run so
+# command-line vnd.sun.star.script invocation works either way.
+g_exportedScripts = (register,)
+`;
+    REGISTRY_MOD_XCU = `<?xml version="1.0" encoding="UTF-8"?>
+<oor:items xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <item oor:path="/org.openoffice.Office.Events/ApplicationEvents/Bindings">
+    <node oor:name="OnStartApp" oor:op="replace">
+      <prop oor:name="BindingURL" oor:type="xs:string">
+        <value>vnd.sun.star.script:JtoFontRegister.py$register?language=Python&amp;location=user</value>
+      </prop>
+    </node>
+  </item>
+  <item oor:path="/org.openoffice.Office.Common/Security/Scripting">
+    <prop oor:name="MacroSecurityLevel" oor:op="fuse">
+      <value>0</value>
+    </prop>
+  </item>
+</oor:items>
+`;
+    MacOSCoreTextStager = class {
+      async stage(fonts, tempDir) {
+        const embeddable = fonts.filter((r) => r.sources.length > 0);
+        if (embeddable.length === 0) {
+          return { envOverrides: {}, cleanup: async () => {
+          } };
+        }
+        const fontsDir = path15.join(tempDir, "fonts");
+        await fs12.mkdir(fontsDir, { recursive: true });
+        const id = nextStagingId();
+        const fontPaths = [];
+        const staged = [];
+        let serial = 0;
+        for (const r of embeddable) {
+          for (const s of r.sources) {
+            serial += 1;
+            const suffix = s.italic ? "i" : "r";
+            const synth = synthesizeFamilyName3(r.family, s.weight, s.italic);
+            const data = synth.family === r.family ? s.data : rewriteFontFamilyName3(s.data, synth.family);
+            const name = `${safeFilenamePart(synth.family)}-${s.weight}${suffix}-${id}-${serial}.ttf`;
+            const full = path15.join(fontsDir, name);
+            await fs12.writeFile(full, data);
+            fontPaths.push(full);
+            staged.push({
+              family: synth.family,
+              weight: s.weight,
+              italic: s.italic,
+              path: full
+            });
+          }
+        }
+        if (process.env.JTO_DEBUG_FONTS === "1") {
+          console.log(
+            "[jto macos-stager] staged " + staged.length + " font(s) for CT Process-scope registration; JTO_FONT_PATHS has " + fontPaths.length + " entries\n" + staged.map(
+              (s) => `  ${s.family} (w=${s.weight}${s.italic ? " italic" : ""}) \u2192 ${path15.basename(s.path)}`
+            ).join("\n")
+          );
+        }
+        const profileUser = path15.join(tempDir, "user-profile", "user");
+        const scriptsDir = path15.join(profileUser, "Scripts", "python");
+        await fs12.mkdir(scriptsDir, { recursive: true });
+        await fs12.writeFile(
+          path15.join(scriptsDir, "JtoFontRegister.py"),
+          PYTHON_MACRO
+        );
+        await fs12.writeFile(
+          path15.join(profileUser, "registrymodifications.xcu"),
+          REGISTRY_MOD_XCU
+        );
+        return {
+          envOverrides: {
+            // Colon-separated list of staged TTF paths (`:` matches Python's
+            // `os.pathsep` on macOS). The macro reads this at OnStartApp.
+            JTO_FONT_PATHS: fontPaths.join(":"),
+            // Force LibreOffice's Core Graphics backend. Skia on macOS can
+            // skip Core Text's freshly-registered fonts in some builds.
+            SAL_DISABLE_SKIA: "1"
+          },
+          cleanup: async () => {
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/server/services/font-staging/index.ts
+function getFontStager(platform = process.platform) {
+  const hit = cached.get(platform);
+  if (hit) return hit;
+  let stager;
+  switch (platform) {
+    case "win32":
+      stager = new WindowsFontStager();
+      break;
+    case "darwin":
+      stager = new MacOSCoreTextStager();
+      break;
+    case "linux":
+    case "freebsd":
+    case "openbsd":
+      stager = new FontconfigStager();
+      break;
+    default:
+      stager = new NoopFontStager();
+  }
+  cached.set(platform, stager);
+  return stager;
+}
+var cached;
+var init_font_staging = __esm({
+  "src/server/services/font-staging/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_noop_stager();
+    init_fontconfig_stager();
+    init_windows_stager();
+    init_macos_stager();
+    cached = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/server/services/libreoffice-converter.ts
 import { execFile } from "child_process";
-import { promises as fs10 } from "fs";
+import { promises as fs13 } from "fs";
 import os from "os";
-import path13 from "path";
-function executeFile(binary, args, timeoutMs) {
-  return new Promise((resolve16, reject) => {
+import path16 from "path";
+function executeFile(binary, args, timeoutMs, envOverrides) {
+  return new Promise((resolve18, reject) => {
     execFile(
       binary,
       args,
       {
         timeout: timeoutMs,
         maxBuffer: MAX_EXEC_BUFFER_BYTES,
-        windowsHide: true
+        windowsHide: true,
+        env: envOverrides ? { ...process.env, ...envOverrides } : process.env
       },
       (error, stdout, stderr) => {
         if (error) {
@@ -1391,7 +2018,7 @@ function executeFile(binary, args, timeoutMs) {
           reject(execError);
           return;
         }
-        resolve16({ stdout: stdout ?? "", stderr: stderr ?? "" });
+        resolve18({ stdout: stdout ?? "", stderr: stderr ?? "" });
       }
     );
   });
@@ -1403,7 +2030,7 @@ function toErrorText(value) {
   return String(value);
 }
 function sanitizeBaseName(originalName) {
-  const parsed = path13.parse(originalName || "document");
+  const parsed = path16.parse(originalName || "document");
   return (parsed.name || "document").replace(/[^a-zA-Z0-9._-]/g, "_") || "document";
 }
 var DEFAULT_CONVERSION_TIMEOUT_MS, BINARY_PROBE_TIMEOUT_MS, MAX_EXEC_BUFFER_BYTES, LibreOfficeError, LibreOfficeBinaryNotFoundError, LibreOfficeTimeoutError, LibreOfficeConversionError, LibreOfficeOutputNotFoundError, LibreOfficeConverterService;
@@ -1412,6 +2039,7 @@ var init_libreoffice_converter = __esm({
     "use strict";
     init_esm_shims();
     init_config();
+    init_font_staging();
     DEFAULT_CONVERSION_TIMEOUT_MS = 3e4;
     BINARY_PROBE_TIMEOUT_MS = 5e3;
     MAX_EXEC_BUFFER_BYTES = 20 * 1024 * 1024;
@@ -1471,24 +2099,35 @@ var init_libreoffice_converter = __esm({
         this.format = format;
         this.timeoutMs = timeoutMs || config.LIBREOFFICE_TIMEOUT_MS || DEFAULT_CONVERSION_TIMEOUT_MS;
       }
-      async convertToPdf(input, originalName = "document") {
+      async convertToPdf(input, originalName = "document", resolvedFonts) {
         if (!input || input.length === 0) {
           throw new LibreOfficeConversionError("Input file is empty");
         }
         const binaryPath = await this.resolveBinaryPath();
-        const tempDir = await fs10.mkdtemp(
-          path13.join(os.tmpdir(), "jto-libreoffice-")
+        const tempDir = await fs13.mkdtemp(
+          path16.join(os.tmpdir(), "jto-libreoffice-")
         );
         const outputBaseName = sanitizeBaseName(originalName);
         const ext = this.format === "pptx" ? ".pptx" : ".docx";
-        const inputPath = path13.join(tempDir, `${outputBaseName}${ext}`);
-        const pdfPath = path13.join(tempDir, `${outputBaseName}.pdf`);
+        const inputPath = path16.join(tempDir, `${outputBaseName}${ext}`);
+        const pdfPath = path16.join(tempDir, `${outputBaseName}.pdf`);
+        const stager = getFontStager();
+        const fontsToStage = (resolvedFonts ?? []).filter(
+          (r) => r.sources.length > 0
+        );
+        const stageHandle = fontsToStage.length > 0 ? await stager.stage(fontsToStage, tempDir) : null;
         try {
-          await fs10.writeFile(inputPath, input);
+          await fs13.writeFile(inputPath, input);
           const filterName = this.format === "pptx" ? "impress_pdf_Export" : "writer_pdf_Export";
-          await this.runConversion(binaryPath, inputPath, tempDir, filterName);
+          await this.runConversion(
+            binaryPath,
+            inputPath,
+            tempDir,
+            filterName,
+            stageHandle?.envOverrides
+          );
           try {
-            return await fs10.readFile(pdfPath);
+            return await fs13.readFile(pdfPath);
           } catch (error) {
             if (error.code === "ENOENT") {
               throw new LibreOfficeOutputNotFoundError(pdfPath);
@@ -1496,7 +2135,11 @@ var init_libreoffice_converter = __esm({
             throw error;
           }
         } finally {
-          await fs10.rm(tempDir, { recursive: true, force: true }).catch(() => {
+          if (stageHandle) {
+            await stageHandle.cleanup().catch(() => {
+            });
+          }
+          await fs13.rm(tempDir, { recursive: true, force: true }).catch(() => {
           });
         }
       }
@@ -1523,9 +2166,9 @@ var init_libreoffice_converter = __esm({
         throw new LibreOfficeBinaryNotFoundError(candidates);
       }
       async isBinaryAvailable(binaryPath) {
-        if (binaryPath.includes(path13.sep)) {
+        if (binaryPath.includes(path16.sep)) {
           try {
-            await fs10.access(binaryPath);
+            await fs13.access(binaryPath);
           } catch {
             return false;
           }
@@ -1538,8 +2181,8 @@ var init_libreoffice_converter = __esm({
           return code !== "ENOENT" && code !== "EACCES";
         }
       }
-      async runConversion(binaryPath, inputPath, outputDir, filterName) {
-        const userProfilePath = path13.join(outputDir, "user-profile").replace(/\\/g, "/");
+      async runConversion(binaryPath, inputPath, outputDir, filterName, envOverrides) {
+        const userProfilePath = path16.join(outputDir, "user-profile").replace(/\\/g, "/");
         const userInstallation = `file:///${userProfilePath.replace(/^\//, "")}`;
         const args = [
           "--headless",
@@ -1553,8 +2196,31 @@ var init_libreoffice_converter = __esm({
           outputDir,
           inputPath
         ];
+        if (process.env.JTO_DEBUG_FONTS === "1") {
+          console.log(
+            "[jto libreoffice-converter] spawning soffice with env overrides: " + JSON.stringify(
+              envOverrides ? Object.fromEntries(
+                Object.entries(envOverrides).map(([k, v]) => [
+                  k,
+                  k === "JTO_FONT_PATHS" ? `<${v.split(":").length} paths>` : v
+                ])
+              ) : {}
+            )
+          );
+        }
         try {
-          await executeFile(binaryPath, args, this.timeoutMs);
+          const result = await executeFile(
+            binaryPath,
+            args,
+            this.timeoutMs,
+            envOverrides
+          );
+          if (process.env.JTO_DEBUG_FONTS === "1") {
+            const stderr = result.stderr?.trim();
+            console.log(
+              "[jto libreoffice-converter] conversion ok; stderr len=" + (stderr?.length ?? 0) + (stderr ? "\n" + stderr : " (empty)")
+            );
+          }
         } catch (error) {
           const execError = error;
           if (execError.code === "ETIMEDOUT")
@@ -1670,11 +2336,27 @@ var init_health = __esm({
 
 // src/server/schemas/loose.ts
 import { Type as Type2 } from "@sinclair/typebox";
-var LooseDocumentGenerationRequestSchema, LooseDocumentValidationRequestSchema;
+var FontOptionsSchema, LooseDocumentGenerationRequestSchema, LooseDocumentValidationRequestSchema;
 var init_loose = __esm({
   "src/server/schemas/loose.ts"() {
     "use strict";
     init_esm_shims();
+    FontOptionsSchema = Type2.Object(
+      {
+        mode: Type2.Optional(
+          Type2.Union([Type2.Literal("substitute"), Type2.Literal("custom")])
+        ),
+        substitution: Type2.Optional(
+          Type2.Record(
+            Type2.String({ maxLength: 128 }),
+            Type2.String({ maxLength: 128 }),
+            { maxProperties: 256 }
+          )
+        ),
+        strict: Type2.Optional(Type2.Boolean())
+      },
+      { additionalProperties: false }
+    );
     LooseDocumentGenerationRequestSchema = Type2.Object(
       {
         jsonDefinition: Type2.Union([
@@ -1684,7 +2366,16 @@ var init_loose = __esm({
           // Allow any object
         ]),
         customThemes: Type2.Optional(Type2.Record(Type2.String(), Type2.Unknown())),
-        options: Type2.Optional(Type2.Object({}, { additionalProperties: true }))
+        options: Type2.Optional(
+          Type2.Object(
+            {
+              bypassCache: Type2.Optional(Type2.Boolean()),
+              returnUrl: Type2.Optional(Type2.Boolean()),
+              fonts: Type2.Optional(FontOptionsSchema)
+            },
+            { additionalProperties: true }
+          )
+        )
       },
       { additionalProperties: true }
     );
@@ -1812,6 +2503,7 @@ var init_rate_limit = __esm({
 // src/server/routes/format.ts
 import { Hono as Hono2 } from "hono";
 import { HTTPException as HTTPException3 } from "hono/http-exception";
+import { bodyLimit } from "hono/body-limit";
 function createFormatRouter(adapter) {
   const router = new Hono2();
   const contentTypeMw = async (c, next) => {
@@ -1838,10 +2530,22 @@ function createFormatRouter(adapter) {
       const requestId = c.get("requestId");
       try {
         const bypassCache = c.req.header("X-Bypass-Cache") === "true" || c.req.query("bypass-cache") === "true" || options?.bypassCache === true;
+        let sanitizedFonts;
+        const rawFonts = options?.fonts;
+        if (rawFonts && "strict" in rawFonts) {
+          sanitizedFonts = { ...rawFonts };
+          delete sanitizedFonts.strict;
+        } else if (rawFonts) {
+          sanitizedFonts = rawFonts;
+        }
         const result = await generatorService.generate({
           jsonDefinition,
           customThemes,
-          options: { ...options, bypassCache }
+          options: {
+            ...options,
+            ...sanitizedFonts !== void 0 && { fonts: sanitizedFonts },
+            bypassCache
+          }
         });
         const cacheService = getContainer().get("cacheService");
         const cacheStats = cacheService.getStats();
@@ -1961,6 +2665,68 @@ function createFormatRouter(adapter) {
       }
     }
   );
+  router.post(
+    "/preview/libreoffice-from-json",
+    bodyLimit({
+      // Doc JSON + custom themes. 2 MB covers large report fixtures; anything
+      // bigger is almost certainly an attempt to OOM the worker.
+      maxSize: 2 * 1024 * 1024,
+      onError: () => {
+        throw new HTTPException3(413, { message: "Request body too large" });
+      }
+    }),
+    rateLimiter({
+      limit: process.env.NODE_ENV === "production" ? 20 : 1e3,
+      window: 15 * 60 * 1e3,
+      keyGenerator: (c) => c.req.header("X-Real-IP") || c.req.header("X-Forwarded-For")?.split(",").pop()?.trim() || "anonymous"
+    }),
+    contentTypeMw,
+    tbValidator(LooseDocumentGenerationRequestSchema),
+    async (c) => {
+      const requestId = c.get("requestId");
+      const generatorService = getContainer().get("generatorService");
+      const libreOfficeService = getContainer().get(
+        "libreOfficeConverterService"
+      );
+      const { jsonDefinition, customThemes } = getValidated(c, "json");
+      try {
+        const generated = await generatorService.generate({
+          jsonDefinition,
+          customThemes,
+          options: { bypassCache: true }
+        });
+        const pdfBuffer = await libreOfficeService.convertToPdf(
+          generated.buffer,
+          generated.filename,
+          generated.resolvedFonts
+        );
+        const pdfName = generated.filename.replace(/\.[^.]+$/i, "") + ".pdf";
+        c.header("Content-Type", "application/pdf");
+        c.header("Content-Disposition", `inline; filename="${pdfName}"`);
+        c.header("Content-Length", String(pdfBuffer.length));
+        return c.body(pdfBuffer);
+      } catch (error) {
+        logger.error("LibreOffice (JSON) preview failed", {
+          error,
+          requestId
+        });
+        if (error instanceof HTTPException3) throw error;
+        if (error instanceof LibreOfficeBinaryNotFoundError) {
+          throw new HTTPException3(503, {
+            message: "LibreOffice is not available. Install LibreOffice or set LIBREOFFICE_PATH."
+          });
+        }
+        if (error instanceof LibreOfficeTimeoutError || error instanceof LibreOfficeConversionError || error instanceof LibreOfficeOutputNotFoundError) {
+          throw new HTTPException3(500, {
+            message: "LibreOffice preview conversion failed."
+          });
+        }
+        throw new HTTPException3(500, {
+          message: "Internal server error during preview conversion"
+        });
+      }
+    }
+  );
   router.post(
     "/standard-components",
     contentTypeMw,
@@ -2455,15 +3221,15 @@ var init_ai_schema = __esm({
 
 // src/server/services/prompt-loader.ts
 import { readFileSync as readFileSync5, existsSync as existsSync6 } from "fs";
-import { join as join7, dirname as dirname5 } from "path";
+import { join as join8, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolvePromptsDir() {
   const candidates = [
-    join7(__dirname2, "..", "prompts"),
+    join8(__dirname2, "..", "prompts"),
     // dev: src/server/prompts
-    join7(__dirname2, "prompts"),
+    join8(__dirname2, "prompts"),
     // bundled: dist/prompts
-    join7(__dirname2, "..", "src", "server", "prompts")
+    join8(__dirname2, "..", "src", "server", "prompts")
     // prod from dist/
   ];
   for (const dir of candidates) {
@@ -2473,7 +3239,7 @@ function resolvePromptsDir() {
 }
 function readPromptFile(name) {
   if (cache.has(name)) return cache.get(name);
-  const filePath = join7(PROMPTS_DIR, name);
+  const filePath = join8(PROMPTS_DIR, name);
   const content = readFileSync5(filePath, "utf-8");
   cache.set(name, content);
   return content;
@@ -2836,6 +3602,110 @@ var init_ai = __esm({
   }
 });
 
+// src/server/routes/fonts.ts
+import { createHash } from "crypto";
+import { Hono as Hono5 } from "hono";
+import { HTTPException as HTTPException4 } from "hono/http-exception";
+import { bodyLimit as bodyLimit2 } from "hono/body-limit";
+import {
+  SAFE_FONTS,
+  POPULAR_GOOGLE_FONTS as POPULAR_GOOGLE_FONTS2,
+  fetchGoogleFontSources
+} from "@json-to-office/shared";
+var fontsRouter, MATERIALIZE_FAMILY_MAX, MATERIALIZE_WEIGHTS_MAX, CATALOG_BODY, CATALOG_ETAG;
+var init_fonts = __esm({
+  "src/server/routes/fonts.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_rate_limit();
+    fontsRouter = new Hono5();
+    MATERIALIZE_FAMILY_MAX = 64;
+    MATERIALIZE_WEIGHTS_MAX = 9;
+    CATALOG_BODY = JSON.stringify({
+      safe: SAFE_FONTS,
+      google: POPULAR_GOOGLE_FONTS2
+    });
+    CATALOG_ETAG = `"${createHash("sha256").update(CATALOG_BODY).digest("base64").slice(0, 24)}"`;
+    fontsRouter.get("/catalog", (c) => {
+      const ifNoneMatch = c.req.header("If-None-Match");
+      if (ifNoneMatch && ifNoneMatch === CATALOG_ETAG) {
+        c.header("ETag", CATALOG_ETAG);
+        c.header("Cache-Control", "public, max-age=86400");
+        return c.body(null, 304);
+      }
+      c.header("Content-Type", "application/json");
+      c.header("ETag", CATALOG_ETAG);
+      c.header("Cache-Control", "public, max-age=86400");
+      return c.body(CATALOG_BODY, 200);
+    });
+    fontsRouter.post(
+      "/materialize",
+      bodyLimit2({
+        // Body is just {family, weights, italics} — 16 KB is generous.
+        maxSize: 16 * 1024,
+        onError: () => {
+          throw new HTTPException4(413, { message: "Request body too large" });
+        }
+      }),
+      rateLimiter({
+        limit: process.env.NODE_ENV === "production" ? 20 : 1e3,
+        window: 15 * 60 * 1e3,
+        keyGenerator: (c) => c.req.header("X-Real-IP") || c.req.header("X-Forwarded-For")?.split(",").pop()?.trim() || "anonymous"
+      }),
+      async (c) => {
+        let body;
+        try {
+          body = await c.req.json();
+        } catch {
+          return c.json({ error: "Invalid JSON body" }, 400);
+        }
+        const family = body.family?.trim();
+        if (!family) {
+          return c.json({ error: "Missing required field: family" }, 400);
+        }
+        if (family.length > MATERIALIZE_FAMILY_MAX) {
+          return c.json(
+            { error: `family exceeds ${MATERIALIZE_FAMILY_MAX} characters` },
+            400
+          );
+        }
+        const weights = Array.isArray(body.weights) && body.weights.length > 0 ? Array.from(
+          new Set(
+            body.weights.filter(
+              (w) => typeof w === "number" && w >= 100 && w <= 900
+            )
+          )
+        ).slice(0, MATERIALIZE_WEIGHTS_MAX) : [400, 700];
+        const italics = Boolean(body.italics);
+        try {
+          const { sources, warnings } = await fetchGoogleFontSources({
+            family,
+            weights,
+            italics
+          });
+          return c.json({
+            family,
+            sources: sources.map((s) => ({
+              weight: s.weight,
+              italic: s.italic,
+              format: s.format,
+              data: s.data.toString("base64")
+            })),
+            warnings
+          });
+        } catch (err) {
+          return c.json(
+            {
+              error: `Google Fonts materialize failed: ${err.message}`
+            },
+            502
+          );
+        }
+      }
+    );
+  }
+});
+
 // src/server/middleware/hono/request-id.ts
 import { randomUUID } from "crypto";
 var requestIdMiddleware;
@@ -2890,7 +3760,7 @@ var init_auth = __esm({
 });
 
 // src/server/middleware/hono/error-handler.ts
-import { HTTPException as HTTPException4 } from "hono/http-exception";
+import { HTTPException as HTTPException5 } from "hono/http-exception";
 var errorHandler;
 var init_error_handler = __esm({
   "src/server/middleware/hono/error-handler.ts"() {
@@ -2900,7 +3770,7 @@ var init_error_handler = __esm({
     init_config();
     errorHandler = (err, c) => {
       const requestId = c.get("requestId") || "unknown";
-      if (err instanceof HTTPException4) {
+      if (err instanceof HTTPException5) {
         return c.json(
           {
             success: false,
@@ -3068,14 +3938,14 @@ var init_request_logger = __esm({
 });
 
 // src/server/app.ts
-import { Hono as Hono5 } from "hono";
+import { Hono as Hono6 } from "hono";
 import { cors } from "hono/cors";
 import { secureHeaders } from "hono/secure-headers";
 import { logger as honoLogger } from "hono/logger";
 import { timing } from "hono/timing";
 function createAPIApp(adapter) {
   Container.initialize(adapter);
-  const honoApp = new Hono5();
+  const honoApp = new Hono6();
   honoApp.use("*", timing());
   honoApp.use("*", honoLogger());
   honoApp.use(
@@ -3103,6 +3973,7 @@ function createAPIApp(adapter) {
   const legacyPath = adapter.name === "docx" ? "/api/documents" : "/api/presentations";
   honoApp.route(legacyPath, formatRouter);
   honoApp.route("/api/discovery", discoveryRouter);
+  honoApp.route("/api/fonts", fontsRouter);
   if (process.env.AI_ENABLED !== "false") {
     honoApp.route("/api/ai", createAiRouter());
   }
@@ -3139,6 +4010,7 @@ var init_app = __esm({
     init_format();
     init_discovery();
     init_ai();
+    init_fonts();
     init_request_id();
     init_auth();
     init_error_handler();
@@ -3154,11 +4026,11 @@ var unified_server_exports = {};
 __export(unified_server_exports, {
   UnifiedServer: () => UnifiedServer
 });
-import { Hono as Hono6 } from "hono";
+import { Hono as Hono7 } from "hono";
 import { serve } from "@hono/node-server";
 import { logger as logger2 } from "hono/logger";
 import { compress } from "hono/compress";
-import { resolve as resolve15, dirname as dirname6 } from "path";
+import { resolve as resolve16, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __filename2, __dirname3, UnifiedServer;
 var init_unified_server = __esm({
@@ -3178,7 +4050,7 @@ var init_unified_server = __esm({
       constructor(adapter, config2) {
         this.adapter = adapter;
         this.config = config2;
-        this.app = new Hono6();
+        this.app = new Hono7();
       }
       async initialize() {
         await this.setupMiddleware();
@@ -3204,9 +4076,9 @@ var init_unified_server = __esm({
           return await apiApp.fetch(c.req.raw);
         });
         this.app.use("*", async (c, next) => {
-          const path14 = c.req.path;
-          if (path14.startsWith("/api")) {
-            if (/\.(ts|tsx|js|jsx|css|map)$/.test(path14)) {
+          const path17 = c.req.path;
+          if (path17.startsWith("/api")) {
+            if (/\.(ts|tsx|js|jsx|css|map)$/.test(path17)) {
               return next();
             }
             const response = await apiApp.fetch(c.req.raw);
@@ -3239,15 +4111,15 @@ var init_unified_server = __esm({
         let clientPath = null;
         if (process.env.JTO_CLIENT_PATH) {
           const envClientPath = process.env.JTO_CLIENT_PATH;
-          if (existsSync7(envClientPath) && existsSync7(resolve15(envClientPath, "index.html"))) {
+          if (existsSync7(envClientPath) && existsSync7(resolve16(envClientPath, "index.html"))) {
             clientPath = envClientPath;
             logger.debug("[Dev Server] Using client from JTO_CLIENT_PATH", {
               path: clientPath
             });
           }
         } else if (isBundled) {
-          const bundledClientPath = resolve15(__dirname3, "client");
-          if (existsSync7(bundledClientPath) && existsSync7(resolve15(bundledClientPath, "index.html"))) {
+          const bundledClientPath = resolve16(__dirname3, "client");
+          if (existsSync7(bundledClientPath) && existsSync7(resolve16(bundledClientPath, "index.html"))) {
             clientPath = bundledClientPath;
             logger.debug("[Dev Server] Using bundled client at", {
               path: clientPath
@@ -3255,8 +4127,8 @@ var init_unified_server = __esm({
           }
         } else {
           const possiblePaths = [
-            resolve15(__dirname3, "../client"),
-            resolve15(__dirname3, "../../dist/client")
+            resolve16(__dirname3, "../client"),
+            resolve16(__dirname3, "../../dist/client")
           ];
           for (const p of possiblePaths) {
             if (existsSync7(p)) {
@@ -3278,7 +4150,7 @@ var init_unified_server = __esm({
                   logger.warn("[Dev Server] Vite not available for dev mode");
                 }
                 break;
-              } else if (existsSync7(resolve15(p, "index.html"))) {
+              } else if (existsSync7(resolve16(p, "index.html"))) {
                 clientPath = p;
                 logger.debug("[Dev Server] Using pre-built client at", {
                   path: clientPath
@@ -3292,7 +4164,7 @@ var init_unified_server = __esm({
           return this.setupBuiltClient(clientPath);
         }
         if (!this.viteServer && !isBundled) {
-          const sourceClientPath = resolve15(__dirname3, "../client");
+          const sourceClientPath = resolve16(__dirname3, "../client");
           try {
             const { createServer: createViteServer } = await import("vite");
             this.viteServer = await createViteServer({
@@ -3309,17 +4181,17 @@ var init_unified_server = __esm({
         }
         if (this.viteServer) {
           this.app.use("*", async (c, next) => {
-            const path14 = c.req.path;
-            if ((path14.startsWith("/api") || path14 === "/health") && !/\.(ts|tsx|js|jsx|css|map)$/.test(path14)) {
+            const path17 = c.req.path;
+            if ((path17.startsWith("/api") || path17 === "/health") && !/\.(ts|tsx|js|jsx|css|map)$/.test(path17)) {
               return next();
             }
             const env = c.env;
             const req = env.incoming || env.req;
             const res = env.outgoing || env.res;
             if (req && res && this.viteServer) {
-              return new Promise((resolve16) => {
+              return new Promise((resolve18) => {
                 this.viteServer.middlewares.handle(req, res, () => {
-                  resolve16(next());
+                  resolve18(next());
                 });
               });
             }
@@ -3329,26 +4201,26 @@ var init_unified_server = __esm({
       }
       async setupBuiltClient(clientPath) {
         const { serveStatic } = await import("@hono/node-server/serve-static");
-        const fs11 = await import("fs");
-        const { extname: extname2 } = await import("path");
+        const fs14 = await import("fs");
+        const { extname: extname4 } = await import("path");
         const mime = await import("mime-types");
         const format = this.adapter.name.replace(/[^a-zA-Z0-9]/g, "");
         this.app.use(
           "/assets/*",
           serveStatic({
             root: clientPath,
-            rewriteRequestPath: (path14) => path14.replace(/^\/assets/, "/assets")
+            rewriteRequestPath: (path17) => path17.replace(/^\/assets/, "/assets")
           })
         );
         this.app.use("/*", async (c, next) => {
           const reqPath = c.req.path;
           if (reqPath.startsWith("/api") || reqPath === "/health") return next();
-          const ext = extname2(reqPath);
+          const ext = extname4(reqPath);
           if (ext) {
-            const filePath = resolve15(clientPath, reqPath.slice(1));
-            if (fs11.existsSync(filePath)) {
+            const filePath = resolve16(clientPath, reqPath.slice(1));
+            if (fs14.existsSync(filePath)) {
               const mimeType = mime.lookup(filePath) || "application/octet-stream";
-              const content = fs11.readFileSync(filePath);
+              const content = fs14.readFileSync(filePath);
               c.header("Content-Type", mimeType);
               return c.body(content);
             }
@@ -3359,9 +4231,9 @@ var init_unified_server = __esm({
           const reqPath = c.req.path;
           if (reqPath.startsWith("/api") || reqPath === "/health")
             return c.notFound();
-          const indexPath = resolve15(clientPath, "index.html");
-          if (fs11.existsSync(indexPath)) {
-            let html = fs11.readFileSync(indexPath, "utf-8");
+          const indexPath = resolve16(clientPath, "index.html");
+          if (fs14.existsSync(indexPath)) {
+            let html = fs14.readFileSync(indexPath, "utf-8");
             html = html.replace(
               "</head>",
               `<script>window.__JTO_FORMAT__ = '${format}';</script>
@@ -3373,12 +4245,12 @@ var init_unified_server = __esm({
         });
       }
       async setupProdClient() {
-        const clientPath = resolve15(__dirname3, "client");
+        const clientPath = resolve16(__dirname3, "client");
         return this.setupBuiltClient(clientPath);
       }
       async start() {
         await this.initialize();
-        return new Promise((resolve16) => {
+        return new Promise((resolve18) => {
           this.server = serve(
             {
               fetch: this.app.fetch,
@@ -3386,7 +4258,7 @@ var init_unified_server = __esm({
               hostname: this.config.server.host
             },
             () => {
-              resolve16();
+              resolve18();
             }
           );
         });
@@ -3394,8 +4266,8 @@ var init_unified_server = __esm({
       async stop() {
         if (this.viteServer) await this.viteServer.close();
         if (this.server) {
-          return new Promise((resolve16) => {
-            this.server?.close(() => resolve16());
+          return new Promise((resolve18) => {
+            this.server?.close(() => resolve18());
           });
         }
       }
@@ -3405,8 +4277,8 @@ var init_unified_server = __esm({
 
 // src/cli.ts
 init_esm_shims();
-import { Command as Command7 } from "commander";
-import chalk9 from "chalk";
+import { Command as Command8 } from "commander";
+import chalk10 from "chalk";
 
 // src/format-adapter.ts
 init_esm_shims();
@@ -3440,7 +4312,8 @@ var DocxFormatAdapter = class {
     const services = buildServicesFromEnv();
     return await core.generateBufferFromJson(docDefinition, {
       customThemes,
-      services
+      services,
+      fonts: options.fonts
     });
   }
   async createGenerator(plugins, options) {
@@ -3455,7 +4328,8 @@ var DocxFormatAdapter = class {
           const customThemes2 = await this.loadCustomThemes(options);
           return await core.generateBufferFromJson(docDefinition, {
             customThemes: customThemes2,
-            services
+            services,
+            fonts: options.fonts
           });
         },
         hasPlugins: false,
@@ -3468,7 +4342,8 @@ var DocxFormatAdapter = class {
       theme,
       customThemes,
       debug: process.env.DEBUG === "true",
-      services
+      services,
+      fonts: options.fonts
     });
     for (const plugin of plugins) {
       generator = generator.addComponent(plugin);
@@ -3660,7 +4535,8 @@ var PptxFormatAdapter = class {
     const services = buildServicesFromEnv();
     return await core.generateBufferFromJson(docDefinition, {
       customThemes,
-      services
+      services,
+      fonts: options.fonts
     });
   }
   async createGenerator(plugins, options) {
@@ -3675,7 +4551,8 @@ var PptxFormatAdapter = class {
           const customThemes2 = await this.loadCustomThemes(options);
           return await core.generateBufferFromJson(docDefinition, {
             customThemes: customThemes2,
-            services
+            services,
+            fonts: options.fonts
           });
         },
         hasPlugins: false,
@@ -3688,7 +4565,8 @@ var PptxFormatAdapter = class {
       theme,
       customThemes,
       debug: process.env.DEBUG === "true",
-      services
+      services,
+      fonts: options.fonts
     });
     for (const plugin of plugins) {
       generator = generator.addComponent(plugin);
@@ -3809,7 +4687,7 @@ init_esm_shims();
 init_plugin_registry();
 import { Command } from "commander";
 import { readFileSync as readFileSync3, writeFileSync } from "fs";
-import { resolve as resolve9, basename as basename4 } from "path";
+import { resolve as resolve10, basename as basename5 } from "path";
 import ora from "ora";
 import chalk2 from "chalk";
 import boxen from "boxen";
@@ -4243,7 +5121,125 @@ function formatError(error) {
   }
 }
 
+// src/commands/font-flags.ts
+init_esm_shims();
+import { readdirSync, statSync as statSync2 } from "fs";
+import { basename as basename4, extname, join as join4, resolve as resolve9 } from "path";
+var WEIGHT_NAMES = {
+  thin: 100,
+  hairline: 100,
+  extralight: 200,
+  ultralight: 200,
+  light: 300,
+  regular: 400,
+  normal: 400,
+  book: 400,
+  medium: 500,
+  semibold: 600,
+  demibold: 600,
+  bold: 700,
+  extrabold: 800,
+  ultrabold: 800,
+  black: 900,
+  heavy: 900
+};
+var SUPPORTED_EXT = /* @__PURE__ */ new Set([".ttf", ".otf"]);
+function parseFontFilename(filename) {
+  const stem = basename4(filename, extname(filename));
+  const parts = stem.split(/[-_\s]+/).filter(Boolean);
+  if (parts.length <= 1) {
+    return { family: stem, weight: 400, italic: false };
+  }
+  const tail = parts[parts.length - 1].toLowerCase();
+  const italic = /italic|oblique/.test(tail);
+  const withoutItalic = tail.replace(/italic|oblique/g, "");
+  let weight = null;
+  if (withoutItalic !== "") {
+    const numeric = parseInt(withoutItalic, 10);
+    if (!Number.isNaN(numeric) && String(numeric) === withoutItalic && numeric >= 100 && numeric <= 900) {
+      weight = numeric;
+    } else if (withoutItalic in WEIGHT_NAMES) {
+      weight = WEIGHT_NAMES[withoutItalic];
+    }
+  } else if (italic) {
+    weight = 400;
+  }
+  if (weight === null) {
+    return { family: stem, weight: 400, italic: false };
+  }
+  const family = parts.slice(0, -1).join(" ");
+  return { family, weight, italic };
+}
+function parseFontFlag(spec, cwd = process.cwd()) {
+  const eq = spec.indexOf("=");
+  if (eq < 0) {
+    throw new Error(
+      `--font expects <name>=<path>, got "${spec}". Example: --font Inter=./fonts/Inter-Regular.ttf`
+    );
+  }
+  const family = spec.slice(0, eq).trim();
+  const path17 = spec.slice(eq + 1).trim();
+  if (!family || !path17) {
+    throw new Error(`--font has empty name or path: "${spec}"`);
+  }
+  const absolutePath = resolve9(cwd, path17);
+  const variant = parseFontFilename(path17);
+  return {
+    id: family,
+    family,
+    sources: [
+      {
+        kind: "file",
+        path: absolutePath,
+        weight: variant.weight,
+        italic: variant.italic
+      }
+    ]
+  };
+}
+function parseFontsDir(dir, cwd = process.cwd()) {
+  const absoluteDir = resolve9(cwd, dir);
+  let entries;
+  try {
+    entries = readdirSync(absoluteDir);
+  } catch (err) {
+    throw new Error(
+      `--fonts-dir "${dir}" could not be read: ${err.message}`
+    );
+  }
+  const byFamily = /* @__PURE__ */ new Map();
+  for (const name of entries) {
+    const ext = extname(name).toLowerCase();
+    if (!SUPPORTED_EXT.has(ext)) continue;
+    const fullPath = join4(absoluteDir, name);
+    try {
+      if (!statSync2(fullPath).isFile()) continue;
+    } catch {
+      continue;
+    }
+    const variant = parseFontFilename(name);
+    const source = {
+      kind: "file",
+      path: fullPath,
+      weight: variant.weight,
+      italic: variant.italic
+    };
+    const existing = byFamily.get(variant.family);
+    if (existing) {
+      existing.sources.push(source);
+    } else {
+      byFamily.set(variant.family, {
+        id: variant.family,
+        family: variant.family,
+        sources: [source]
+      });
+    }
+  }
+  return [...byFamily.values()];
+}
+
 // src/commands/generate.ts
+import { isSafeFont } from "@json-to-office/shared";
 function createGenerateCommand(adapter) {
   return new Command("generate").description(`Generate ${adapter.label} from JSON`).argument("<input>", "Input JSON file path").option("-o, --output <path>", "Output file path").option("-t, --template <name>", "Template to use").option(
     "--plugins [names-or-paths]",
@@ -4251,7 +5247,40 @@ function createGenerateCommand(adapter) {
   ).option("--plugin-dir <dir>", "Directory to search for plugins").option("--theme <name-or-path>", "Theme name or path to theme file").option(
     "--theme-path <path>",
     "Path to theme file (alternative to --theme)"
-  ).option("--strict", "Enable strict validation").option("--dry-run", "Preview without writing files").action(async (input, options) => {
+  ).option("--strict", "Enable strict validation").option(
+    "--strict-fonts",
+    "Fail generation on unresolved fontRegistry references"
+  ).option(
+    "--no-google-fonts",
+    "Disable Google Fonts HTTP fetching (offline/CI builds)"
+  ).option(
+    "--font-cache-dir <path>",
+    "Directory to cache fetched Google Fonts TTFs"
+  ).option(
+    "--font <name=path>",
+    "Register a font file (repeatable): <family>=<path to .ttf/.otf>",
+    (value, previous = []) => [...previous, value],
+    []
+  ).option(
+    "--fonts-dir <path>",
+    "Scan directory for .ttf/.otf files and auto-register by filename"
+  ).option(
+    "--font-mode <mode>",
+    'How to handle non-safe fonts: "custom" (default; keep refs as-is \u2014 recipient needs fonts installed) or "substitute" (rewrite to safe fonts)',
+    (value) => {
+      if (value !== "substitute" && value !== "custom") {
+        throw new Error(
+          `--font-mode must be one of: substitute, custom (got "${value}")`
+        );
+      }
+      return value;
+    }
+  ).option(
+    "--font-substitute <family=safe>",
+    "When --font-mode substitute: map a non-safe family to a specific safe font (repeatable). Falls back to category defaults when omitted.",
+    (value, previous = []) => [...previous, value],
+    []
+  ).option("--dry-run", "Preview without writing files").action(async (input, options) => {
     const spinner = ora("Initializing...").start();
     const startTime = performance.now();
     try {
@@ -4274,13 +5303,13 @@ function createGenerateCommand(adapter) {
         adapter.name
       );
       spinner.text = "Reading input file...";
-      const inputPath = resolve9(process.cwd(), input);
+      const inputPath = resolve10(process.cwd(), input);
       const jsonContent = readFileSync3(inputPath, "utf-8");
       const documentDefinition = JSON.parse(jsonContent);
       const factory = new GeneratorFactory(adapter);
-      const outputPath = options.output ? resolve9(process.cwd(), options.output) : resolve9(
+      const outputPath = options.output ? resolve10(process.cwd(), options.output) : resolve10(
         process.cwd(),
-        basename4(input, ".json") + adapter.extension
+        basename5(input, ".json") + adapter.extension
       );
       const pluginInfo = factory.getPluginInfo();
       if (options.dryRun) {
@@ -4310,11 +5339,52 @@ function createGenerateCommand(adapter) {
         PluginRegistry.getInstance().clear();
         return;
       }
+      const extraEntries = [];
+      for (const spec of options.font ?? []) {
+        extraEntries.push(parseFontFlag(spec));
+      }
+      if (options.fontsDir) {
+        extraEntries.push(...parseFontsDir(options.fontsDir));
+      }
+      const substitution = {};
+      for (const spec of options.fontSubstitute ?? []) {
+        const eq = spec.indexOf("=");
+        if (eq < 0) {
+          throw new Error(
+            `--font-substitute expects <family>=<safe-font>, got "${spec}"`
+          );
+        }
+        const from = spec.slice(0, eq).trim();
+        const to = spec.slice(eq + 1).trim();
+        if (!from || !to) {
+          throw new Error(
+            `--font-substitute expects non-empty family and safe-font, got "${spec}"`
+          );
+        }
+        if (!isSafeFont(to)) {
+          throw new Error(
+            `--font-substitute target "${to}" is not in SAFE_FONTS (got "${spec}")`
+          );
+        }
+        substitution[from] = to;
+      }
       spinner.text = `Generating ${adapter.label}...`;
       const buffer = await factory.generate(documentDefinition, {
         theme: mergedConfig.theme,
         themePath: mergedConfig.themePath,
-        validation: mergedConfig.validation
+        validation: mergedConfig.validation,
+        fonts: {
+          strict: options.strictFonts,
+          ...extraEntries.length > 0 && { extraEntries },
+          ...options.fontMode && { mode: options.fontMode },
+          ...Object.keys(substitution).length > 0 && { substitution },
+          googleFonts: {
+            ...options.noGoogleFonts === true && { enabled: false },
+            ...options.fontCacheDir && {
+              cacheDir: resolve10(process.cwd(), options.fontCacheDir)
+            }
+          }
+        }
       });
       spinner.text = "Writing output file...";
       writeFileSync(outputPath, Buffer.from(buffer));
@@ -4359,6 +5429,11 @@ ${chalk2.gray("Examples:")}
   $ jto ${adapter.name} generate doc.json --theme minimal           ${chalk2.dim("# Use built-in theme")}
   $ jto ${adapter.name} generate doc.json --theme-path ./theme.json ${chalk2.dim("# Use custom theme")}
   $ jto ${adapter.name} generate doc.json --dry-run                 ${chalk2.dim("# Preview without writing")}
+  $ jto ${adapter.name} generate doc.json --strict-fonts            ${chalk2.dim("# Fail on unresolved fonts")}
+  $ jto ${adapter.name} generate doc.json --font-cache-dir .fontcache ${chalk2.dim("# Cache Google Fonts TTFs")}
+  $ jto ${adapter.name} generate doc.json --no-google-fonts         ${chalk2.dim("# Offline build, skip network fetches")}
+  $ jto ${adapter.name} generate doc.json --font Inter=./fonts/Inter-Regular.ttf ${chalk2.dim("# Register one TTF")}
+  $ jto ${adapter.name} generate doc.json --fonts-dir ./fonts       ${chalk2.dim("# Auto-register every .ttf/.otf in ./fonts")}
 `
   );
 }
@@ -4368,13 +5443,13 @@ init_esm_shims();
 import { Command as Command2 } from "commander";
 import chalk3 from "chalk";
 import ora2 from "ora";
-import { resolve as resolve11, relative as relative4 } from "path";
+import { resolve as resolve12, relative as relative4 } from "path";
 import { existsSync as existsSync3 } from "fs";
 
 // src/services/json-validator.ts
 init_esm_shims();
-import { readFileSync as readFileSync4, statSync as statSync2, readdirSync } from "fs";
-import { resolve as resolve10, join as join4, extname } from "path";
+import { readFileSync as readFileSync4, statSync as statSync3, readdirSync as readdirSync2 } from "fs";
+import { resolve as resolve11, join as join5, extname as extname2 } from "path";
 import { glob as glob2 } from "glob";
 var JsonValidator = class {
   format;
@@ -4391,7 +5466,7 @@ var JsonValidator = class {
     return results;
   }
   async validateFile(filePath, options = {}) {
-    const absolutePath = resolve10(filePath);
+    const absolutePath = resolve11(filePath);
     try {
       const content = readFileSync4(absolutePath, "utf-8");
       let jsonData;
@@ -4513,7 +5588,7 @@ var JsonValidator = class {
   }
   async validateWithCustomSchema(filePath, jsonData, schemaPath, strict) {
     try {
-      const schemaContent = readFileSync4(resolve10(schemaPath), "utf-8");
+      const schemaContent = readFileSync4(resolve11(schemaPath), "utf-8");
       const schema = JSON.parse(schemaContent);
       const Ajv = (await import("ajv")).default;
       const addFormats = (await import("ajv-formats")).default;
@@ -4562,20 +5637,20 @@ var JsonValidator = class {
     return null;
   }
   async getFilesToValidate(pathOrPattern, options) {
-    const resolvedPath = resolve10(pathOrPattern);
+    const resolvedPath = resolve11(pathOrPattern);
     try {
-      const stats = statSync2(resolvedPath);
+      const stats = statSync3(resolvedPath);
       if (stats.isFile()) {
         return [resolvedPath];
       } else if (stats.isDirectory()) {
         if (options.recursive) {
-          const pattern = join4(resolvedPath, "**/*.json");
+          const pattern = join5(resolvedPath, "**/*.json");
           return glob2(pattern, {
             ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"]
           });
         } else {
-          const files = readdirSync(resolvedPath);
-          return files.filter((file) => extname(file).toLowerCase() === ".json").map((file) => join4(resolvedPath, file));
+          const files = readdirSync2(resolvedPath);
+          return files.filter((file) => extname2(file).toLowerCase() === ".json").map((file) => join5(resolvedPath, file));
         }
       }
     } catch {
@@ -4626,7 +5701,7 @@ function createValidateCommand(adapter) {
       const spinner = showSpinner ? ora2("Validating...").start() : null;
       const startTime = performance.now();
       try {
-        if (options.schema && !existsSync3(resolve11(options.schema))) {
+        if (options.schema && !existsSync3(resolve12(options.schema))) {
           throw new Error(`Schema file not found: ${options.schema}`);
         }
         const results = await validator.validate(fileOrDirectory, {
@@ -5483,7 +6558,7 @@ function groupByLocation(items) {
 init_esm_shims();
 import { Command as Command5 } from "commander";
 import { mkdirSync, writeFileSync as writeFileSync2, existsSync as existsSync4 } from "fs";
-import { resolve as resolve13, join as join6 } from "path";
+import { resolve as resolve14, join as join7 } from "path";
 import { execSync } from "child_process";
 import ora5 from "ora";
 import chalk7 from "chalk";
@@ -5509,7 +6584,7 @@ function createInitCommand(adapter) {
           process.exit(EXIT_CODES.FAIL);
         }
       }
-      const projectPath = resolve13(process.cwd(), name);
+      const projectPath = resolve14(process.cwd(), name);
       if (existsSync4(projectPath)) {
         console.error(chalk7.red(`Directory ${name} already exists`));
         process.exit(EXIT_CODES.FAIL);
@@ -5535,7 +6610,7 @@ function createInitCommand(adapter) {
         }
       };
       writeFileSync2(
-        join6(projectPath, "package.json"),
+        join7(projectPath, "package.json"),
         JSON.stringify(packageJson, null, 2)
       );
       const exampleDocument = adapter.name === "docx" ? {
@@ -5583,7 +6658,7 @@ function createInitCommand(adapter) {
         ]
       };
       writeFileSync2(
-        join6(projectPath, "example.json"),
+        join7(projectPath, "example.json"),
         JSON.stringify(exampleDocument, null, 2)
       );
       const gitignore = `node_modules
@@ -5593,7 +6668,7 @@ dist
 .env
 .env.local
 `;
-      writeFileSync2(join6(projectPath, ".gitignore"), gitignore);
+      writeFileSync2(join7(projectPath, ".gitignore"), gitignore);
       console.log(chalk7.green(`
 Created project at ${projectPath}
 `));
@@ -5651,7 +6726,7 @@ import boxen3 from "boxen";
 init_esm_shims();
 import { existsSync as existsSync5 } from "fs";
 import { readFile as readFile4 } from "fs/promises";
-import { resolve as resolve14 } from "path";
+import { resolve as resolve15 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/config/schema.ts
@@ -5796,7 +6871,7 @@ async function loadConfig(configPath) {
 async function findConfigFile() {
   const cwd = process.cwd();
   for (const filename of CONFIG_FILES) {
-    const filepath = resolve14(cwd, filename);
+    const filepath = resolve15(cwd, filename);
     if (existsSync5(filepath)) {
       return filepath;
     }
@@ -5896,8 +6971,304 @@ ${chalk8.cyan("Health:")}  ${url}/health
   });
 }
 
+// src/commands/fonts.ts
+init_esm_shims();
+import { Command as Command7 } from "commander";
+import chalk9 from "chalk";
+import {
+  readFileSync as readFileSync6,
+  statSync as statSync4,
+  mkdirSync as mkdirSync2,
+  writeFileSync as writeFileSync3,
+  renameSync,
+  unlinkSync
+} from "fs";
+import { resolve as resolve17, basename as basename6, extname as extname3 } from "path";
+import {
+  SAFE_FONTS as SAFE_FONTS2,
+  collectFontNamesFromDocx as collectFontNamesFromDocx2,
+  collectFontNamesFromPptx as collectFontNamesFromPptx2,
+  detectFontFormat,
+  fetchGoogleFontSources as fetchGoogleFontSources2,
+  isSafeFont as isSafeFont3,
+  POPULAR_GOOGLE_FONTS as POPULAR_GOOGLE_FONTS3
+} from "@json-to-office/shared";
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+function weightLabel(weight, italic) {
+  return `${weight}${italic ? " italic" : ""}`;
+}
+function listSafeFonts() {
+  console.log(
+    chalk9.bold("\nSafe fonts (bundled with Office, no embedding needed):")
+  );
+  for (const name of SAFE_FONTS2) {
+    console.log(`  ${chalk9.cyan(name)}`);
+  }
+}
+function listLocalFonts(dir) {
+  let entries;
+  try {
+    entries = parseFontsDir(dir);
+  } catch (err) {
+    console.log(
+      chalk9.yellow(
+        `
+(--fonts-dir ${dir} not readable: ${err.message})`
+      )
+    );
+    return;
+  }
+  if (entries.length === 0) {
+    console.log(chalk9.dim(`
+Local fonts in ${dir}: (none)`));
+    return;
+  }
+  console.log(chalk9.bold(`
+Local fonts in ${dir}:`));
+  for (const e of entries) {
+    const variants = e.sources.map((s) => {
+      const weight = "weight" in s ? s.weight ?? 400 : 400;
+      const italic = "italic" in s ? Boolean(s.italic) : false;
+      return weightLabel(weight, italic);
+    }).join(", ");
+    console.log(`  ${chalk9.cyan(e.family)}  ${chalk9.dim(`(${variants})`)}`);
+  }
+}
+function listReferencedFonts(docPath, adapterName) {
+  const absolutePath = resolve17(process.cwd(), docPath);
+  let raw;
+  try {
+    raw = readFileSync6(absolutePath, "utf-8");
+  } catch (err) {
+    console.log(
+      chalk9.yellow(`
+(Could not read ${docPath}: ${err.message})`)
+    );
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    console.log(
+      chalk9.yellow(
+        `
+(${docPath} is not valid JSON: ${err.message})`
+      )
+    );
+    return;
+  }
+  const names = adapterName === "docx" ? collectFontNamesFromDocx2(parsed) : collectFontNamesFromPptx2(parsed);
+  if (names.size === 0) {
+    console.log(chalk9.dim(`
+Fonts referenced in ${docPath}: (none)`));
+    return;
+  }
+  console.log(chalk9.bold(`
+Fonts referenced in ${docPath}:`));
+  for (const name of [...names].sort()) {
+    const status = isSafeFont3(name) ? chalk9.green("[safe]") : POPULAR_GOOGLE_FONTS3.some(
+      (g) => g.family.toLowerCase() === name.toLowerCase()
+    ) ? chalk9.blue("[google]") : chalk9.yellow("[unresolved]");
+    console.log(`  ${chalk9.cyan(name)}  ${status}`);
+  }
+}
+function createListCommand(adapter) {
+  return new Command7("list").description(
+    "List safe fonts, fonts in ./fonts, and fonts referenced in a document"
+  ).argument(
+    "[document]",
+    "Optional JSON document to scan for font references"
+  ).option(
+    "--fonts-dir <path>",
+    "Directory of local .ttf/.otf files to list (default: ./fonts)",
+    "./fonts"
+  ).action(async (document, options) => {
+    listSafeFonts();
+    if (options.fontsDir) listLocalFonts(options.fontsDir);
+    if (document) {
+      listReferencedFonts(document, adapter.name);
+    }
+    console.log();
+  });
+}
+function createInspectCommand() {
+  return new Command7("inspect").description("Print family/weight/italic/format/size for a .ttf/.otf file").argument("<file>", "Path to a font file").action(async (file) => {
+    const absolute = resolve17(process.cwd(), file);
+    let buf;
+    let size;
+    try {
+      buf = readFileSync6(absolute);
+      size = statSync4(absolute).size;
+    } catch (err) {
+      formatError(err);
+      process.exit(EXIT_CODES.FAIL);
+    }
+    const format = detectFontFormat(buf);
+    const parsed = parseFontFilename(basename6(file));
+    const ext = extname3(file).toLowerCase();
+    console.log();
+    console.log(chalk9.bold("Font:"), chalk9.cyan(parsed.family));
+    console.log(chalk9.bold("File:"), file);
+    console.log(
+      chalk9.bold("Format:"),
+      format === "unknown" ? chalk9.yellow(format) : format
+    );
+    console.log(chalk9.bold("Weight:"), parsed.weight);
+    console.log(chalk9.bold("Italic:"), parsed.italic ? "yes" : "no");
+    console.log(chalk9.bold("Size:"), formatBytes(size));
+    if (format !== "ttf" && format !== "otf") {
+      console.log(
+        chalk9.yellow(
+          "\nWarning: embedding requires TTF or OTF. WOFF/WOFF2 won't embed in .docx."
+        )
+      );
+    }
+    if (parsed.family === basename6(file, ext)) {
+      console.log(
+        chalk9.dim(
+          "\n(Family was not parsed from a recognized weight/style suffix \u2014 treating full filename as family.)"
+        )
+      );
+    }
+    console.log();
+  });
+}
+function parseWeightsOption(raw) {
+  if (!raw) return [400, 700];
+  const out = [];
+  for (const token of raw.split(/[,\s]+/).filter(Boolean)) {
+    const n = parseInt(token, 10);
+    if (Number.isNaN(n) || n < 100 || n > 900 || n % 100 !== 0) {
+      throw new Error(
+        `--weights must be 100-step integers between 100 and 900, got "${token}"`
+      );
+    }
+    out.push(n);
+  }
+  return [...new Set(out)].sort((a, b) => a - b);
+}
+var WEIGHT_NAMES2 = {
+  100: "Thin",
+  200: "ExtraLight",
+  300: "Light",
+  400: "Regular",
+  500: "Medium",
+  600: "SemiBold",
+  700: "Bold",
+  800: "ExtraBold",
+  900: "Black"
+};
+function filenameFor(family, weight, italic) {
+  const safeFamily = family.replace(/\s+/g, "");
+  const suffix = `${WEIGHT_NAMES2[weight] ?? weight}${italic ? "Italic" : ""}`;
+  return `${safeFamily}-${suffix}.ttf`;
+}
+function createInstallCommand() {
+  return new Command7("install").description(
+    "Download a Google Fonts family into ./fonts/ (filenames compatible with --fonts-dir)"
+  ).argument("<family>", 'Google Fonts family name (e.g. "Inter")').option(
+    "-w, --weights <list>",
+    'Comma-separated weights (100..900, step 100). Default: "400,700"'
+  ).option("--italics", "Also download italic variants").option(
+    "-d, --dir <path>",
+    "Output directory (default: ./fonts)",
+    "./fonts"
+  ).action(async (family, options) => {
+    const weights = parseWeightsOption(options.weights);
+    const italics = Boolean(options.italics);
+    const outDir = resolve17(process.cwd(), options.dir ?? "./fonts");
+    console.log(
+      chalk9.dim(
+        `Fetching ${family} [${weights.join(", ")}]${italics ? " + italics" : ""} from Google Fonts...`
+      )
+    );
+    const { sources, warnings } = await fetchGoogleFontSources2({
+      family,
+      weights,
+      italics
+    });
+    if (warnings.length > 0) {
+      for (const w of warnings) console.warn(chalk9.yellow(`  ${w}`));
+    }
+    if (sources.length === 0) {
+      console.error(chalk9.red(`
+No variants downloaded for "${family}".`));
+      process.exit(EXIT_CODES.FAIL);
+    }
+    mkdirSync2(outDir, { recursive: true });
+    const written = [];
+    const failures = [];
+    for (const src of sources) {
+      const name = filenameFor(family, src.weight, src.italic);
+      const full = resolve17(outDir, name);
+      const tmp = `${full}.tmp`;
+      try {
+        writeFileSync3(tmp, src.data);
+        renameSync(tmp, full);
+        written.push(name);
+      } catch (err) {
+        try {
+          unlinkSync(tmp);
+        } catch {
+        }
+        failures.push({ name, err: err.message });
+      }
+    }
+    if (failures.length > 0) {
+      console.error(
+        chalk9.red(`
+${failures.length} file(s) failed to install:`)
+      );
+      for (const f of failures) {
+        console.error(`  ${chalk9.red(f.name)}: ${f.err}`);
+      }
+    }
+    if (written.length > 0) {
+      console.log(
+        chalk9.green(`
+Installed ${written.length} file(s) into ${outDir}:`)
+      );
+      for (const name of written) console.log(`  ${chalk9.cyan(name)}`);
+      console.log(
+        chalk9.dim(
+          `
+Use them with:  jto <format> generate doc.json --fonts-dir ${options.dir ?? "./fonts"}`
+        )
+      );
+    }
+    if (failures.length > 0) {
+      process.exit(EXIT_CODES.FAIL);
+    }
+  });
+}
+function createFontsCommand(adapter) {
+  const cmd = new Command7("fonts").description(
+    `Font introspection and Google Fonts install for ${adapter.label}s`
+  );
+  cmd.addCommand(createListCommand(adapter));
+  cmd.addCommand(createInspectCommand());
+  cmd.addCommand(createInstallCommand());
+  cmd.addHelpText(
+    "after",
+    `
+${chalk9.gray("Examples:")}
+  $ jto ${adapter.name} fonts list                         ${chalk9.dim("# Safe + ./fonts")}
+  $ jto ${adapter.name} fonts list doc.json                ${chalk9.dim("# + fonts referenced in doc")}
+  $ jto ${adapter.name} fonts inspect ./fonts/Inter-Bold.ttf
+  $ jto ${adapter.name} fonts install Inter                ${chalk9.dim("# \u2192 ./fonts/Inter-Regular.ttf + Inter-Bold.ttf")}
+  $ jto ${adapter.name} fonts install "Playfair Display" --weights 400,700 --italics
+`
+  );
+  return cmd;
+}
+
 // src/cli.ts
-var PACKAGE_VERSION = true ? "0.8.3" : "dev-mode";
+var PACKAGE_VERSION = true ? "0.9.0" : "dev-mode";
 function registerFormatCommands(parent, adapter) {
   parent.addCommand(createGenerateCommand(adapter));
   parent.addCommand(createValidateCommand(adapter));
@@ -5905,25 +7276,27 @@ function registerFormatCommands(parent, adapter) {
   parent.addCommand(createDiscoverCommand(adapter));
   parent.addCommand(createInitCommand(adapter));
   parent.addCommand(createDevCommand(adapter));
+  parent.addCommand(createFontsCommand(adapter));
 }
-var program = new Command7();
+var program = new Command8();
 program.name("jto").description("JSON to Office CLI - Generate .docx and .pptx from JSON").version(PACKAGE_VERSION);
-var docx = new Command7("docx").description("DOCX document commands");
+var docx = new Command8("docx").description("DOCX document commands");
 registerFormatCommands(docx, new DocxFormatAdapter());
-var pptx = new Command7("pptx").description("PPTX presentation commands");
+var pptx = new Command8("pptx").description("PPTX presentation commands");
 registerFormatCommands(pptx, new PptxFormatAdapter());
 program.addCommand(docx);
 program.addCommand(pptx);
 program.addHelpText(
   "after",
   `
-${chalk9.gray("Examples:")}
-  $ jto docx generate doc.json      ${chalk9.dim("# Generate DOCX from JSON")}
-  $ jto pptx generate slides.json   ${chalk9.dim("# Generate PPTX from JSON")}
-  $ jto docx dev                    ${chalk9.dim("# Start DOCX dev server")}
-  $ jto pptx validate slides.json   ${chalk9.dim("# Validate PPTX JSON")}
-  $ jto docx schemas                ${chalk9.dim("# Export DOCX JSON schemas")}
-  $ jto pptx discover               ${chalk9.dim("# Discover PPTX plugins")}
+${chalk10.gray("Examples:")}
+  $ jto docx generate doc.json      ${chalk10.dim("# Generate DOCX from JSON")}
+  $ jto pptx generate slides.json   ${chalk10.dim("# Generate PPTX from JSON")}
+  $ jto docx dev                    ${chalk10.dim("# Start DOCX dev server")}
+  $ jto pptx validate slides.json   ${chalk10.dim("# Validate PPTX JSON")}
+  $ jto docx schemas                ${chalk10.dim("# Export DOCX JSON schemas")}
+  $ jto pptx discover               ${chalk10.dim("# Discover PPTX plugins")}
+  $ jto docx fonts install Inter    ${chalk10.dim("# Download a Google Font into ./fonts")}
 `
 );
 program.exitOverride();
@@ -5937,7 +7310,7 @@ program.exitOverride();
     if (error.code === "commander.executeSubCommandAsync") {
       process.exit(error.exitCode);
     }
-    console.error(chalk9.red("Error:"), error.message);
+    console.error(chalk10.red("Error:"), error.message);
     process.exit(1);
   }
 })();