animl-cli 0.0.0-stage → 0.1.0

package/packages/cli/src/font/browser.js

@@ -0,0 +1,54 @@
+import { ImageEncoder } from "../encode.js";
+import { sfnt, fault } from "./binary.js";
+async function browserTextPNG(svg, measurer) {
+  const session = new ImageEncoder();
+  try {
+    const browser = await session.browser(), page = await browser.newPage();
+    try {
+      const fonts = [...measurer.fonts].flatMap(
+        ([family, entries]) => entries.map(({ font, weight, style }) => ({
+          family,
+          weight: font.axes.some((a) => a.tag === "wght") ? font.axes.filter((a) => a.tag === "wght").map((a) => `${a.min} ${a.max}`)[0] : String(weight),
+          style,
+          source: "data:font/" + (font.flavor === 1330926671 ? "otf" : "ttf") + ";base64," + sfnt(font.tables, font.flavor).toString("base64")
+        }))
+      );
+      await page.setContent(
+        "<!doctype html><style>html,body{margin:0;background:transparent}svg{display:block}</style>" + svg
+      );
+      await page.evaluate(async (fonts2) => {
+        for (const f of fonts2) {
+          const face = new FontFace(f.family, `url("${f.source}")`, {
+            weight: String(f.weight),
+            style: f.style
+          });
+          document.fonts.add(await face.load());
+        }
+        await document.fonts.ready;
+      }, fonts);
+      return await page.locator("svg").first().screenshot({ omitBackground: true });
+    } finally {
+      await page.close();
+    }
+  } catch (error) {
+    if (error instanceof Error && "code" in error) throw error;
+    fault(
+      "cannot render browser text: " + (error instanceof Error ? error.message : "browser failure"),
+      "font-invalid"
+    );
+  } finally {
+    await session.close();
+  }
+}
+function embedFontCSS(svg, measurer) {
+  const css = [...measurer.fonts].flatMap(
+    ([family, entries]) => entries.map(
+      ({ font, weight, style }) => `@font-face{font-family:${JSON.stringify(family).replaceAll("<", "\\3c ")};font-weight:${font.axes.find((a) => a.tag === "wght") ? `${font.axes.find((a) => a.tag === "wght").min} ${font.axes.find((a) => a.tag === "wght").max}` : weight};font-style:${style};src:url(data:font/${font.flavor === 1330926671 ? "otf" : "ttf"};base64,${sfnt(font.tables, font.flavor).toString("base64")})}`
+    )
+  ).join("");
+  return svg.replace(/(<svg\b[^>]*>)/, (_match, root) => `${root}<style>${css}</style>`);
+}
+export {
+  browserTextPNG,
+  embedFontCSS
+};

package/packages/cli/src/font/cff.d.ts

@@ -0,0 +1,6 @@
+import type { Font } from './reader.js';
+export { cffOutline } from 'animl/internal/modules/fonts/core/opentype/cff.js';
+/** CFF1 subsetting with stable glyph IDs. Rebuild offset-bearing dictionaries and INDEXes;
+ * preserve charset/encoding/FDSelect and local/global subroutines byte-for-byte.
+ */
+export declare function subsetCFF(font: Font, keep: ReadonlySet<number>): Buffer;

package/packages/cli/src/font/cff.js

@@ -0,0 +1,154 @@
+import { fault, MAX_FONT } from "./binary.js";
+import { index, dict, cffOutline } from "animl/internal/modules/fonts/core/opentype/cff.js";
+import { cffOutline as cffOutline2 } from "animl/internal/modules/fonts/core/opentype/cff.js";
+function subsetCFF(font, keep) {
+  const b = font.table("CFF "), names = index(b, b.u8(2)), topStart = names.end, top = index(b, topStart);
+  if (b.u8(0) !== 1 || top.items.length !== 1)
+    fault("subsetting requires a single CFF1 font", "font-unsupported");
+  const info = dict(top.items[0]), charStart = info.get(17)?.[0] ?? fault("missing CFF CharStrings"), chars = index(b, charStart);
+  if (chars.items.length !== font.glyphCount) fault("CFF CharStrings count mismatch");
+  if (keep.size === font.glyphCount) return Buffer.from(b.data);
+  const budget = { remaining: 4e6 };
+  for (const glyph of keep) cffOutline(font, glyph, 1, 0, 0, budget);
+  const makeIndex = (items) => {
+    if (!items.length) return Buffer.alloc(2);
+    if (3 + 4 * (items.length + 1) + items.reduce((sum, item) => sum + item.length, 0) > MAX_FONT)
+      fault("CFF INDEX size limit", "font-limit");
+    const h = Buffer.alloc(3 + 4 * (items.length + 1));
+    h.writeUInt16BE(items.length);
+    h[2] = 4;
+    let offset = 1;
+    items.forEach((item, i) => {
+      h.writeUInt32BE(offset, 3 + i * 4);
+      offset += item.length;
+    });
+    h.writeUInt32BE(offset, 3 + items.length * 4);
+    return Buffer.concat([h, ...items]);
+  };
+  const encodeNumber = (n) => {
+    if (Number.isInteger(n) && n >= -2147483648 && n <= 2147483647) {
+      const out = Buffer.alloc(5);
+      out[0] = 29;
+      out.writeInt32BE(n, 1);
+      return out;
+    }
+    if (!Number.isFinite(n)) fault("nonfinite CFF dictionary value");
+    const digits = [];
+    const text = String(n).toLowerCase();
+    for (let i = 0; i < text.length; i++) {
+      const c = text[i];
+      if (c === "e") {
+        if (text[i + 1] === "-") {
+          digits.push(12);
+          i++;
+        } else {
+          digits.push(11);
+          if (text[i + 1] === "+") i++;
+        }
+      } else digits.push(c === "." ? 10 : c === "-" ? 14 : Number(c));
+    }
+    digits.push(15);
+    if (digits.length & 1) digits.push(15);
+    return Buffer.from([
+      30,
+      ...Array.from(
+        { length: digits.length / 2 },
+        (_, i) => digits[i * 2] * 16 + digits[i * 2 + 1]
+      )
+    ]);
+  };
+  const encodeDict = (d) => Buffer.concat(
+    [...d].flatMap(([op, values]) => [
+      ...values.map(encodeNumber),
+      Buffer.from(op >= 1200 ? [12, op - 1200] : [op])
+    ])
+  );
+  const patches = [], privates = /* @__PURE__ */ new Map();
+  let relocating = false;
+  const relocate = (p2) => {
+    if (!relocating) return p2;
+    b.check(p2, 0);
+    let delta = 0;
+    for (const patch of patches) {
+      if (p2 > patch.start && p2 < patch.end) fault("CFF offset points inside a rewritten structure");
+      if (patch.end <= p2) delta += patch.bytes.length - (patch.end - patch.start);
+    }
+    return p2 + delta;
+  };
+  const registerPrivate = (entry) => {
+    if (!entry) return;
+    const [size, start] = entry;
+    if (size === void 0 || start === void 0) fault("invalid CFF Private entry");
+    const prior = privates.get(start);
+    if (prior) {
+      if (prior.size !== size) fault("conflicting CFF private dictionary ranges");
+      return;
+    }
+    const values = dict(b.slice(start, size)), patch = { start, end: start + size, bytes: Buffer.alloc(0) };
+    const write = () => {
+      const result = new Map(values);
+      const subrs = values.get(19);
+      if (subrs) result.set(19, [relocate(start + subrs[0]) - relocate(start)]);
+      return encodeDict(result);
+    };
+    patch.write = write;
+    patch.bytes = write();
+    privates.set(start, { size, patch, values });
+    patches.push(patch);
+  };
+  registerPrivate(info.get(18));
+  const rewritePrivate = (d) => {
+    const result = new Map(d), entry = d.get(18);
+    if (entry) {
+      const privateDict = privates.get(entry[1]) ?? fault("missing CFF private dictionary");
+      result.set(18, [privateDict.patch.bytes.length, relocate(entry[1])]);
+    }
+    return result;
+  };
+  const fdStart = info.get(1236)?.[0];
+  if (fdStart !== void 0) {
+    const fds = index(b, fdStart), dicts = fds.items.map(dict);
+    dicts.forEach((d) => registerPrivate(d.get(18)));
+    const write = () => makeIndex(dicts.map((d) => encodeDict(rewritePrivate(d))));
+    patches.push({ start: fdStart, end: fds.end, bytes: write(), write });
+  }
+  const writeTop = () => {
+    const result = rewritePrivate(info);
+    for (const op of [15, 16, 17, 1236, 1237]) {
+      const entry = result.get(op);
+      if (entry && !(op === 15 && entry[0] <= 2) && !(op === 16 && entry[0] <= 1))
+        result.set(op, [relocate(entry[0])]);
+    }
+    return makeIndex([encodeDict(result)]);
+  };
+  patches.push({ start: topStart, end: top.end, bytes: writeTop(), write: writeTop });
+  patches.push({
+    start: charStart,
+    end: chars.end,
+    bytes: makeIndex(chars.items.map((raw, id) => keep.has(id) ? raw : Buffer.from([14])))
+  });
+  patches.sort((a, c) => a.start - c.start);
+  for (let i = 1; i < patches.length; i++)
+    if (patches[i].start < patches[i - 1].end) fault("overlapping CFF structures");
+  relocating = true;
+  for (const patch of patches)
+    if (patch.write) {
+      const rewritten = patch.write();
+      if (rewritten.length !== patch.bytes.length) fault("unstable CFF relocation size");
+      patch.bytes = rewritten;
+    }
+  const chunks = [];
+  let p = 0;
+  for (const patch of patches) {
+    chunks.push(b.slice(p, patch.start - p), patch.bytes);
+    p = patch.end;
+  }
+  chunks.push(b.slice(p, b.data.length - p));
+  if (chunks.reduce((sum, chunk) => sum + chunk.length, 0) > MAX_FONT)
+    fault("CFF subset size limit", "font-limit");
+  return Buffer.concat(chunks);
+}
+export {
+  cffOutline2 as cffOutline,
+  subsetCFF
+};

package/packages/cli/src/font/container.d.ts

@@ -0,0 +1,5 @@
+export declare function unpack(input: Uint8Array): {
+    tables: Map<string, Buffer>;
+    flavor: number;
+};
+export declare function normalizeFont(bytes: Uint8Array): Buffer;

package/packages/cli/src/font/container.js

@@ -0,0 +1,97 @@
+import { inflateSync, brotliDecompressSync } from "node:zlib";
+import { restoreGlyf, restoreHmtx } from "./woff2.js";
+import { Bytes, fault, MAX_FONT, sfnt } from "./binary.js";
+const TAGS = "cmap head hhea hmtx maxp name OS/2 post cvt_ fpgm glyf loca prep CFF_ VORG EBDT EBLC gasp hdmx kern LTSH PCLT VDMX vhea vmtx BASE GDEF GPOS GSUB EBSC JSTF MATH CBDT CBLC COLR CPAL SVG_ sbix acnt avar bdat bloc bsln cvar fdsc feat fmtx fvar gvar hsty just lcar mort morx opbd prop trak Zapf Silf Glat Gloc Feat Sill".split(" ").map((t) => t.replaceAll("_", " "));
+function unpack(input) {
+  if (input.length > MAX_FONT) fault("font exceeds the 32 MiB tool limit", "font-limit");
+  const b = new Bytes(Buffer.from(input)), tag = b.tag(0);
+  const tables = /* @__PURE__ */ new Map();
+  const put = (tag2, bytes) => {
+    if (tables.has(tag2)) fault("duplicate font table " + tag2);
+    tables.set(tag2, bytes);
+  };
+  if (tag === "wOFF") {
+    if (b.u32(8) !== input.length || b.u32(16) > MAX_FONT) fault("invalid WOFF length");
+    const n2 = b.u16(12);
+    if (n2 > 256) fault("too many font tables", "font-limit");
+    let total2 = 0;
+    for (let i = 0; i < n2; i++) {
+      const p = 44 + i * 20, len = b.u32(p + 12), compressed = b.u32(p + 8);
+      total2 += len;
+      if (total2 > MAX_FONT) fault("WOFF exceeds decompression limit", "font-limit");
+      if (compressed > len || len > MAX_FONT) fault("invalid WOFF table length");
+      const bytes = b.slice(b.u32(p + 4), compressed);
+      const data = compressed === len ? bytes : inflateSync(bytes, { maxOutputLength: len });
+      if (data.length !== len) fault("WOFF decompressed length mismatch");
+      put(b.tag(p), data);
+    }
+    return { tables, flavor: b.u32(4) };
+  }
+  if (tag === "wOF2") {
+    if (b.u32(8) !== input.length || b.u32(16) > MAX_FONT) fault("invalid WOFF2 length");
+    const n2 = b.u16(12);
+    if (n2 > 256) fault("too many font tables", "font-limit");
+    let pos = 48;
+    const base128 = () => {
+      let v = 0;
+      for (let i = 0; i < 5; i++) {
+        const x = b.u8(pos++);
+        if (!i && x === 128 || v > 33554431) fault("invalid WOFF2 UIntBase128");
+        v = v * 128 + (x & 127);
+        if (!(x & 128)) return v;
+      }
+      return fault("invalid WOFF2 UIntBase128");
+    };
+    const entries = [];
+    let total2 = 0;
+    for (let i = 0; i < n2; i++) {
+      const flags = b.u8(pos++), tag2 = (flags & 63) === 63 ? (pos += 4, b.tag(pos - 4)) : TAGS[flags & 63];
+      const len = base128(), version = flags >> 6, transformed = tag2 === "glyf" || tag2 === "loca" ? version !== 3 : version !== 0;
+      const stored = transformed ? base128() : len;
+      total2 += stored;
+      if (total2 > MAX_FONT) fault("WOFF2 exceeds decompression limit", "font-limit");
+      entries.push({ tag: tag2, len, stored, transform: transformed ? version + 1 : 0 });
+    }
+    const data = brotliDecompressSync(b.slice(pos, b.u32(20)), {
+      maxOutputLength: Math.max(1, total2)
+    });
+    if (data.length !== total2) fault("WOFF2 decompressed length mismatch");
+    let p = 0;
+    for (const entry of entries) {
+      put(entry.tag, data.subarray(p, p + entry.stored));
+      p += entry.stored;
+    }
+    for (const e of entries)
+      if (e.transform && !((e.tag === "glyf" || e.tag === "loca") && e.transform === 1 || e.tag === "hmtx" && e.transform === 2))
+        fault("unsupported WOFF2 transform", "font-unsupported");
+    const glyf = entries.find((e) => e.tag === "glyf"), loca = entries.find((e) => e.tag === "loca");
+    if (!!glyf?.transform !== !!loca?.transform) fault("WOFF2 glyf/loca transform mismatch");
+    if (glyf?.transform) {
+      if (loca.stored !== 0) fault("transformed loca must be empty");
+      restoreGlyf(tables, loca.len);
+    }
+    if (entries.some((e) => e.tag === "hmtx" && e.transform)) restoreHmtx(tables);
+    return { tables, flavor: b.u32(4) };
+  }
+  const flavor = b.u32(0);
+  if (flavor !== 65536 && tag !== "OTTO" && tag !== "true")
+    fault("expected TTF, OTF, WOFF or WOFF2", "font-format");
+  const n = b.u16(4);
+  if (!n || n > 256) fault("invalid sfnt table count");
+  let total = 0;
+  for (let i = 0; i < n; i++) {
+    const p = 12 + i * 16;
+    if ((total += b.u32(p + 12)) > MAX_FONT)
+      fault("font tables exceed the 32 MiB tool limit", "font-limit");
+    put(b.tag(p), b.slice(b.u32(p + 8), b.u32(p + 12)));
+  }
+  return { tables, flavor };
+}
+function normalizeFont(bytes) {
+  const { tables, flavor } = unpack(bytes);
+  return sfnt(tables, flavor);
+}
+export {
+  normalizeFont,
+  unpack
+};

package/packages/cli/src/font/document.d.ts

@@ -0,0 +1,28 @@
+import type { Diagnostic } from 'animl';
+import { ToolMeasurer } from './measure.js';
+export interface FontAsset {
+    type: string;
+    source: string;
+    family?: string;
+    weight?: number;
+    style?: 'normal' | 'italic';
+    glyphs?: 'used' | 'all' | 'custom';
+    chars?: string;
+    mime?: string;
+    size?: number;
+    storage?: string;
+    export?: boolean;
+}
+export interface FontDocument {
+    assets?: Record<string, FontAsset>;
+    components?: Record<string, FontDocument>;
+}
+export declare function fontBytes(source: string, file: string): Buffer;
+export declare function documentCharacters(doc: unknown): string;
+export declare function documentFonts(doc: FontDocument, file: string, overrides?: readonly string[], sourceFile?: (pointer: string) => string): {
+    measurer: ToolMeasurer;
+    diagnostics: Diagnostic[];
+};
+/** Optional runtime seam. Does not import the text module into core or web. */
+export declare function installToolMeasurer(measurer: ToolMeasurer): Promise<void>;
+export declare function buildFont(asset: FontAsset, doc: FontDocument, file: string): void;

package/packages/cli/src/font/document.js

@@ -0,0 +1,143 @@
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { diagnostic, fault } from "./binary.js";
+import { Font } from "./reader.js";
+import { ToolMeasurer, shapingDiagnostic } from "./measure.js";
+import { subsetFont } from "./subset.js";
+import { featureTags } from "./features.js";
+const escape = (s) => s.replaceAll("~", "~0").replaceAll("/", "~1");
+function fontBytes(source, file) {
+  const url = new URL(source, pathToFileURL(resolve(file)));
+  if (url.protocol === "data:") {
+    const match = /^data:[^,]*;base64,([A-Za-z0-9+/]*={0,2})$/.exec(source);
+    if (!match) fault("font data URI must use base64", "font-format");
+    return Buffer.from(match[1], "base64");
+  }
+  if (url.protocol !== "file:")
+    fault("tool fonts must be local; import remote fonts at build time", "font-source");
+  return readFileSync(url);
+}
+function documentCharacters(doc) {
+  const chars = [];
+  const visit = (value, key = "") => {
+    if (typeof value === "string" && ["text", "default", "value", "placeholder"].includes(key))
+      chars.push(value);
+    else if (Array.isArray(value)) value.forEach((v) => visit(v, key));
+    else if (value && typeof value === "object") {
+      if ("overflow" in value && value.overflow === "ellipsis") chars.push("\u2026");
+      if ("obscured" in value && value.obscured === true) chars.push("\u2022");
+      for (const [k, v] of Object.entries(value)) visit(v, k);
+    }
+  };
+  visit(doc);
+  return chars.join("");
+}
+function documentFonts(doc, file, overrides = [], sourceFile = () => file) {
+  const measurer = new ToolMeasurer(), diagnostics = [];
+  const visit = (doc2, base = "") => {
+    if (!doc2 || typeof doc2 !== "object" || Array.isArray(doc2)) return;
+    for (const [name, asset] of Object.entries(doc2.assets ?? {}))
+      if (asset && typeof asset === "object" && asset.type === "font" && typeof asset.source === "string" && asset.export !== false) {
+        const pointer = base + "/assets/" + escape(name) + "/source";
+        try {
+          const font = new Font(fontBytes(asset.source, sourceFile(pointer)));
+          measurer.register(name, font, asset.weight, asset.style);
+          if (typeof asset.family === "string")
+            measurer.register(asset.family, font, asset.weight, asset.style);
+          measurer.register(font.family, font, asset.weight, asset.style);
+        } catch (e) {
+          diagnostics.push(diagnostic(e, pointer));
+        }
+      }
+    for (const [name, child] of Object.entries(doc2.components ?? {}))
+      visit(child, base + "/components/" + escape(name));
+  };
+  visit(doc);
+  for (const entry of overrides) {
+    const equal = entry.indexOf("=");
+    try {
+      if (equal <= 0) fault("--font needs family=path", "font-option");
+      const font = new Font(readFileSync(entry.slice(equal + 1)));
+      const family = entry.slice(0, equal);
+      measurer.fonts.delete(family.toLowerCase());
+      measurer.register(family, font);
+    } catch (e) {
+      diagnostics.push(diagnostic(e, "/font"));
+    }
+  }
+  const walk = (v, pointer = "") => {
+    if (!v || typeof v !== "object") return;
+    const style = v;
+    if ((style.axes || style.features) && measurer.fonts.size && /\/(?:styles|textStyles)\/[^/]+$/.test(pointer)) {
+      const spec = {
+        family: style.font ?? "sans-serif",
+        size: 1,
+        weight: 400,
+        style: "normal",
+        tracking: 0,
+        axes: style.axes,
+        features: style.features
+      };
+      let font;
+      try {
+        font = measurer.resolve(spec);
+      } catch {
+      }
+      if (font) {
+        for (const tag of Object.keys(style.axes ?? {}))
+          if (!font.axes.some((a) => a.tag === tag))
+            diagnostics.push({
+              code: "font-axis",
+              severity: "error",
+              pointer: pointer + "/axes/" + escape(tag),
+              message: "font has no variation axis " + tag,
+              hint: "use an axis listed by anima inspect-font"
+            });
+        for (const tag of Object.keys(style.features ?? {}))
+          if (!featureTags(font).has(tag))
+            diagnostics.push({
+              code: "font-feature",
+              severity: "warning",
+              pointer: pointer + "/features/" + escape(tag),
+              message: "font has no feature " + tag,
+              hint: "choose a feature advertised by the font; absent features have no effect"
+            });
+      }
+    }
+    for (const [k, child] of Object.entries(v)) {
+      const p = pointer + "/" + escape(k);
+      if (k === "text" && typeof child === "string")
+        diagnostics.push(...shapingDiagnostic(child, p));
+      else walk(child, p);
+    }
+  };
+  walk(doc);
+  return { measurer, diagnostics };
+}
+async function installToolMeasurer(measurer) {
+  const actual = new URL("../../../../modules/text/core/measure.ts", import.meta.url);
+  const module = await (existsSync(actual) ? import(actual.href) : import("animl/internal/modules/text/core/measure.js"));
+  const install = module.setTextMeasurer ?? module.setMeasurer;
+  if (!install) fault("text module must export setTextMeasurer(TextMeasurer)", "font-contract");
+  install(measurer);
+}
+function buildFont(asset, doc, file) {
+  const bytes = fontBytes(asset.source, file), font = new Font(bytes), mode = asset.glyphs ?? "all";
+  if (!["used", "all", "custom"].includes(mode) || mode === "custom" && typeof asset.chars !== "string")
+    fault("font glyphs needs all, used, or custom with chars", "font-glyphs");
+  const result = mode === "all" ? bytes : subsetFont(bytes, mode === "custom" ? asset.chars : documentCharacters(doc));
+  if (mode !== "all") {
+    asset.source = `data:${font.flavor === 1330926671 ? "font/otf" : "font/ttf"};base64,` + result.toString("base64");
+    asset.storage = "embedded";
+  }
+  asset.mime = mode !== "all" ? font.flavor === 1330926671 ? "font/otf" : "font/ttf" : bytes.subarray(0, 4).toString() === "wOF2" ? "font/woff2" : bytes.subarray(0, 4).toString() === "wOFF" ? "font/woff" : font.flavor === 1330926671 ? "font/otf" : "font/ttf";
+  asset.size = result.length;
+}
+export {
+  buildFont,
+  documentCharacters,
+  documentFonts,
+  fontBytes,
+  installToolMeasurer
+};

package/packages/cli/src/font/features.d.ts

@@ -0,0 +1 @@
+export * from 'animl/internal/modules/fonts/core/opentype/features.js';

package/packages/cli/src/font/features.js

@@ -0,0 +1 @@
+export * from "animl/internal/modules/fonts/core/opentype/features.js";

package/packages/cli/src/font/flatten.d.ts

@@ -0,0 +1,5 @@
+import type { ToolMeasurer } from './measure.js';
+type ObjectValue = Record<string, unknown>;
+/** Freeze default text into geometry, retaining document/definition scopes and live group props. */
+export declare function flattenText(doc: ObjectValue, measurer: ToolMeasurer, nodeId?: string): ObjectValue;
+export {};

package/packages/cli/src/font/flatten.js

@@ -0,0 +1,146 @@
+import { drawFrame, load, Player } from "animl";
+import { nodeShape } from "animl/internal/packages/core/src/registry.js";
+import { sceneTree, svgAttrs, staticSlots } from "animl/internal/packages/core/src/svg.js";
+import { importSVG } from "../import-svg.js";
+import { outlineSVG } from "./svg.js";
+const xml = (s) => s.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+function flattenText(doc, measurer, nodeId) {
+  const out = structuredClone(doc);
+  let found = false, clipped = false, serial = 0;
+  const ids = /* @__PURE__ */ new Set();
+  const collect = (value) => {
+    if (Array.isArray(value)) value.forEach(collect);
+    else if (value && typeof value === "object") {
+      if ("id" in value && typeof value.id === "string") ids.add(value.id);
+      Object.values(value).forEach(collect);
+    }
+  };
+  collect(out);
+  const fresh = () => {
+    let id;
+    do {
+      id = "outline" + serial++;
+    } while (ids.has(id));
+    ids.add(id);
+    return id;
+  };
+  const fail = (message) => {
+    throw Object.assign(new Error(message), {
+      code: "font-flatten",
+      pointer: "",
+      hint: "remove editable fields and text-only references, or simplify the unsupported drawing feature"
+    });
+  };
+  const groupKeys = Object.keys(nodeShape("group").p).filter(
+    (k) => !["id", "type", "children"].includes(k)
+  );
+  const convert = (definition, source, prefix) => {
+    let player;
+    const getPlayer = () => {
+      if (player) return player;
+      const result = load(source);
+      if (!result.model)
+        fail("cannot flatten text: " + result.diagnostics.map((d) => d.message).join("; "));
+      player = new Player(result.model);
+      player.step(0);
+      return player;
+    };
+    const visit = (nodes, inLayout = false) => {
+      if (!Array.isArray(nodes)) return;
+      for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        if (node.type !== "text" || nodeId && nodeId !== prefix + node.id) {
+          visit(node.children, node.type === "layout");
+          continue;
+        }
+        if (node.textInput) fail("cannot flatten an editable field; remove textInput first");
+        if (inLayout) fail("cannot flatten a layout participant; its measured size would be lost");
+        found = true;
+        const p = getPlayer(), index = p.model.ids.get(String(node.id)), frame = drawFrame(p);
+        const find = (els) => {
+          for (const el of els) {
+            if (el.node === index && el.role === "module:text") return el;
+            const child = find(el.kids);
+            if (child) return child;
+          }
+        };
+        const root = find(sceneTree(p.model).root);
+        if (!root) fail("text SVG backend is not installed");
+        const serialize = (el) => {
+          const a = svgAttrs(frame, el, staticSlots(), "flatten");
+          if (el.role === "module:text-clip") return "";
+          if (el.role === "module:text-content") delete a["clip-path"];
+          if (a["color-interpolation"] === "sRGB") delete a["color-interpolation"];
+          if (el.tag === "g" && a.style === "white-space:pre") delete a.style;
+          if (el.tag === "g") delete a["text-rendering"];
+          const attrs = Object.entries(a).filter(([, v]) => v !== null).map(([k, v]) => ` ${k}="${xml(v)}"`).join("");
+          const rendered = `<${el.tag}${attrs}>${el.text === void 0 ? el.kids.map(serialize).join("") : xml(el.text)}</${el.tag}>`;
+          return ["linearGradient", "radialGradient"].includes(el.tag) ? `<defs>${rendered}</defs>` : rendered;
+        };
+        const svg = `<svg viewBox="${p.model.viewBox.join(" ")}">${serialize(root)}</svg>`, imported = importSVG(outlineSVG(svg, measurer), "flattened");
+        if (imported.diagnostics.length)
+          fail(
+            "outline conversion cannot preserve SVG feature: " + imported.diagnostics[0].message
+          );
+        let children = imported.doc.nodes;
+        const rename = (nodes2) => nodes2.forEach((n) => {
+          n.id = fresh();
+          if (Array.isArray(n.children)) rename(n.children);
+        });
+        rename(children);
+        const clip = frame.nodes[index].text?.layout.clip;
+        if (clip) {
+          const [x0, y0, w, h] = clip;
+          const id = fresh();
+          children = [
+            { type: "rect", id, x0, y0, w, h, fill: { color: "#00000000" } },
+            { type: "group", id: fresh(), clip: { source: id }, children }
+          ];
+          clipped = true;
+        }
+        nodes[i] = {
+          type: "group",
+          id: node.id,
+          ...Object.fromEntries(
+            groupKeys.filter((k) => node[k] !== void 0).map((k) => [k, node[k]])
+          ),
+          children
+        };
+      }
+    };
+    visit(definition.nodes);
+  };
+  convert(out, doc, "");
+  for (const [name, definition] of Object.entries(out.components ?? {})) {
+    const original = doc.components[name];
+    const source = {
+      anima: doc.anima,
+      name: "flatten-component",
+      requires: doc.requires,
+      components: doc.components,
+      ...original,
+      ...original.data || doc.data ? {
+        data: typeof original.data === "string" ? { ...doc.data, model: original.data } : original.data ?? doc.data
+      } : {}
+    };
+    convert(definition, source, name + "/");
+  }
+  if (nodeId && !found) fail("no text node with id " + nodeId);
+  if (found)
+    out.requires = [
+      .../* @__PURE__ */ new Set([
+        ...Array.isArray(out.requires) ? out.requires : [],
+        "paint",
+        ...clipped ? ["composite"] : []
+      ])
+    ];
+  const checked = load(out);
+  if (!checked.model)
+    fail(
+      "flattened document has remaining text references: " + checked.diagnostics.map((d) => d.message).join("; ")
+    );
+  return out;
+}
+export {
+  flattenText
+};

package/packages/cli/src/font/import.d.ts

@@ -0,0 +1,12 @@
+export interface ImportedFont {
+    source: string;
+    type: 'font';
+    family: string;
+    weight: number;
+    style: 'normal' | 'italic';
+    mime: string;
+    size: number;
+}
+export declare function importFont(path: string, out: string, chars?: string): ImportedFont;
+/** Explicit build-time network access. Tests supply a fake Fetch implementation. */
+export declare function googleFonts(query: string, out: string, chars?: string, fetcher?: typeof fetch): Promise<ImportedFont[]>;