@json-to-office/shared 0.7.0 → 0.9.0

package/dist/index.js

@@ -1,3 +1,7 @@
+import {
+  detectFontFormat,
+  isAllowedFontUrl
+} from "./chunk-CP2I5NPP.js";
 import {
   ComponentValidationError,
   DuplicateComponentError,
@@ -41,13 +45,1511 @@ import {
   transformValueError,
   transformValueErrors
 } from "./chunk-ZKD5BAMU.js";
+
+// src/schemas/font-catalog.ts
+import { Type } from "@sinclair/typebox";
+var SAFE_FONTS = [
+  "Arial",
+  "Calibri",
+  "Cambria",
+  "Consolas",
+  "Courier New",
+  "Georgia",
+  "Segoe UI",
+  "Tahoma",
+  "Times New Roman",
+  "Trebuchet MS",
+  "Verdana",
+  "Helvetica",
+  "Helvetica Neue",
+  "Menlo",
+  "Monaco"
+];
+function isSafeFont(name) {
+  const lower = name.toLowerCase();
+  return SAFE_FONTS.some((f) => f.toLowerCase() === lower);
+}
+var FontFamilyNameSchema = Type.String({
+  description: "Font family name. Prefer a SAFE_FONTS entry (Arial, Calibri, Cambria, Consolas, Courier New, Georgia, Segoe UI, Tahoma, Times New Roman, Trebuchet MS, Verdana, Helvetica, Helvetica Neue, Menlo, Monaco) for zero-setup rendering. For any other font, register it in props.fontRegistry[] and reference it here by family. Unregistered non-safe names render with a host fallback.",
+  examples: ["Arial", "Calibri", "Georgia", "Inter", "Roboto"]
+});
+var FontWeightSchema = Type.Number({
+  minimum: 100,
+  maximum: 900,
+  description: "OpenType weight (100 thin ... 900 black). Default 400."
+});
+var FontItalicSchema = Type.Boolean({
+  description: "Whether this source is italic. Default false."
+});
+var SafeFontSourceSchema = Type.Object(
+  {
+    kind: Type.Literal("safe"),
+    family: Type.String({
+      description: "A SAFE_FONTS name \u2014 installed with Office."
+    })
+  },
+  {
+    additionalProperties: false,
+    description: "Office-installed font \u2014 no embedding"
+  }
+);
+var GoogleFontSourceSchema = Type.Object(
+  {
+    kind: Type.Literal("google"),
+    family: Type.String({
+      description: 'Exact Google Fonts family name (e.g. "Inter").'
+    }),
+    weights: Type.Optional(
+      Type.Array(FontWeightSchema, {
+        description: "Weights to fetch. Default [400, 700]."
+      })
+    ),
+    italics: Type.Optional(
+      Type.Boolean({ description: "Include italic variants. Default false." })
+    )
+  },
+  {
+    additionalProperties: false,
+    description: "Google Fonts \u2014 auto-fetched and embedded"
+  }
+);
+var FileFontSourceSchema = Type.Object(
+  {
+    kind: Type.Literal("file"),
+    path: Type.String({
+      description: "Path to a .ttf/.otf file. Relative paths are resolved against the JSON document file."
+    }),
+    weight: Type.Optional(FontWeightSchema),
+    italic: Type.Optional(FontItalicSchema)
+  },
+  { additionalProperties: false, description: "Local font file to embed" }
+);
+var UrlFontSourceSchema = Type.Object(
+  {
+    kind: Type.Literal("url"),
+    url: Type.String({
+      description: "HTTPS URL of a TTF or OTF file."
+    }),
+    weight: Type.Optional(FontWeightSchema),
+    italic: Type.Optional(FontItalicSchema)
+  },
+  {
+    additionalProperties: false,
+    description: "Direct TTF/OTF URL (non-Google CDN)"
+  }
+);
+var VariableFontSourceSchema = Type.Object(
+  {
+    kind: Type.Literal("variable"),
+    url: Type.String({
+      description: "HTTPS URL of a variable TTF (`fvar` axis table required)."
+    }),
+    weight: FontWeightSchema,
+    italic: Type.Optional(FontItalicSchema),
+    axes: Type.Optional(
+      Type.Record(Type.String(), Type.Number(), {
+        description: "Additional axis pin values (e.g. `{ ital: 1, opsz: 14 }`) merged on top of the derived `wght` pin. Uncommon \u2014 the `weight` field is usually enough."
+      })
+    )
+  },
+  {
+    additionalProperties: false,
+    description: "Variable-font instancer. The fetcher pins `wght` to `weight` (plus any `axes` overrides) and emits a clean static TTF, bypassing upstream distributions that collapse multiple static weights onto the same glyph geometry."
+  }
+);
+var DataFontSourceSchema = Type.Object(
+  {
+    kind: Type.Literal("data"),
+    data: Type.String({
+      description: "Base64-encoded TTF/OTF or data: URL (data:font/ttf;base64,...). Makes the JSON self-contained at the cost of size."
+    }),
+    weight: Type.Optional(FontWeightSchema),
+    italic: Type.Optional(FontItalicSchema)
+  },
+  { additionalProperties: false, description: "Inline base64 font \u2014 portable" }
+);
+var FontSourceSchema = Type.Union(
+  [
+    SafeFontSourceSchema,
+    GoogleFontSourceSchema,
+    FileFontSourceSchema,
+    DataFontSourceSchema,
+    UrlFontSourceSchema,
+    VariableFontSourceSchema
+  ],
+  {
+    description: 'A single font variant source. Use kind:"safe" for installed fonts, kind:"google" for Google Fonts, kind:"file" for local files, kind:"data" for base64, kind:"url" for direct HTTPS TTF/OTF URLs, kind:"variable" to instance a variable TTF at a specific weight.'
+  }
+);
+var FontCategorySchema = Type.Union(
+  [
+    Type.Literal("sans"),
+    Type.Literal("serif"),
+    Type.Literal("mono"),
+    Type.Literal("display"),
+    Type.Literal("handwriting")
+  ],
+  { description: "Broad category used for fallback selection" }
+);
+var FontRegistryEntrySchema = Type.Object(
+  {
+    id: Type.String({
+      description: 'Registry key. By convention, match the display family name ("Inter", "Roboto Slab").'
+    }),
+    family: Type.String({
+      description: "Display family used in font.family / fontFace / theme.fonts.*. Usually identical to id."
+    }),
+    category: Type.Optional(FontCategorySchema),
+    sources: Type.Array(FontSourceSchema, {
+      minItems: 1,
+      description: "One or more weight/style variants. List at least a regular (weight 400, italic false)."
+    })
+  },
+  {
+    additionalProperties: false,
+    description: "A font registered for this document. Referenced by family from font.family, fontFace, and theme.fonts.*."
+  }
+);
+var FontRegistrySchema = Type.Array(FontRegistryEntrySchema, {
+  description: "Document-scoped font registry. Every non-safe font used in this document must be registered here."
+});
+
+// src/fonts/collect.ts
+var FONT_NAME_KEYS = /* @__PURE__ */ new Set([
+  "family",
+  "fontFace",
+  "titleFontFace",
+  "legendFontFace",
+  "dataLabelFontFace",
+  "catAxisLabelFontFace",
+  "valAxisLabelFontFace"
+]);
+var THEME_FONT_KEYS = /* @__PURE__ */ new Set(["heading", "body", "mono", "light"]);
+function collect(node, out, parentKey) {
+  if (node == null) return;
+  if (typeof node === "string") {
+    if (parentKey && (FONT_NAME_KEYS.has(parentKey) || THEME_FONT_KEYS.has(parentKey))) {
+      const trimmed = node.trim();
+      if (trimmed.length > 0) out.add(trimmed);
+    }
+    return;
+  }
+  if (Array.isArray(node)) {
+    for (const item of node) collect(item, out, parentKey);
+    return;
+  }
+  if (typeof node === "object") {
+    const maybeFonts = node.fonts;
+    if (parentKey === "theme" && maybeFonts && typeof maybeFonts === "object") {
+      for (const [k, v] of Object.entries(
+        maybeFonts
+      )) {
+        if (typeof v === "string") {
+          const trimmed = v.trim();
+          if (trimmed.length > 0) out.add(trimmed);
+        } else if (v && typeof v === "object") {
+          const fam = v.family;
+          if (typeof fam === "string" && fam.trim().length > 0) {
+            out.add(fam.trim());
+          }
+        }
+        void k;
+      }
+    }
+    for (const [k, v] of Object.entries(node)) {
+      collect(v, out, k);
+    }
+  }
+}
+function collectFontNames(doc) {
+  const out = /* @__PURE__ */ new Set();
+  collect(doc, out);
+  return out;
+}
+var collectFontNamesFromDocx = collectFontNames;
+var collectFontNamesFromPptx = collectFontNames;
+
+// src/fonts/validator.ts
+function buildRegistryIndex(registeredEntries) {
+  const idx = /* @__PURE__ */ new Set();
+  for (const e of registeredEntries ?? []) {
+    idx.add(e.family.toLowerCase());
+    idx.add(e.id.toLowerCase());
+  }
+  return idx;
+}
+function validateFontReferences(input) {
+  const registryIdx = buildRegistryIndex(input.registeredEntries);
+  const resolved = [];
+  const unresolved = [];
+  const warnings = [];
+  for (const name of input.referencedNames) {
+    if (isSafeFont(name) || registryIdx.has(name.toLowerCase())) {
+      resolved.push(name);
+      continue;
+    }
+    unresolved.push(name);
+    warnings.push({
+      code: "FONT_UNRESOLVED",
+      family: name,
+      message: `Font "${name}" is not a SAFE_FONTS entry and is not registered via fonts.extraEntries. It will render with a host fallback on machines lacking the font. Safe fonts: ${SAFE_FONTS.join(", ")}.`
+    });
+  }
+  return { resolved, unresolved, warnings };
+}
+
+// src/fonts/synthesize.ts
+var WEIGHT_LABELS = {
+  100: "Thin",
+  200: "ExtraLight",
+  300: "Light",
+  400: "Regular",
+  500: "Medium",
+  600: "SemiBold",
+  700: "Bold",
+  800: "ExtraBold",
+  900: "Black"
+};
+function synthesizeFamilyName(family, weight, italic) {
+  if (weight == null) {
+    return { family, bold: false, italic, nonCanonicalWeight: false };
+  }
+  if (weight === 400) {
+    return { family, bold: false, italic, nonCanonicalWeight: false };
+  }
+  if (weight === 700) {
+    return { family, bold: true, italic, nonCanonicalWeight: false };
+  }
+  const label = WEIGHT_LABELS[weight];
+  if (!label) {
+    return {
+      family,
+      bold: weight >= 600,
+      italic,
+      nonCanonicalWeight: true
+    };
+  }
+  const suffix = italic ? ` ${label} Italic` : ` ${label}`;
+  return {
+    family: `${family}${suffix}`,
+    bold: false,
+    italic: false,
+    nonCanonicalWeight: false
+  };
+}
+
+// src/fonts/sources/ttf-name.ts
+var TARGET_NAME_IDS = /* @__PURE__ */ new Set([
+  1,
+  // Font Family
+  4,
+  // Full Font Name
+  6,
+  // PostScript Name
+  16
+  // Typographic/Preferred Family
+]);
+var MAGIC_HEAD_CHECKSUM = 2981146554;
+function sfntChecksum(buf) {
+  let sum = 0;
+  const end = buf.length;
+  const aligned = end - end % 4;
+  for (let i = 0; i < aligned; i += 4) {
+    sum = sum + buf.readUInt32BE(i) >>> 0;
+  }
+  if (aligned < end) {
+    let chunk = 0;
+    const remaining = end - aligned;
+    if (remaining >= 1) chunk |= buf[aligned] << 24;
+    if (remaining >= 2) chunk |= buf[aligned + 1] << 16;
+    if (remaining >= 3) chunk |= buf[aligned + 2] << 8;
+    sum = sum + chunk >>> 0;
+  }
+  return sum >>> 0;
+}
+function encodeString(record, value) {
+  if (record.platformID === 1) {
+    return Buffer.from(value, "ascii");
+  }
+  const out = Buffer.alloc(value.length * 2);
+  for (let i = 0; i < value.length; i += 1) {
+    out.writeUInt16BE(value.charCodeAt(i), i * 2);
+  }
+  return out;
+}
+function buildNameTable(records) {
+  const count = records.length;
+  const headerSize = 6 + count * 12;
+  let heapSize = 0;
+  for (const r of records) heapSize += r.bytes.length;
+  const raw = Buffer.alloc(headerSize + heapSize);
+  raw.writeUInt16BE(0, 0);
+  raw.writeUInt16BE(count, 2);
+  raw.writeUInt16BE(headerSize, 4);
+  let heapCursor = 0;
+  for (let i = 0; i < count; i += 1) {
+    const r = records[i];
+    const ro = 6 + i * 12;
+    raw.writeUInt16BE(r.platformID, ro);
+    raw.writeUInt16BE(r.encodingID, ro + 2);
+    raw.writeUInt16BE(r.languageID, ro + 4);
+    raw.writeUInt16BE(r.nameID, ro + 6);
+    raw.writeUInt16BE(r.bytes.length, ro + 8);
+    raw.writeUInt16BE(heapCursor, ro + 10);
+    r.bytes.copy(raw, headerSize + heapCursor);
+    heapCursor += r.bytes.length;
+  }
+  return raw;
+}
+function rewriteFontFamilyName(input, newFamily) {
+  if (input.length < 12) return input;
+  const version = input.readUInt32BE(0);
+  const isSfnt = version === 65536 || version === 1330926671 || version === 1953658213 || version === 1954115633;
+  if (!isSfnt) return input;
+  const numTables = input.readUInt16BE(4);
+  if (numTables === 0 || input.length < 12 + numTables * 16) return input;
+  const tables = [];
+  for (let i = 0; i < numTables; i += 1) {
+    const eo = 12 + i * 16;
+    const tag = input.toString("ascii", eo, eo + 4);
+    const checksum = input.readUInt32BE(eo + 4);
+    const offset = input.readUInt32BE(eo + 8);
+    const length = input.readUInt32BE(eo + 12);
+    if (offset + length > input.length) return input;
+    tables.push({
+      tag,
+      checksum,
+      offset: 0,
+      originalOffset: offset,
+      data: input.slice(offset, offset + length)
+    });
+  }
+  const nameIdx = tables.findIndex((t) => t.tag === "name");
+  if (nameIdx === -1) return input;
+  const nameBuf = tables[nameIdx].data;
+  if (nameBuf.length < 6) return input;
+  const recordCount = nameBuf.readUInt16BE(2);
+  const stringOffset = nameBuf.readUInt16BE(4);
+  if (nameBuf.length < 6 + recordCount * 12) return input;
+  const records = [];
+  for (let i = 0; i < recordCount; i += 1) {
+    const ro = 6 + i * 12;
+    const platformID = nameBuf.readUInt16BE(ro);
+    const encodingID = nameBuf.readUInt16BE(ro + 2);
+    const languageID = nameBuf.readUInt16BE(ro + 4);
+    const nameID = nameBuf.readUInt16BE(ro + 6);
+    const length = nameBuf.readUInt16BE(ro + 8);
+    const offset = nameBuf.readUInt16BE(ro + 10);
+    const bytes = nameBuf.slice(
+      stringOffset + offset,
+      stringOffset + offset + length
+    );
+    records.push({ platformID, encodingID, languageID, nameID, bytes });
+  }
+  const psForbidden = /[[\](){}<>/%]/g;
+  const isAscii = /^[\x00-\x7f]*$/.test(newFamily);
+  const survivors = [];
+  for (const r of records) {
+    if (!TARGET_NAME_IDS.has(r.nameID)) {
+      survivors.push(r);
+      continue;
+    }
+    if (r.platformID === 1 && !isAscii) {
+      continue;
+    }
+    const value = r.nameID === 6 ? newFamily.replace(/\s+/g, "").replace(psForbidden, "").replace(/[^\x21-\x7e]/g, "") : newFamily;
+    r.bytes = encodeString(r, value);
+    survivors.push(r);
+  }
+  records.length = 0;
+  records.push(...survivors);
+  const rebuiltName = buildNameTable(records);
+  tables[nameIdx] = {
+    ...tables[nameIdx],
+    data: rebuiltName,
+    checksum: sfntChecksum(rebuiltName)
+  };
+  tables.sort((a, b) => a.originalOffset - b.originalOffset);
+  let cursor = 12 + tables.length * 16;
+  for (const t of tables) {
+    cursor = cursor + 3 & ~3;
+    t.offset = cursor;
+    cursor += t.data.length;
+  }
+  const totalSize = cursor + 3 & ~3;
+  const out = Buffer.alloc(totalSize);
+  input.copy(out, 0, 0, 12);
+  out.writeUInt16BE(tables.length, 4);
+  const dirTables = [...tables].sort(
+    (a, b) => a.tag < b.tag ? -1 : a.tag > b.tag ? 1 : 0
+  );
+  for (let i = 0; i < dirTables.length; i += 1) {
+    const t = dirTables[i];
+    const eo = 12 + i * 16;
+    out.write(t.tag, eo, 4, "ascii");
+    out.writeUInt32BE(t.checksum, eo + 4);
+    out.writeUInt32BE(t.offset, eo + 8);
+    out.writeUInt32BE(t.data.length, eo + 12);
+  }
+  for (const t of tables) {
+    t.data.copy(out, t.offset);
+  }
+  const headTable = tables.find((t) => t.tag === "head");
+  if (headTable && headTable.data.length >= 12) {
+    out.writeUInt32BE(0, headTable.offset + 8);
+    const fontSum = sfntChecksum(out);
+    const adjustment = MAGIC_HEAD_CHECKSUM - fontSum >>> 0;
+    out.writeUInt32BE(adjustment, headTable.offset + 8);
+  }
+  return out;
+}
+
+// src/fonts/sources/data-loader.ts
+var MAX_DATA_FONT_BYTES = 5 * 1024 * 1024;
+function loadDataFontSource(input) {
+  const raw = input.data.trim();
+  let b64;
+  if (raw.startsWith("data:")) {
+    const comma = raw.indexOf(",");
+    if (comma < 0) throw new Error("Invalid data URL: no payload separator");
+    const header = raw.slice(5, comma);
+    if (!header.includes(";base64")) {
+      throw new Error("Data URL must be base64-encoded");
+    }
+    b64 = raw.slice(comma + 1);
+  } else {
+    b64 = raw;
+  }
+  const approxDecodedBytes = Math.floor(b64.length * 3 / 4);
+  if (approxDecodedBytes > MAX_DATA_FONT_BYTES) {
+    throw new Error(
+      `Font data payload exceeds ${MAX_DATA_FONT_BYTES} byte limit`
+    );
+  }
+  const data = Buffer.from(b64, "base64");
+  if (data.length === 0) throw new Error("Decoded font buffer is empty");
+  if (data.length > MAX_DATA_FONT_BYTES) {
+    throw new Error(
+      `Font data payload exceeds ${MAX_DATA_FONT_BYTES} byte limit`
+    );
+  }
+  const format = detectFontFormat(data);
+  if (format === "unknown") {
+    throw new Error(
+      "Decoded font buffer is not a recognized font (expected TTF/OTF/WOFF/WOFF2)"
+    );
+  }
+  return {
+    data,
+    weight: input.weight ?? 400,
+    italic: input.italic ?? false,
+    format
+  };
+}
+
+// src/fonts/sources/google-fetcher.ts
+var TTF_UA = "Mozilla/4.0";
+async function fetchWithTimeout(url, opts) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), opts.timeoutMs ?? 5e3);
+  try {
+    const f = opts.fetcher ?? fetch;
+    return await f(url, { headers: opts.headers, signal: ctrl.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function buildCssUrl(family, weights, italics) {
+  const famPart = encodeURIComponent(family).replace(/%20/g, "+");
+  const sortedWeights = [...weights].sort((a, b) => a - b);
+  if (italics) {
+    const axis = sortedWeights.flatMap((w) => [`0,${w}`, `1,${w}`]).join(";");
+    return `https://fonts.googleapis.com/css2?family=${famPart}:ital,wght@${axis}&display=swap`;
+  }
+  const wghtPart = sortedWeights.join(";");
+  return `https://fonts.googleapis.com/css2?family=${famPart}:wght@${wghtPart}&display=swap`;
+}
+function parseCssFaces(css) {
+  const out = [];
+  const faceRe = /@font-face\s*\{([^}]*)\}/g;
+  let m;
+  while ((m = faceRe.exec(css)) !== null) {
+    const block = m[1];
+    const urlM = block.match(
+      /src:\s*url\((https:\/\/fonts\.gstatic\.com\/[^)]+\.ttf)\)/
+    );
+    if (!urlM) continue;
+    const weightM = block.match(/font-weight:\s*(\d+)/);
+    const italicM = block.match(/font-style:\s*italic/);
+    out.push({
+      weight: weightM ? parseInt(weightM[1], 10) : 400,
+      italic: Boolean(italicM),
+      ttfUrl: urlM[1]
+    });
+  }
+  return out;
+}
+function cacheKey(family, weight, italic) {
+  return `google|${family}|${weight}|${italic ? "i" : "r"}`;
+}
+async function fetchGoogleFontSources(opts) {
+  const weights = opts.weights?.length ? opts.weights : [400, 700];
+  const italics = opts.italics ?? false;
+  const warnings = [];
+  const sources = [];
+  const wanted = [];
+  for (const w of weights) {
+    wanted.push({ weight: w, italic: false });
+    if (italics) wanted.push({ weight: w, italic: true });
+  }
+  const pending = [];
+  for (const w of wanted) {
+    const key = cacheKey(opts.family, w.weight, w.italic);
+    const mem = opts.memoryCache?.get(key);
+    if (mem) {
+      sources.push({
+        data: mem,
+        weight: w.weight,
+        italic: w.italic,
+        format: detectFontFormat(mem)
+      });
+      continue;
+    }
+    const disk = await opts.diskCache?.get(key);
+    if (disk) {
+      opts.memoryCache?.set(key, disk);
+      sources.push({
+        data: disk,
+        weight: w.weight,
+        italic: w.italic,
+        format: detectFontFormat(disk)
+      });
+      continue;
+    }
+    pending.push(w);
+  }
+  if (pending.length === 0) {
+    return { sources, warnings };
+  }
+  const needItalics = pending.some((p) => p.italic);
+  const cssUrl = buildCssUrl(
+    opts.family,
+    Array.from(new Set(pending.map((p) => p.weight))),
+    needItalics
+  );
+  let faces;
+  try {
+    const cssRes = await fetchWithTimeout(cssUrl, {
+      headers: { "User-Agent": TTF_UA },
+      timeoutMs: opts.fetchTimeoutMs,
+      fetcher: opts.fetcher
+    });
+    if (!cssRes.ok) {
+      warnings.push(
+        `Google Fonts CSS fetch for "${opts.family}" returned ${cssRes.status}`
+      );
+      return { sources, warnings };
+    }
+    const css = await cssRes.text();
+    faces = parseCssFaces(css);
+  } catch (err) {
+    warnings.push(
+      `Google Fonts CSS fetch for "${opts.family}" failed: ${err.message}`
+    );
+    return { sources, warnings };
+  }
+  for (const need of pending) {
+    const match = faces.find(
+      (f) => f.weight === need.weight && f.italic === need.italic
+    );
+    if (!match) {
+      warnings.push(
+        `Google Fonts "${opts.family}" missing weight ${need.weight}${need.italic ? " italic" : ""}`
+      );
+      continue;
+    }
+    try {
+      const res = await fetchWithTimeout(match.ttfUrl, {
+        timeoutMs: opts.fetchTimeoutMs,
+        fetcher: opts.fetcher
+      });
+      if (!res.ok) {
+        warnings.push(
+          `Google Fonts TTF fetch for "${opts.family}" ${need.weight} returned ${res.status}`
+        );
+        continue;
+      }
+      const ab = await res.arrayBuffer();
+      const buf = Buffer.from(ab);
+      const key = cacheKey(opts.family, need.weight, need.italic);
+      opts.memoryCache?.set(key, buf);
+      await opts.diskCache?.set(key, buf);
+      sources.push({
+        data: buf,
+        weight: need.weight,
+        italic: need.italic,
+        format: detectFontFormat(buf)
+      });
+    } catch (err) {
+      warnings.push(
+        `Google Fonts TTF fetch for "${opts.family}" ${need.weight} failed: ${err.message}`
+      );
+    }
+  }
+  return { sources, warnings };
+}
+
+// src/fonts/sources/url-fetcher.ts
+function cacheKey2(url, weight, italic) {
+  return `url|${url}|${weight}|${italic ? "i" : "r"}`;
+}
+async function fetchUrlFontSource(opts) {
+  if (!isAllowedFontUrl(opts.url)) {
+    return {
+      warnings: [
+        `URL font fetch rejected (host not in allowlist or non-HTTPS): ${opts.url}`
+      ]
+    };
+  }
+  const key = cacheKey2(opts.url, opts.weight, opts.italic);
+  const mem = opts.memoryCache?.get(key);
+  if (mem) {
+    return {
+      source: {
+        data: mem,
+        weight: opts.weight,
+        italic: opts.italic,
+        format: detectFontFormat(mem)
+      },
+      warnings: []
+    };
+  }
+  const disk = await opts.diskCache?.get(key);
+  if (disk) {
+    opts.memoryCache?.set(key, disk);
+    return {
+      source: {
+        data: disk,
+        weight: opts.weight,
+        italic: opts.italic,
+        format: detectFontFormat(disk)
+      },
+      warnings: []
+    };
+  }
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), opts.fetchTimeoutMs ?? 1e4);
+  try {
+    const f = opts.fetcher ?? fetch;
+    let res = await f(opts.url, { signal: ctrl.signal, redirect: "manual" });
+    let hops = 0;
+    while (res.status >= 300 && res.status < 400 && res.status !== 304) {
+      const next = res.headers.get("location");
+      if (!next) {
+        return {
+          warnings: [
+            `URL font fetch "${opts.url}" ${res.status} with no Location header`
+          ]
+        };
+      }
+      const resolved = new URL(next, opts.url).toString();
+      if (!isAllowedFontUrl(resolved)) {
+        return {
+          warnings: [
+            `URL font fetch "${opts.url}" redirected to disallowed host: ${resolved}`
+          ]
+        };
+      }
+      if (++hops > 3) {
+        return {
+          warnings: [`URL font fetch "${opts.url}" too many redirects`]
+        };
+      }
+      res = await f(resolved, { signal: ctrl.signal, redirect: "manual" });
+    }
+    if (!res.ok) {
+      return {
+        warnings: [`URL font fetch "${opts.url}" returned ${res.status}`]
+      };
+    }
+    const ab = await res.arrayBuffer();
+    const raw = Buffer.from(ab);
+    const format = detectFontFormat(raw);
+    if (format === "unknown" || raw.length < 512) {
+      return {
+        warnings: [
+          `URL font fetch "${opts.url}" returned ${raw.length} bytes of ${format} \u2014 not a TTF/OTF. Skipping.`
+        ]
+      };
+    }
+    const buf = raw;
+    opts.memoryCache?.set(key, buf);
+    await opts.diskCache?.set(key, buf);
+    return {
+      source: {
+        data: buf,
+        weight: opts.weight,
+        italic: opts.italic,
+        format
+      },
+      warnings: []
+    };
+  } catch (err) {
+    return {
+      warnings: [
+        `URL font fetch "${opts.url}" failed: ${err.message}`
+      ]
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/fonts/sources/ttf-validate.ts
+var HEADER_SIZE = 12;
+var TABLE_RECORD_SIZE = 16;
+function readTable(ttf, tag) {
+  if (ttf.length < HEADER_SIZE) return null;
+  const version = ttf.readUInt32BE(0);
+  if (version !== 65536 && version !== 1330926671) return null;
+  const numTables = ttf.readUInt16BE(4);
+  for (let i = 0; i < numTables; i++) {
+    const r = HEADER_SIZE + i * TABLE_RECORD_SIZE;
+    if (r + TABLE_RECORD_SIZE > ttf.length) return null;
+    if (ttf.toString("ascii", r, r + 4) === tag) {
+      return { off: ttf.readUInt32BE(r + 8), len: ttf.readUInt32BE(r + 12) };
+    }
+  }
+  return null;
+}
+function readUsWeightClass(ttf) {
+  const os2 = readTable(ttf, "OS/2");
+  if (!os2) return null;
+  if (os2.off + 6 > ttf.length) return null;
+  return ttf.readUInt16BE(os2.off + 4);
+}
+function readNames(ttf, wanted) {
+  const nt = readTable(ttf, "name");
+  if (!nt) return [];
+  const tableOff = nt.off;
+  if (tableOff + 6 > ttf.length) return [];
+  const count = ttf.readUInt16BE(tableOff + 2);
+  const storageRel = ttf.readUInt16BE(tableOff + 4);
+  const storage = tableOff + storageRel;
+  const out = [];
+  for (let j = 0; j < count; j++) {
+    const r = tableOff + 6 + j * 12;
+    if (r + 12 > ttf.length) break;
+    const platformID = ttf.readUInt16BE(r);
+    const nameID = ttf.readUInt16BE(r + 6);
+    if (!wanted.has(nameID)) continue;
+    const length = ttf.readUInt16BE(r + 8);
+    const offset = ttf.readUInt16BE(r + 10);
+    const raw = ttf.slice(storage + offset, storage + offset + length);
+    let value;
+    if (platformID === 1) {
+      value = raw.toString("ascii");
+    } else {
+      const swapped = Buffer.from(raw);
+      if (swapped.length % 2 === 0) swapped.swap16();
+      value = swapped.toString("utf16le");
+    }
+    out.push({ platformID, nameID, value });
+  }
+  return out;
+}
+var STANDARD_SUBFAMILY = {
+  100: "Thin",
+  200: "ExtraLight",
+  300: "Light",
+  400: "Regular",
+  500: "Medium",
+  600: "SemiBold",
+  700: "Bold",
+  800: "ExtraBold",
+  900: "Black"
+};
+function validateFontMetadata(ttf, weight, italic, familyLabel) {
+  const diags = [];
+  const usWeight = readUsWeightClass(ttf);
+  if (usWeight != null && usWeight !== weight) {
+    diags.push({
+      code: "WEIGHT_CLASS_MISMATCH",
+      message: `Font "${familyLabel}" weight ${weight}: OS/2.usWeightClass reports ${usWeight}. Likely a defective redistribution \u2014 consider adding an upstream override.`
+    });
+  }
+  const subfamily = STANDARD_SUBFAMILY[weight];
+  if (!subfamily) return diags;
+  const expected17 = italic ? `${subfamily} Italic` : subfamily;
+  const expected2 = weight >= 600 ? italic ? "Bold Italic" : "Bold" : italic ? "Italic" : "Regular";
+  const names = readNames(ttf, /* @__PURE__ */ new Set([2, 17]));
+  for (const n of names) {
+    if (n.nameID === 17 && n.value !== expected17) {
+      diags.push({
+        code: "SUBFAMILY_MISMATCH",
+        message: `Font "${familyLabel}" weight ${weight}${italic ? " italic" : ""}: name record (platform ${n.platformID}) nameID 17 = "${n.value}", expected "${expected17}".`
+      });
+    }
+    if (n.nameID === 2 && n.value !== expected2) {
+      diags.push({
+        code: "LEGACY_SUBFAMILY_MISMATCH",
+        message: `Font "${familyLabel}" weight ${weight}${italic ? " italic" : ""}: name record (platform ${n.platformID}) nameID 2 = "${n.value}", expected "${expected2}".`
+      });
+    }
+  }
+  return diags;
+}
+
+// src/fonts/cache/memory-cache.ts
+var FontMemoryCache = class {
+  store = /* @__PURE__ */ new Map();
+  bytes = 0;
+  maxBytes;
+  constructor(opts = {}) {
+    this.maxBytes = opts.maxBytes ?? 20 * 1024 * 1024;
+  }
+  get(key) {
+    const v = this.store.get(key);
+    if (!v) return void 0;
+    this.store.delete(key);
+    this.store.set(key, v);
+    return v;
+  }
+  set(key, value) {
+    const existing = this.store.get(key);
+    if (existing) this.bytes -= existing.byteLength;
+    this.store.set(key, value);
+    this.bytes += value.byteLength;
+    while (this.bytes > this.maxBytes && this.store.size > 0) {
+      const oldest = this.store.keys().next().value;
+      if (!oldest) break;
+      const removed = this.store.get(oldest);
+      this.store.delete(oldest);
+      if (removed) this.bytes -= removed.byteLength;
+    }
+  }
+  size() {
+    return this.store.size;
+  }
+};
+
+// src/fonts/registry.ts
+var FontRegistry = class {
+  index;
+  cache;
+  opts;
+  memoryCache;
+  diskCache;
+  fileLoader;
+  variableLoader;
+  constructor(input = {}) {
+    this.opts = input.opts ?? {};
+    this.index = /* @__PURE__ */ new Map();
+    this.cache = /* @__PURE__ */ new Map();
+    this.memoryCache = new FontMemoryCache();
+    this.diskCache = input.diskCache;
+    this.fileLoader = input.fileLoader;
+    this.variableLoader = input.variableLoader;
+    for (const e of this.opts.extraEntries ?? []) this.addEntry(e);
+  }
+  addEntry(entry) {
+    this.index.set(entry.family.toLowerCase(), entry);
+    this.index.set(entry.id.toLowerCase(), entry);
+  }
+  /** Resolve every referenced name in one pass. Order preserved. */
+  async resolveMany(names) {
+    const out = [];
+    for (const n of names) out.push(await this.resolve(n));
+    return out;
+  }
+  async resolve(name) {
+    const key = name.toLowerCase();
+    const cached = this.cache.get(key);
+    if (cached) return cached;
+    const entry = this.index.get(key);
+    let result;
+    if (entry) {
+      result = await this.materializeEntry(entry);
+    } else if (isSafeFont(name)) {
+      result = { family: name, sources: [], warnings: [] };
+    } else {
+      result = {
+        family: name,
+        sources: [],
+        warnings: [
+          `Font "${name}" is not registered and not in SAFE_FONTS; will rely on host fallback.`
+        ]
+      };
+    }
+    this.cache.set(key, result);
+    return result;
+  }
+  async materializeEntry(entry) {
+    const sources = [];
+    const warnings = [];
+    for (const source of entry.sources) {
+      try {
+        const materialized = await this.materializeSource(source, warnings);
+        for (const s of materialized) {
+          if (s.format === "ttf" || s.format === "otf") {
+            for (const d of validateFontMetadata(
+              s.data,
+              s.weight,
+              s.italic,
+              entry.family
+            )) {
+              warnings.push(`[FONT_METADATA_DEFECT:${d.code}] ${d.message}`);
+            }
+          }
+          sources.push(s);
+        }
+      } catch (err) {
+        warnings.push(
+          `Font "${entry.family}" source (${source.kind}) failed: ${err.message}`
+        );
+      }
+    }
+    return {
+      family: entry.family,
+      sources,
+      warnings
+    };
+  }
+  async materializeSource(source, warnings) {
+    switch (source.kind) {
+      case "safe":
+        return [];
+      case "file": {
+        if (!this.fileLoader) {
+          warnings.push(
+            `kind:"file" source for "${source.path}" requires a fileLoader (Node-only); skipping.`
+          );
+          return [];
+        }
+        return [
+          await this.fileLoader({
+            path: source.path,
+            weight: source.weight,
+            italic: source.italic,
+            baseDir: this.opts.baseDir
+          })
+        ];
+      }
+      case "data":
+        return [
+          loadDataFontSource({
+            data: source.data,
+            weight: source.weight,
+            italic: source.italic
+          })
+        ];
+      case "google": {
+        const gf = this.opts.googleFonts;
+        if (gf?.enabled === false) {
+          warnings.push(
+            `Google Fonts fetch disabled \u2014 skipping "${source.family}".`
+          );
+          return [];
+        }
+        const { sources: fetched, warnings: fetchWarnings } = await fetchGoogleFontSources({
+          family: source.family,
+          weights: source.weights ?? [400, 700],
+          italics: source.italics ?? false,
+          memoryCache: this.memoryCache,
+          diskCache: this.diskCache,
+          fetchTimeoutMs: gf?.fetchTimeoutMs
+        });
+        warnings.push(...fetchWarnings);
+        return fetched;
+      }
+      case "url": {
+        const gf = this.opts.googleFonts;
+        const { source: fetched, warnings: fetchWarnings } = await fetchUrlFontSource({
+          url: source.url,
+          weight: source.weight ?? 400,
+          italic: source.italic ?? false,
+          memoryCache: this.memoryCache,
+          diskCache: this.diskCache,
+          fetchTimeoutMs: gf?.fetchTimeoutMs
+        });
+        if (fetchWarnings) warnings.push(...fetchWarnings);
+        return fetched ? [fetched] : [];
+      }
+      case "variable": {
+        if (!this.variableLoader) {
+          warnings.push(
+            `kind:"variable" source for "${source.url}" requires a variableLoader (Node-only); skipping.`
+          );
+          return [];
+        }
+        const gf = this.opts.googleFonts;
+        const { source: fetched, warnings: fetchWarnings } = await this.variableLoader({
+          url: source.url,
+          weight: source.weight,
+          italic: source.italic ?? false,
+          axes: source.axes,
+          memoryCache: this.memoryCache,
+          diskCache: this.diskCache,
+          fetchTimeoutMs: gf?.fetchTimeoutMs
+        });
+        if (fetchWarnings) warnings.push(...fetchWarnings);
+        return fetched ? [fetched] : [];
+      }
+      default:
+        throw new Error(
+          `Unknown font source kind: ${source.kind}`
+        );
+    }
+  }
+};
+
+// src/fonts/catalog/popular-google.ts
+var POPULAR_GOOGLE_FONTS = [
+  // Sans-serif
+  {
+    family: "Inter",
+    category: "sans",
+    weights: [100, 200, 300, 400, 500, 600, 700, 800, 900],
+    hasItalic: false
+  },
+  {
+    family: "Roboto",
+    category: "sans",
+    weights: [100, 300, 400, 500, 700, 900],
+    hasItalic: true
+  },
+  {
+    family: "Open Sans",
+    category: "sans",
+    weights: [300, 400, 500, 600, 700, 800],
+    hasItalic: true
+  },
+  {
+    family: "Lato",
+    category: "sans",
+    weights: [100, 300, 400, 700, 900],
+    hasItalic: true
+  },
+  {
+    family: "Montserrat",
+    category: "sans",
+    weights: [100, 200, 300, 400, 500, 600, 700, 800, 900],
+    hasItalic: true
+  },
+  {
+    family: "Poppins",
+    category: "sans",
+    weights: [100, 200, 300, 400, 500, 600, 700, 800, 900],
+    hasItalic: true
+  },
+  {
+    family: "Work Sans",
+    category: "sans",
+    weights: [100, 200, 300, 400, 500, 600, 700, 800, 900],
+    hasItalic: true
+  },
+  {
+    family: "Nunito",
+    category: "sans",
+    weights: [200, 300, 400, 500, 600, 700, 800, 900],
+    hasItalic: true
+  },
+  {
+    family: "DM Sans",
+    category: "sans",
+    weights: [100, 200, 300, 400, 500, 600, 700, 800, 900],
+    hasItalic: true
+  },
+  {
+    family: "Rubik",
+    category: "sans",
+    weights: [300, 400, 500, 600, 700, 800, 900],
+    hasItalic: true
+  },
+  {
+    family: "Source Sans 3",
+    category: "sans",
+    weights: [200, 300, 400, 500, 600, 700, 800, 900],
+    hasItalic: true
+  },
+  {
+    family: "Manrope",
+    category: "sans",
+    weights: [200, 300, 400, 500, 600, 700, 800],
+    hasItalic: false
+  },
+  {
+    family: "Plus Jakarta Sans",
+    category: "sans",
+    weights: [200, 300, 400, 500, 600, 700, 800],
+    hasItalic: true
+  },
+  {
+    family: "IBM Plex Sans",
+    category: "sans",
+    weights: [100, 200, 300, 400, 500, 600, 700],
+    hasItalic: true
+  },
+  // Serif
+  {
+    family: "Playfair Display",
+    category: "serif",
+    weights: [400, 500, 600, 700, 800, 900],
+    hasItalic: true
+  },
+  {
+    family: "Merriweather",
+    category: "serif",
+    weights: [300, 400, 700, 900],
+    hasItalic: true
+  },
+  {
+    family: "Lora",
+    category: "serif",
+    weights: [400, 500, 600, 700],
+    hasItalic: true
+  },
+  {
+    family: "Source Serif 4",
+    category: "serif",
+    weights: [200, 300, 400, 500, 600, 700, 800, 900],
+    hasItalic: true
+  },
+  {
+    family: "DM Serif Display",
+    category: "serif",
+    weights: [400],
+    hasItalic: true
+  },
+  {
+    family: "Crimson Pro",
+    category: "serif",
+    weights: [200, 300, 400, 500, 600, 700, 800, 900],
+    hasItalic: true
+  },
+  {
+    family: "Cormorant Garamond",
+    category: "serif",
+    weights: [300, 400, 500, 600, 700],
+    hasItalic: true
+  },
+  // Monospace
+  {
+    family: "JetBrains Mono",
+    category: "mono",
+    weights: [100, 200, 300, 400, 500, 600, 700, 800],
+    hasItalic: true
+  },
+  {
+    family: "Fira Code",
+    category: "mono",
+    weights: [300, 400, 500, 600, 700],
+    hasItalic: false
+  },
+  {
+    family: "IBM Plex Mono",
+    category: "mono",
+    weights: [100, 200, 300, 400, 500, 600, 700],
+    hasItalic: true
+  },
+  {
+    family: "Source Code Pro",
+    category: "mono",
+    weights: [200, 300, 400, 500, 600, 700, 800, 900],
+    hasItalic: true
+  },
+  {
+    family: "Space Mono",
+    category: "mono",
+    weights: [400, 700],
+    hasItalic: true
+  },
+  // Display
+  {
+    family: "Bebas Neue",
+    category: "display",
+    weights: [400],
+    hasItalic: false
+  },
+  {
+    family: "Abril Fatface",
+    category: "display",
+    weights: [400],
+    hasItalic: false
+  },
+  {
+    family: "Archivo Black",
+    category: "display",
+    weights: [400],
+    hasItalic: false
+  },
+  {
+    family: "Oswald",
+    category: "display",
+    weights: [200, 300, 400, 500, 600, 700],
+    hasItalic: false
+  },
+  // Handwriting
+  {
+    family: "Caveat",
+    category: "handwriting",
+    weights: [400, 500, 600, 700],
+    hasItalic: false
+  },
+  {
+    family: "Pacifico",
+    category: "handwriting",
+    weights: [400],
+    hasItalic: false
+  }
+];
+
+// src/fonts/catalog/upstream-overrides.ts
+var INTER_VARIABLE_URL = "https://cdn.jsdelivr.net/gh/rsms/inter@v4.1/docs/font-files/InterVariable.ttf";
+var INTER_VARIABLE_ITALIC_URL = "https://cdn.jsdelivr.net/gh/rsms/inter@v4.1/docs/font-files/InterVariable-Italic.ttf";
+function interVariants() {
+  const weights = [100, 200, 300, 400, 500, 600, 700, 800, 900];
+  const upright = weights.map((weight) => ({
+    kind: "variable",
+    url: INTER_VARIABLE_URL,
+    weight,
+    italic: false
+  }));
+  const italic = weights.map((weight) => ({
+    kind: "variable",
+    url: INTER_VARIABLE_ITALIC_URL,
+    weight,
+    italic: true
+  }));
+  return [...upright, ...italic];
+}
+var UPSTREAM_OVERRIDES = {
+  inter: {
+    reason: "Google's static Inter Thin/ExtraLight both carry usWeightClass=250 and near-identical glyph outlines (xAvgCharWidth differs by 1.8%); instancing the upstream variable font per weight produces properly distinct statics.",
+    variants: interVariants()
+  }
+};
+function getUpstreamOverride(family) {
+  return UPSTREAM_OVERRIDES[family.toLowerCase()];
+}
+
+// src/fonts/substitute.ts
+function applyFontSubstitution(doc, mapping) {
+  const seen = /* @__PURE__ */ new Map();
+  const rewritten = rewrite(doc, mapping, seen);
+  const substitutions = [];
+  for (const [from, to] of seen) substitutions.push({ from, to });
+  return { doc: rewritten, substitutions };
+}
+function rewrite(node, mapping, seen, parentKey) {
+  if (node == null) return node;
+  if (typeof node === "string") {
+    if (parentKey && (FONT_NAME_KEYS.has(parentKey) || THEME_FONT_KEYS.has(parentKey))) {
+      return maybeSwap(node, mapping, seen);
+    }
+    return node;
+  }
+  if (Array.isArray(node)) {
+    return node.map((item) => rewrite(item, mapping, seen, parentKey));
+  }
+  if (typeof node === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(node)) {
+      if (parentKey === "theme" && k === "fonts" && v && typeof v === "object") {
+        const nextFonts = {};
+        for (const [fk, fv] of Object.entries(v)) {
+          if (typeof fv === "string") {
+            nextFonts[fk] = maybeSwap(fv, mapping, seen);
+          } else if (fv && typeof fv === "object") {
+            const fam = fv.family;
+            nextFonts[fk] = typeof fam === "string" ? { ...fv, family: maybeSwap(fam, mapping, seen) } : rewrite(fv, mapping, seen, fk);
+          } else {
+            nextFonts[fk] = fv;
+          }
+        }
+        out[k] = nextFonts;
+        continue;
+      }
+      out[k] = rewrite(v, mapping, seen, k);
+    }
+    return out;
+  }
+  return node;
+}
+function maybeSwap(name, mapping, seen) {
+  const trimmed = name.trim();
+  if (trimmed.length === 0) return name;
+  if (isSafeFont(trimmed)) return name;
+  const lowered = trimmed.toLowerCase();
+  for (const [from, to] of Object.entries(mapping)) {
+    if (from.toLowerCase() === lowered) {
+      seen.set(trimmed, to);
+      return to;
+    }
+  }
+  return name;
+}
+var EXPLICIT_OVERRIDES = {
+  Inter: "Calibri",
+  Roboto: "Calibri",
+  "Open Sans": "Calibri",
+  Lato: "Calibri",
+  "Source Sans 3": "Calibri",
+  "Source Sans Pro": "Calibri",
+  "IBM Plex Sans": "Calibri",
+  "Work Sans": "Calibri",
+  Manrope: "Calibri",
+  Nunito: "Calibri",
+  "Nunito Sans": "Calibri",
+  Poppins: "Calibri",
+  Montserrat: "Calibri",
+  "Playfair Display": "Georgia",
+  Merriweather: "Georgia",
+  "Source Serif 4": "Cambria",
+  "Source Serif Pro": "Cambria",
+  "IBM Plex Serif": "Cambria",
+  "Crimson Pro": "Cambria",
+  Lora: "Georgia",
+  "PT Serif": "Georgia",
+  "Cormorant Garamond": "Cambria",
+  "JetBrains Mono": "Consolas",
+  "Fira Code": "Consolas",
+  "IBM Plex Mono": "Consolas",
+  "Source Code Pro": "Consolas",
+  "Roboto Mono": "Consolas"
+};
+var CATEGORY_FALLBACK = {
+  sans: "Calibri",
+  serif: "Georgia",
+  mono: "Consolas",
+  display: "Georgia",
+  handwriting: "Segoe UI"
+};
+function defaultSubstituteFor(family) {
+  const trimmed = family.trim();
+  for (const [from, to] of Object.entries(EXPLICIT_OVERRIDES)) {
+    if (from.toLowerCase() === trimmed.toLowerCase()) return to;
+  }
+  const catalog = POPULAR_GOOGLE_FONTS.find(
+    (f) => f.family.toLowerCase() === trimmed.toLowerCase()
+  );
+  if (catalog) {
+    const cat = CATEGORY_FALLBACK[catalog.category];
+    if (cat) return cat;
+  }
+  return "Calibri";
+}
+function buildDefaultSubstitutionMap(referencedNames) {
+  const out = {};
+  for (const raw of referencedNames) {
+    const name = raw.trim();
+    if (name.length === 0) continue;
+    if (isSafeFont(name)) continue;
+    if (out[name]) continue;
+    out[name] = defaultSubstituteFor(name);
+  }
+  return out;
+}
+function scopedThemeName(baseThemeName, fontMode) {
+  return fontMode === "substitute" ? `${baseThemeName}#substitute` : baseThemeName;
+}
+function applyExportMode(input) {
+  const mode = input.fonts?.mode ?? "custom";
+  if (mode === "custom") {
+    if (!input.fonts) {
+      return { doc: input.doc, theme: input.theme, warnings: [] };
+    }
+    const referenced2 = /* @__PURE__ */ new Set([
+      ...collectFontNames(input.doc),
+      ...collectFontNames(input.theme)
+    ]);
+    const nonSafe = [...referenced2].filter((name) => !isSafeFont(name.trim()));
+    const warnings2 = nonSafe.length > 0 ? [
+      {
+        code: "FONT_MODE_CUSTOM",
+        message: `Export mode "custom": non-safe font references (${nonSafe.join(", ")}) kept as-is. Recipients need these fonts installed locally; Word falls back to a generic substitute otherwise.`
+      }
+    ] : [];
+    return {
+      doc: input.doc,
+      theme: input.theme,
+      warnings: warnings2
+    };
+  }
+  const referenced = /* @__PURE__ */ new Set([
+    ...collectFontNames(input.doc),
+    ...collectFontNames(input.theme)
+  ]);
+  const defaults = buildDefaultSubstitutionMap(referenced);
+  const mapping = {
+    ...defaults,
+    ...input.fonts?.substitution ?? {}
+  };
+  const docRewrite = applyFontSubstitution(input.doc, mapping);
+  const themeRewrite = applyFontSubstitution(input.theme, mapping);
+  const combined = /* @__PURE__ */ new Map();
+  for (const s of docRewrite.substitutions) combined.set(s.from, s.to);
+  for (const s of themeRewrite.substitutions) combined.set(s.from, s.to);
+  const warnings = [];
+  if (combined.size > 0) {
+    const list = [...combined].map(([from, to]) => `${from} \u2192 ${to}`).join(", ");
+    warnings.push({
+      code: "FONT_MODE_SUBSTITUTED",
+      message: `Export mode "substitute": rewrote non-safe families to safe equivalents \u2014 ${list}. No fonts embedded; document renders identically on every machine.`
+    });
+  }
+  return {
+    doc: docRewrite.doc,
+    theme: themeRewrite.doc,
+    warnings
+  };
+}
+
+// src/utils/deepMerge.ts
+function isObject(item) {
+  return item !== null && typeof item === "object" && !Array.isArray(item);
+}
+function deepMerge(target, source) {
+  const output = { ...target };
+  if (isObject(target) && isObject(source)) {
+    Object.keys(source).forEach((key) => {
+      if (isObject(source[key])) {
+        if (!(key in target)) {
+          output[key] = source[key];
+        } else {
+          output[key] = deepMerge(target[key], source[key]);
+        }
+      } else {
+        output[key] = source[key];
+      }
+    });
+  }
+  return output;
+}
+function mergeWithDefaults(userConfig, themeDefaults) {
+  return deepMerge(themeDefaults, userConfig);
+}
 export {
   ComponentValidationError,
   DEFAULT_ERROR_CONFIG,
   DuplicateComponentError,
   ERROR_EMOJIS,
+  FontFamilyNameSchema,
+  FontRegistry,
+  FontRegistryEntrySchema,
+  FontRegistrySchema,
+  FontSourceSchema,
+  POPULAR_GOOGLE_FONTS,
+  SAFE_FONTS,
+  UPSTREAM_OVERRIDES,
+  WEIGHT_LABELS,
+  applyExportMode,
+  applyFontSubstitution,
+  buildDefaultSubstitutionMap,
   calculatePosition,
   clearComponentNamesCache,
+  collectFontNamesFromDocx,
+  collectFontNamesFromPptx,
   compareSemver,
   convertToJsonSchema,
   createComponent,
@@ -56,26 +1558,36 @@ export {
   createErrorConfig,
   createJsonParseError,
   createVersion,
+  defaultSubstituteFor,
+  detectFontFormat,
   exportSchemaToFile,
   extractStandardComponentNames,
+  fetchGoogleFontSources,
   fixSchemaReferences,
   formatErrorMessage,
   formatErrorSummary,
   getLiteralValue,
   getObjectSchemaPropertyNames,
   getSchemaMetadata,
+  getUpstreamOverride,
   getValidationSummary,
   groupErrorsByPath,
   isLiteralSchema,
   isObjectSchema,
+  isSafeFont,
   isUnionSchema,
   isValidSemver,
   isValidationSuccess,
   latestVersion,
+  mergeWithDefaults,
   parseSemver,
   resolveComponentVersion,
+  rewriteFontFamilyName,
+  scopedThemeName,
+  synthesizeFamilyName,
   transformValueError,
   transformValueErrors,
-  validateCustomComponentProps
+  validateCustomComponentProps,
+  validateFontReferences
 };
 //# sourceMappingURL=index.js.map