animl-cli 0.0.0-stage → 0.1.1

package/packages/cli/src/docs-view.js

@@ -0,0 +1,279 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+import "animl/all";
+import { ELEMENTS, NODE_TYPES } from "animl";
+import { distance } from "./schema-view.js";
+const ROOT = resolve(import.meta.dirname, "../../..");
+const read = (path) => readFileSync(resolve(ROOT, path), "utf8");
+const compact = (value) => value.replace(/[^a-z0-9]/gi, "").toLowerCase();
+const slug = (title) => title.toLowerCase().replace(/^[0-9]+(?:\.[0-9]+)*[.\s-]*/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+function headings(source, levels = [2, 3]) {
+  return [...source.matchAll(/^(#{2,6}) (.+)$/gm)].map((match) => ({
+    level: match[1].length,
+    title: match[2],
+    slug: slug(match[2]),
+    at: match.index
+  })).filter((entry) => levels.includes(entry.level));
+}
+function section(source, entry, entries = headings(source)) {
+  const next = entries.find(
+    (candidate) => candidate.at > entry.at && candidate.level <= entry.level
+  );
+  return source.slice(entry.at, next?.at ?? source.length).trim();
+}
+function nearest(word, candidates) {
+  const key = compact(word);
+  const first = [...new Set(candidates)].map((candidate) => ({ candidate, d: distance(key, compact(candidate)) })).sort((a, b) => a.d - b.d || a.candidate.localeCompare(b.candidate))[0];
+  return first && first.d <= Math.max(2, Math.floor(key.length / 3)) ? first.candidate : void 0;
+}
+function moduleDocs() {
+  return new Map(
+    readdirSync(resolve(ROOT, "modules"), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => [
+      entry.name,
+      ["AUTHORING.md", "SPEC.md"].map((file) => "modules/" + entry.name + "/" + file).filter((file) => existsSync(resolve(ROOT, file)))
+    ])
+  );
+}
+function parityRows() {
+  return JSON.parse(read("docs/parity/inventory.json"));
+}
+function resolveHeadingForWord(source, word) {
+  const entries = headings(source);
+  const key = compact(word);
+  const bySlug = entries.find(
+    (entry) => compact(entry.slug) === key || compact(entry.title) === key
+  );
+  if (bySlug) return bySlug;
+  const lower = source.toLowerCase();
+  const terms = [word, word.replace(/[A-Z]/g, (letter) => "-" + letter.toLowerCase())];
+  let at = -1;
+  for (const term of terms) {
+    const index = lower.indexOf(term.toLowerCase());
+    if (index >= 0 && (at < 0 || index < at)) at = index;
+  }
+  if (at < 0) return void 0;
+  return entries.filter((entry) => entry.at <= at).at(-1);
+}
+function resolver() {
+  const guide = read("docs/AUTHORING.md") + "\n\n" + read("packages/cli/src/font/README.md");
+  const spec = read("spec/SPEC.md");
+  const modules = moduleDocs();
+  const guideHeadings = headings(guide);
+  const specHeadings = headings(spec);
+  const moduleNames = [...modules.keys()];
+  const aliases = {
+    constraint: "rig",
+    constraints: "rig",
+    semantic: "a11y",
+    semantics: "a11y",
+    accessibility: "a11y",
+    a11y: "a11y"
+  };
+  const canonicalModule = (word) => moduleNames.find((name) => compact(name) === compact(word));
+  const resolve2 = (word) => {
+    if (word === "authoring") return { kind: "authoring", topic: "authoring" };
+    if (word === "spec") return { kind: "spec", topic: "spec" };
+    if (word === "markup") return { kind: "markup", topic: "markup" };
+    const alias = aliases[word] ?? aliases[compact(word)];
+    if (alias && alias !== word) return resolve2(alias);
+    const module = canonicalModule(word);
+    if (module) return { kind: "module", topic: module };
+    const guideHeading = guideHeadings.find(
+      (entry) => compact(entry.slug) === compact(word) || compact(entry.title) === compact(word)
+    );
+    if (guideHeading)
+      return { kind: "guide-section", topic: guideHeading.slug, heading: guideHeading };
+    const specHeading = specHeadings.find(
+      (entry) => compact(entry.slug) === compact(word) || compact(entry.title) === compact(word)
+    );
+    if (specHeading) return { kind: "spec-section", topic: specHeading.slug, heading: specHeading };
+    const row = parityRows().find((candidate) => compact(candidate.id) === compact(word));
+    if (row) {
+      const suffix = row.id.split(".").at(-1);
+      const suffixResolved = resolve2(suffix);
+      if (suffixResolved) return suffixResolved;
+      if (row.anima?.module) {
+        const moduleResolved = resolve2(row.anima.module);
+        if (moduleResolved) return moduleResolved;
+      }
+    }
+    const element = Object.entries(ELEMENTS).find(
+      ([name, form]) => compact(name) === compact(word) || form.values?.kind && compact(form.values.kind) === compact(word)
+    );
+    if (element) {
+      const heading2 = resolveHeadingForWord(spec, element[0]) ?? resolveHeadingForWord(spec, word);
+      if (heading2) return { kind: "spec-section", topic: heading2.slug, heading: heading2 };
+      const feature = element[1].shape.feature;
+      if (feature) {
+        const featureResolved = resolve2(String(feature).split("|")[0]);
+        if (featureResolved) return featureResolved;
+      }
+    }
+    if (NODE_TYPES.some((name) => compact(name) === compact(word))) {
+      const heading2 = resolveHeadingForWord(spec, word);
+      if (heading2) return { kind: "spec-section", topic: heading2.slug, heading: heading2 };
+    }
+    const heading = resolveHeadingForWord(spec, word);
+    if (heading) return { kind: "spec-section", topic: heading.slug, heading };
+    return void 0;
+  };
+  const candidates = [
+    "authoring",
+    "spec",
+    "markup",
+    ...guideHeadings.map((entry) => entry.slug),
+    ...specHeadings.map((entry) => entry.slug),
+    ...moduleNames,
+    ...Object.keys(aliases),
+    ...Object.keys(ELEMENTS),
+    ...Object.values(ELEMENTS).map((form) => form.values?.kind).filter((value) => !!value),
+    ...NODE_TYPES,
+    ...parityRows().map((row) => row.id)
+  ];
+  return { guide, spec, modules, guideHeadings, specHeadings, resolve: resolve2, candidates };
+}
+function moduleText(topic, spec, modules) {
+  const specEntries = headings(spec, [2]);
+  const chapter = specEntries.find((entry) => compact(entry.title) === compact(topic));
+  let text = chapter ? section(spec, chapter, specEntries) : "";
+  for (const file of modules.get(topic) ?? []) {
+    const body = read(file).trim();
+    text += "\n\n" + (chapter ? body.replace(/^#/gm, "###") : body);
+  }
+  const examples = resolve(ROOT, "modules", topic, "examples");
+  if (existsSync(examples)) {
+    const files = readdirSync(examples).filter((file) => file.endsWith(".animl")).sort();
+    if (files.length)
+      text += "\n\nExamples (AniML sources with built .ani siblings):\n" + files.map((file) => "- modules/" + topic + "/examples/" + file).join("\n");
+  }
+  return text.trim();
+}
+function contents(title, command, entries) {
+  return title + "\n\nContents (" + command + " <section>):\n" + entries.map((entry) => "- " + entry.slug + ": " + entry.title).join("\n");
+}
+function miss(topic, candidates, io, json = false) {
+  const suggestion = nearest(topic, candidates);
+  if (json) {
+    const suggestions = suggestion ? [suggestion] : [];
+    io.err(
+      JSON.stringify({ error: `no docs topic "${topic}"`, suggestions, help: "anima docs --list" })
+    );
+    return 2;
+  }
+  io.err(
+    suggestion ? 'no docs topic "' + topic + '"; did you mean "' + suggestion + '"? Try anima docs ' + suggestion + "\nSee 'anima docs --list'." : 'no docs topic "' + topic + `"
+See 'anima docs --list'.`
+  );
+  return 2;
+}
+function docsImpl(topic, list, json, io, requestedSection, full = false) {
+  const state = resolver();
+  if (topic === "spec" && (list || requestedSection)) {
+    const entries = state.specHeadings;
+    if (list) {
+      io.out(
+        json ? JSON.stringify(entries.map(({ title, slug: name }) => ({ title, slug: name }))) : entries.map((entry) => entry.slug + "	" + entry.title).join("\n")
+      );
+      return 0;
+    }
+    const found = entries.find((entry) => compact(entry.slug) === compact(requestedSection));
+    if (!found)
+      return miss(
+        requestedSection,
+        entries.map((entry) => entry.slug),
+        io,
+        json
+      );
+    const text2 = section(state.spec, found, entries);
+    io.out(json ? JSON.stringify({ topic: "spec", section: found.slug, text: text2 }) : text2);
+    return 0;
+  }
+  if (topic === "authoring" && requestedSection) {
+    const found = state.guideHeadings.find(
+      (entry) => compact(entry.slug) === compact(requestedSection)
+    );
+    if (!found)
+      return miss(
+        requestedSection,
+        state.guideHeadings.map((entry) => entry.slug),
+        io,
+        json
+      );
+    const text2 = section(state.guide, found, state.guideHeadings);
+    io.out(json ? JSON.stringify({ topic: "authoring", section: found.slug, text: text2 }) : text2);
+    return 0;
+  }
+  if (list) {
+    const listed = [
+      .../* @__PURE__ */ new Set([
+        "authoring",
+        "spec",
+        "markup",
+        ...state.guideHeadings.map((entry) => entry.slug),
+        ...state.specHeadings.map((entry) => entry.slug),
+        ...state.modules.keys()
+      ])
+    ].sort();
+    io.out(json ? JSON.stringify(listed) : listed.join("\n"));
+    return 0;
+  }
+  if (!topic) {
+    const text2 = contents(state.guide.split("\n")[0], "anima docs authoring", state.guideHeadings);
+    io.out(json ? JSON.stringify({ topic: "authoring", text: text2 }) : text2);
+    return 0;
+  }
+  const resolved = state.resolve(topic);
+  if (!resolved) return miss(topic, state.candidates, io, json);
+  let text;
+  switch (resolved.kind) {
+    case "authoring": {
+      const index = contents(
+        state.guide.split("\n")[0],
+        "anima docs authoring",
+        state.guideHeadings
+      );
+      text = full ? state.guide : index + "\n\nThe whole guide: anima docs authoring --full";
+      break;
+    }
+    case "spec":
+      text = full ? state.spec : contents(state.spec.split("\n")[0], "anima docs spec", state.specHeadings);
+      break;
+    case "markup":
+      text = read("spec/ANIML.md");
+      break;
+    case "guide-section":
+      text = section(state.guide, resolved.heading, state.guideHeadings);
+      break;
+    case "spec-section":
+      text = section(state.spec, resolved.heading, state.specHeadings);
+      break;
+    case "module":
+      text = moduleText(resolved.topic, state.spec, state.modules);
+      break;
+  }
+  if (requestedSection) {
+    const entries = headings(text, [2, 3, 4, 5, 6]);
+    const matches = entries.filter((entry) => compact(entry.slug) === compact(requestedSection));
+    const found = matches.find((entry) => entry.at > 0) ?? matches[0];
+    if (!found)
+      return miss(
+        requestedSection,
+        entries.map((entry) => entry.slug),
+        io,
+        json
+      );
+    text = section(text, found, entries);
+  }
+  io.out(json ? JSON.stringify({ topic: resolved.topic, text }) : text);
+  return 0;
+}
+function docs(topic, list, json, io, requestedSection) {
+  return docsImpl(topic, list, json, io, requestedSection, false);
+}
+function docsFull(topic, list, json, io, requestedSection) {
+  return docsImpl(topic, list, json, io, requestedSection, true);
+}
+export {
+  docs,
+  docsFull
+};

package/packages/cli/src/doctor.d.ts

@@ -0,0 +1,11 @@
+export declare function doctor(cwd?: string): Promise<{
+    ok: boolean;
+    checks: {
+        code: string;
+        pointer: string;
+        name: string;
+        pass: boolean;
+        message: string;
+        hint: string;
+    }[];
+}>;

package/packages/cli/src/doctor.js

@@ -0,0 +1,151 @@
+import { accessSync, constants, existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { createServer } from "node:net";
+import { findProject } from "./project.js";
+import { homedir } from "node:os";
+import { resolve, dirname } from "node:path";
+import { spawnSync } from "node:child_process";
+async function doctor(cwd = process.cwd()) {
+  const { firefox, chromium, devices } = await import("playwright-core");
+  const checks = [];
+  checks.push({
+    name: "authentication",
+    pass: true,
+    message: "not applicable: Anima has no accounts",
+    hint: "no authentication required"
+  });
+  try {
+    const project = findProject(cwd);
+    checks.push({
+      name: "project",
+      pass: true,
+      message: project?.file ?? "no anima.json (optional)",
+      hint: "create anima.json to configure this project"
+    });
+  } catch (e) {
+    checks.push({
+      name: "project",
+      pass: false,
+      message: e.message,
+      hint: "repair anima.json; run a project command for its field pointer"
+    });
+  }
+  const port = await new Promise((resolve2) => {
+    const server = createServer();
+    server.once("error", () => resolve2(false));
+    server.listen(4519, "127.0.0.1", () => server.close(() => resolve2(true)));
+  });
+  checks.push({
+    name: "port",
+    pass: port,
+    message: "127.0.0.1:4519",
+    hint: "stop the process using port 4519 or choose another playground --port"
+  });
+  try {
+    const browser = await chromium.launch({
+      executablePath: process.env.CHROMIUM_PATH ?? resolve(
+        homedir(),
+        ".cache/ms-playwright/chromium_headless_shell-1248/chrome-headless-shell-linux64/chrome-headless-shell"
+      ),
+      headless: true
+    });
+    try {
+      const context = await browser.newContext({ ...devices["iPhone 13"] });
+      const page = await context.newPage();
+      const pass = await page.evaluate(() => innerWidth > 0 && navigator.maxTouchPoints > 0);
+      checks.push({
+        name: "devices",
+        pass,
+        message: "Chromium mobile viewport and touch emulation",
+        hint: "install a working cached Playwright Chromium"
+      });
+      await context.close();
+    } finally {
+      await browser.close();
+    }
+  } catch (e) {
+    checks.push({
+      name: "devices",
+      pass: false,
+      message: e.message,
+      hint: "install cached Playwright Chromium or set CHROMIUM_PATH"
+    });
+  }
+  const node = Number(process.versions.node.split(".")[0]);
+  checks.push({
+    name: "node",
+    pass: node >= 24,
+    message: process.version,
+    hint: "install Node 24 or newer"
+  });
+  for (const [name, path] of [
+    [
+      "chromium",
+      process.env.CHROMIUM_PATH ?? resolve(
+        homedir(),
+        ".cache/ms-playwright/chromium_headless_shell-1248/chrome-headless-shell-linux64/chrome-headless-shell"
+      )
+    ],
+    ["firefox", firefox.executablePath()]
+  ]) {
+    let pass = false;
+    try {
+      accessSync(path, constants.X_OK);
+      pass = true;
+    } catch {
+    }
+    checks.push({
+      name,
+      pass,
+      message: path,
+      hint: "install the Playwright browser or set CHROMIUM_PATH for Chromium"
+    });
+  }
+  const cache = process.env.XDG_CACHE_HOME ?? resolve(homedir(), ".cache");
+  let writable = false;
+  try {
+    mkdirSync(cache, { recursive: true });
+    accessSync(cache, constants.W_OK);
+    const probe = mkdtempSync(resolve(cache, ".anima-doctor-"));
+    rmSync(probe, { recursive: true });
+    writable = true;
+  } catch {
+  }
+  checks.push({
+    name: "cache",
+    pass: writable,
+    message: cache,
+    hint: "grant write access to the cache directory"
+  });
+  let repo = resolve(cwd);
+  while (!(existsSync(resolve(repo, "tools/modules.ts")) && existsSync(resolve(repo, "spec/MODULES.md")))) {
+    const parent = dirname(repo);
+    if (parent === repo) break;
+    repo = parent;
+  }
+  if (existsSync(resolve(repo, "tools/modules.ts")) && existsSync(resolve(repo, "spec/MODULES.md"))) {
+    const result = spawnSync(process.execPath, ["tools/modules.ts", "--check"], {
+      cwd: repo,
+      encoding: "utf8"
+    });
+    checks.push({
+      name: "module-wiring",
+      pass: result.status === 0,
+      message: (result.stdout + result.stderr).trim(),
+      hint: "run node tools/modules.ts and commit generated wiring"
+    });
+  } else {
+    checks.push({
+      name: "module-wiring",
+      pass: true,
+      message: "installed package: repository wiring check not applicable",
+      hint: "run this check from an Anima source checkout to verify generated wiring"
+    });
+  }
+  return {
+    ok: checks.every((c) => c.pass),
+    checks: checks.map((c) => ({ ...c, code: "doctor-" + c.name, pointer: "/checks/" + c.name }))
+  };
+}
+export {
+  doctor
+};

package/packages/cli/src/encode.d.ts

@@ -0,0 +1,9 @@
+import type { Browser } from 'playwright-core';
+import type { AssetInfo } from './asset-info.js';
+export declare class ImageEncoder {
+    #private;
+    close(): Promise<void>;
+    browser(): Promise<Browser>;
+}
+export declare function validateWebP(bytes: Buffer, info: AssetInfo, session?: ImageEncoder): Promise<void>;
+export declare function encodeImage(bytes: Buffer, info: AssetInfo, encode: string, quality?: number, session?: ImageEncoder): Promise<Buffer>;

package/packages/cli/src/encode.js

@@ -0,0 +1,100 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { Resvg } from "@resvg/resvg-js";
+import { PNG } from "pngjs";
+class ImageEncoder {
+  #browser;
+  async close() {
+    await (await this.#browser)?.close();
+  }
+  async browser() {
+    if (!this.#browser) {
+      const executablePath = process.env.CHROMIUM_PATH ?? resolve(
+        homedir(),
+        ".cache/ms-playwright/chromium_headless_shell-1248/chrome-headless-shell-linux64/chrome-headless-shell"
+      );
+      this.#browser = (async () => {
+        if (!existsSync(executablePath)) throw Error("missing executable");
+        const { chromium } = await import("playwright-core");
+        return chromium.launch({ executablePath, headless: true });
+      })().catch(() => {
+        this.#browser = void 0;
+        throw Object.assign(Error("cached Chromium image encoder/decoder is unavailable"), {
+          code: "build-encoder-unavailable",
+          pointer: "",
+          hint: "install cached Playwright Chromium or set CHROMIUM_PATH to a Chromium executable"
+        });
+      });
+    }
+    return this.#browser;
+  }
+}
+async function browserImage(bytes, info, encode, quality, session) {
+  const owned = session === void 0;
+  session ??= new ImageEncoder();
+  const browser = await session.browser();
+  let page;
+  try {
+    page = await browser.newPage();
+    return await page.evaluate(
+      async ({ uri, encode: encode2, quality: quality2 }) => {
+        const image = new Image();
+        image.src = uri;
+        await image.decode();
+        const canvas = document.createElement("canvas");
+        canvas.width = image.naturalWidth;
+        canvas.height = image.naturalHeight;
+        const ctx = canvas.getContext("2d");
+        ctx.drawImage(image, 0, 0);
+        if (!encode2)
+          return {
+            width: canvas.width,
+            height: canvas.height,
+            data: Array.from(ctx.getImageData(0, 0, canvas.width, canvas.height).data)
+          };
+        const result = canvas.toDataURL("image/" + encode2, quality2);
+        if (!result.startsWith("data:image/" + encode2 + ";"))
+          throw Error("encoder returned a different format");
+        return result.split(",")[1];
+      },
+      { uri: `data:${info.mime};base64,${bytes.toString("base64")}`, encode, quality }
+    );
+  } finally {
+    try {
+      await page?.close();
+    } finally {
+      if (owned) await session.close();
+    }
+  }
+}
+async function validateWebP(bytes, info, session) {
+  await browserImage(bytes, info, void 0, void 0, session);
+}
+async function encodeImage(bytes, info, encode, quality, session) {
+  if (encode === "png") {
+    if (info.mime === "image/webp") {
+      const pixels = await browserImage(bytes, info, void 0, void 0, session);
+      if (typeof pixels === "string") throw Error("decoder returned no pixels");
+      return PNG.sync.write({
+        width: pixels.width,
+        height: pixels.height,
+        data: Buffer.from(pixels.data)
+      });
+    }
+    const uri = `data:${info.mime};base64,${bytes.toString("base64")}`;
+    return Buffer.from(
+      new Resvg(
+        `<svg xmlns="http://www.w3.org/2000/svg" width="${info.width}" height="${info.height}"><image href="${uri}" width="${info.width}" height="${info.height}"/></svg>`
+      ).render().asPng()
+    );
+  }
+  const encoded = await browserImage(bytes, info, encode, quality, session);
+  if (typeof encoded !== "string") throw Error("encoder returned no bytes");
+  return Buffer.from(encoded, "base64");
+}
+export {
+  ImageEncoder,
+  encodeImage,
+  validateWebP
+};

package/packages/cli/src/font/README.md

@@ -0,0 +1,45 @@
+# Tool fonts
+
+This directory is Node-only tooling. `reader.ts` exposes `Font` and diagnostic-safe `readFont`;
+`measure.ts` supplies the DESIGN §4 `ToolMeasurer`. `document.ts` loads local document faces,
+builds subsets and installs the optional text-module seam. `svg.ts` turns rendered text into paths;
+`browser.ts` owns the explicit Chromium fallback. `flatten.ts` freezes default text into geometry.
+
+```sh
+anima import-font fixtures/fonts/anima-test.ttf -o /tmp/local.ttf --chars 'AVé'
+anima import-font --google 'Example:wght@400;600' -o /tmp/example.ttf --chars 'Hello'
+anima validate scene.animl --font 'Example=/tmp/example.ttf'
+anima sample scene.animl --font 'Example=/tmp/example.ttf' -e snapshot
+anima render scene.animl --font 'Example=/tmp/example.ttf' -o /tmp/scene.png
+anima render scene.animl --browser-text -o /tmp/complex.png
+anima flatten scene.animl --node title -o /tmp/outlined.animl
+```
+
+Register fixtures for tool clients with `new ToolMeasurer()`, `register(family, new Font(bytes))`,
+then call `measure(fontSpec, text)` or `outline(fontSpec, text, x, baseline)`. Register separate static
+faces with weight/style arguments; variable `wght` comes from FontSpec.weight by default. No system
+fonts are used by this measurer. The optional text module must export `setTextMeasurer` (or
+`setMeasurer`) for CLI/conformance installation. See the spec's “Tool font processing” for limits.
+
+Flatten accepts the text backend's inline font/paint CSS and whitespace/geometricPrecision hints, translating paint to SVG presentation attributes and removing text-only hints after outlining. Unsupported CSS still reports font-unsupported instead of silently dropping visible effects.
+
+## Local font options
+
+`anima sample`, `session` (including reload), `bench`, `inspect`, `validate`, `render`, `flatten` and `build` accept repeatable
+`--font Name=path` overrides. This includes semantic snapshots and bounds during sampling,
+render comparisons and sheets, and both document and HTML builds. Font assets declared in the
+document are loaded automatically; overrides supply CSS families or replace an asset alias.
+Commands that only inspect structure (`schema`, `fmt`, `decompile`) do not lay out
+text and do not load font overrides. Inspect steps a preview player, so semantic text in that preview also uses these fonts.
+
+Semantic sampling retains `font-missing` with a script-line pointer and a
+`--font Name=path` repair hint when layout requests an unregistered family.
+
+## Decoded-face inspection
+
+`@anima-format/core/fonts-info` exports `decodeFont(SFNTBytes)` and `FontInfo`. Tool clients can
+wrap their existing decoded face with `new FontInfo(new Font(bytes))`, including after the Node
+reader has unpacked a WOFF/WOFF2 container. Both use the same bounded platform-neutral parser.
+The optional browser entry adds `await icon.fonts.info(bytesOrURLOrOwnedDecodedFace)`.
+See `modules/fonts/INFO.md` for metrics/coverage, immutable effective options, derivation and
+context-free glyph path access, coordinate conventions and deliberately unsupported formats.

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

@@ -0,0 +1,8 @@
+import { Bytes as ByteReader } from 'animl/internal/modules/fonts/core/opentype/binary.js';
+export { fault, diagnostic, MAX_FONT } from 'animl/internal/modules/fonts/core/opentype/binary.js';
+export declare function checksum(data: Uint8Array): number;
+/** Canonical sfnt directory; deterministic padding and checkSumAdjustment. */
+export declare function sfnt(tables: ReadonlyMap<string, Uint8Array>, flavor?: number): Buffer;
+export declare class Bytes extends ByteReader {
+    slice(p: number, n: number): Buffer;
+}

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

@@ -0,0 +1,54 @@
+import { Bytes as ByteReader } from "animl/internal/modules/fonts/core/opentype/binary.js";
+import { fault } from "animl/internal/modules/fonts/core/opentype/binary.js";
+import { fault as fault2, diagnostic, MAX_FONT } from "animl/internal/modules/fonts/core/opentype/binary.js";
+function checksum(data) {
+  let sum = 0;
+  for (let i = 0; i < data.length; i += 4)
+    sum = sum + ((data[i] ?? 0) * 16777216 + ((data[i + 1] ?? 0) << 16) + ((data[i + 2] ?? 0) << 8) + (data[i + 3] ?? 0)) >>> 0;
+  return sum;
+}
+function sfnt(tables, flavor = 65536) {
+  const entries = [...tables].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  const n = entries.length;
+  if (!n || n > 256) fault("invalid sfnt table count");
+  let offset = 12 + n * 16;
+  const out = Buffer.alloc(offset + entries.reduce((s, [, b]) => s + (b.length + 3 & ~3), 0));
+  out.writeUInt32BE(flavor);
+  out.writeUInt16BE(n, 4);
+  const power = 2 ** Math.floor(Math.log2(n));
+  out.writeUInt16BE(power * 16, 6);
+  out.writeUInt16BE(Math.log2(power), 8);
+  out.writeUInt16BE((n - power) * 16, 10);
+  let head = 0;
+  entries.forEach(([tag, raw], i) => {
+    const data = Buffer.from(raw);
+    if (tag === "head") {
+      if (data.length < 54) fault("short head table");
+      data.writeUInt32BE(0, 8);
+      head = offset;
+    }
+    const p = 12 + i * 16;
+    out.write(tag, p, 4, "ascii");
+    out.writeUInt32BE(checksum(data), p + 4);
+    out.writeUInt32BE(offset, p + 8);
+    out.writeUInt32BE(data.length, p + 12);
+    data.copy(out, offset);
+    offset += data.length + 3 & ~3;
+  });
+  if (head) out.writeUInt32BE(2981146554 - checksum(out) >>> 0, head + 8);
+  return out;
+}
+class Bytes extends ByteReader {
+  slice(p, n) {
+    const bytes = super.slice(p, n);
+    return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  }
+}
+export {
+  Bytes,
+  MAX_FONT,
+  checksum,
+  diagnostic,
+  fault2 as fault,
+  sfnt
+};

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

@@ -0,0 +1,4 @@
+import type { ToolMeasurer } from './measure.js';
+/** Browser shaping is an explicit rendering choice; same lazy Chromium as image encoding. */
+export declare function browserTextPNG(svg: string, measurer: ToolMeasurer): Promise<Buffer>;
+export declare function embedFontCSS(svg: string, measurer: ToolMeasurer): string;