animl 0.0.0-stage → 0.1.0

package/packages/core/src/all.d.ts

@@ -0,0 +1 @@
+export {};

package/packages/core/src/all.js

@@ -0,0 +1,143 @@
+import { VERBOSE } from "./flags.js";
+import { registerModule } from "./modules.js";
+import { registerSVGBackend } from "./svg.js";
+import { components } from "../../../modules/components/core/index.js";
+import { componentsSVG } from "../../../modules/components/core/svg.js";
+import { bind } from "../../../modules/bind/core/index.js";
+import { assets } from "../../../modules/assets/core/index.js";
+import { assetsSVG } from "../../../modules/assets/core/svg.js";
+import { corners } from "../../../modules/corners/core/index.js";
+import { focus } from "../../../modules/focus/core/index.js";
+import { focusSVG } from "../../../modules/focus/core/svg.js";
+import { input } from "../../../modules/input/core/index.js";
+import { inputSVG } from "../../../modules/input/core/svg.js";
+import { media } from "../../../modules/media/core/index.js";
+import { mesh } from "../../../modules/mesh/core/index.js";
+import { meshSVG } from "../../../modules/mesh/core/svg.js";
+import { motion } from "../../../modules/motion/core/index.js";
+import { motionSVG } from "../../../modules/motion/core/svg.js";
+import { events } from "../../../modules/events/core/index.js";
+import { eventsSVG } from "../../../modules/events/core/svg.js";
+import { machine } from "../../../modules/machine/core/index.js";
+import { machineSVG } from "../../../modules/machine/core/svg.js";
+import { paint } from "../../../modules/paint/core/index.js";
+import { paintSVG } from "../../../modules/paint/core/svg.js";
+import { composite } from "../../../modules/composite/core/index.js";
+import { compositeSVG } from "../../../modules/composite/core/svg.js";
+import { contour } from "../../../modules/contour/core/index.js";
+import { contourSVG } from "../../../modules/contour/core/svg.js";
+import { data } from "../../../modules/data/core/index.js";
+import { convert } from "../../../modules/convert/core/index.js";
+import { derive } from "../../../modules/derive/core/index.js";
+import { hostValues } from "../../../modules/host-values/core/index.js";
+import { host } from "../../../modules/host/core/index.js";
+import { dataHost } from "../../../modules/data-host/core/index.js";
+import { hostEdit } from "../../../modules/host-edit/core/index.js";
+import { fonts } from "../../../modules/fonts/core/index.js";
+import { fontsSVG } from "../../../modules/fonts/core/svg.js";
+import { lists } from "../../../modules/lists/core/index.js";
+import { listsSVG } from "../../../modules/lists/core/svg.js";
+import { a11y } from "../../../modules/a11y/core/index.js";
+import { a11ySVG } from "../../../modules/a11y/core/svg.js";
+import { a11yActions } from "../../../modules/a11y-actions/core/index.js";
+import { nested } from "../../../modules/nested/core/index.js";
+import { nestedSVG } from "../../../modules/nested/core/svg.js";
+import { dataArtboard } from "../../../modules/data-artboard/core/index.js";
+import { surface } from "../../../modules/surface/core/index.js";
+import { surfaceSVG } from "../../../modules/surface/core/svg.js";
+import { colormix } from "../../../modules/colormix/core/index.js";
+import { colormixSVG } from "../../../modules/colormix/core/svg.js";
+import { mix } from "../../../modules/mix/core/index.js";
+import { mixSVG } from "../../../modules/mix/core/svg.js";
+import { componentpaint } from "../../../modules/componentpaint/core/index.js";
+import { componentpaintSVG } from "../../../modules/componentpaint/core/svg.js";
+import { text } from "../../../modules/text/core/index.js";
+import { textSVG } from "../../../modules/text/core/svg.js";
+import { layout } from "../../../modules/layout/core/index.js";
+import { layoutSVG } from "../../../modules/layout/core/svg.js";
+import { rig } from "../../../modules/rig/core/all.js";
+import { rigSVG } from "../../../modules/rig/core/svg.js";
+import { ik } from "../../../modules/ik/core/index.js";
+import { ikSVG } from "../../../modules/ik/core/svg.js";
+import { pathfollow } from "../../../modules/pathfollow/core/index.js";
+import { pathfollowSVG } from "../../../modules/pathfollow/core/svg.js";
+import { posepad } from "../../../modules/posepad/core/index.js";
+import { scroll } from "../../../modules/scroll/core/index.js";
+import { scrollSVG } from "../../../modules/scroll/core/svg.js";
+import { skin } from "../../../modules/skin/core/all.js";
+import { skinSVG } from "../../../modules/skin/core/svg.js";
+import { textEffects } from "../../../modules/text-effects/core/index.js";
+import { textEffectsSVG } from "../../../modules/text-effects/core/svg.js";
+import { textinput } from "../../../modules/text-input/core/index.js";
+import { textinputSVG } from "../../../modules/text-input/core/svg.js";
+if (VERBOSE) {
+  registerModule(components);
+  registerSVGBackend("components", componentsSVG);
+  registerModule(bind);
+  registerModule(assets);
+  registerSVGBackend("assets", assetsSVG);
+  registerModule(corners);
+  registerModule(focus);
+  registerSVGBackend("focus", focusSVG);
+  registerModule(input);
+  registerSVGBackend("input", inputSVG);
+  registerModule(media);
+  registerModule(mesh);
+  registerSVGBackend("mesh", meshSVG);
+  registerModule(motion);
+  registerSVGBackend("motion", motionSVG);
+  registerModule(events);
+  registerSVGBackend("events", eventsSVG);
+  registerModule(machine);
+  registerSVGBackend("machine", machineSVG);
+  registerModule(paint);
+  registerSVGBackend("paint", paintSVG);
+  registerModule(composite);
+  registerSVGBackend("composite", compositeSVG);
+  registerModule(contour);
+  registerSVGBackend("contour", contourSVG);
+  registerModule(data);
+  registerModule(convert);
+  registerModule(derive);
+  registerModule(hostValues);
+  registerModule(host);
+  registerModule(dataHost);
+  registerModule(hostEdit);
+  registerModule(fonts);
+  registerSVGBackend("fonts", fontsSVG);
+  registerModule(lists);
+  registerSVGBackend("lists", listsSVG);
+  registerModule(a11y);
+  registerSVGBackend("a11y", a11ySVG);
+  registerModule(a11yActions);
+  registerModule(nested);
+  registerSVGBackend("nested", nestedSVG);
+  registerModule(dataArtboard);
+  registerModule(surface);
+  registerSVGBackend("surface", surfaceSVG);
+  registerModule(colormix);
+  registerSVGBackend("colormix", colormixSVG);
+  registerModule(mix);
+  registerSVGBackend("mix", mixSVG);
+  registerModule(componentpaint);
+  registerSVGBackend("componentpaint", componentpaintSVG);
+  registerModule(text);
+  registerSVGBackend("text", textSVG);
+  registerModule(layout);
+  registerSVGBackend("layout", layoutSVG);
+  registerModule(rig);
+  registerSVGBackend("rig", rigSVG);
+  registerModule(ik);
+  registerSVGBackend("ik", ikSVG);
+  registerModule(pathfollow);
+  registerSVGBackend("pathfollow", pathfollowSVG);
+  registerModule(posepad);
+  registerModule(scroll);
+  registerSVGBackend("scroll", scrollSVG);
+  registerModule(skin);
+  registerSVGBackend("skin", skinSVG);
+  registerModule(textEffects);
+  registerSVGBackend("text-effects", textEffectsSVG);
+  registerModule(textinput);
+  registerSVGBackend("text-input", textinputSVG);
+}

package/packages/core/src/check.d.ts

@@ -0,0 +1,5 @@
+import { type Diags } from './diag.js';
+import { type Shape } from './registry.js';
+/** Check `value` against the document shape. Reports into `d`; returns false on any error. */
+export declare function checkDoc(value: unknown, d: Diags): boolean;
+export declare function check(v: unknown, s: Shape, p: string, d: Diags, depth: number): void;

package/packages/core/src/check.js

@@ -0,0 +1,147 @@
+import { ptr, suggest } from "./diag.js";
+import { VERBOSE as V } from "./flags.js";
+import {
+  DOC,
+  DOC_NAME,
+  NAME,
+  NODE_TYPES,
+  nodeShape
+} from "./registry.js";
+const kind = (v) => v === null ? "null" : Array.isArray(v) ? "array" : typeof v;
+const shapeKind = (s) => s.k === "str" ? "string" : s.k === "num" ? "number" : s.k === "bool" ? "boolean" : s.k === "arr" || s.k === "tup" ? "array" : s.k === "any" ? "any" : "object";
+const MAX_DEPTH = 96;
+function checkDoc(value, d) {
+  const before = d.list.length;
+  const required = value?.requires;
+  d.features = Array.isArray(required) ? required : [];
+  const shape = d.features.includes("components") ? { ...DOC, p: { ...DOC.p, nodes: { ...DOC.p.nodes, min: 0 } } } : DOC;
+  check(value, shape, "", d, 0);
+  return d.list.length === before;
+}
+function check(v, s, p, d, depth) {
+  if (depth > MAX_DEPTH) return d.err("limit-exceeded", p, V && "nesting is too deep");
+  if (s.feature && !s.feature.split("|").some((f) => d.features?.includes(f)))
+    d.err(
+      "undeclared-feature",
+      p,
+      V && `requires does not declare ${s.feature}`,
+      V && `add "${s.feature.split("|").join('" or "')}" to "requires"`
+    );
+  if (s.k === "any") {
+    const seen = /* @__PURE__ */ new Set();
+    for (const stack = [[v, depth]]; stack.length; ) {
+      const [x, n] = stack.pop();
+      if (n > MAX_DEPTH) return d.err("limit-exceeded", p, V && "nesting is too deep");
+      if (x && typeof x === "object" && !seen.has(x)) {
+        seen.add(x);
+        for (const y of Object.values(x)) stack.push([y, n + 1]);
+      }
+    }
+    return;
+  }
+  const k = kind(v);
+  if (s.k === "alt") {
+    const hit = s.of.find((o) => shapeKind(o) === k);
+    return hit ? check(v, hit, p, d, depth) : d.err("type", p, V && `expected ${s.of.map(shapeKind).join(" or ")}, got ${k}`);
+  }
+  if (k !== shapeKind(s) || k === "number" && !Number.isFinite(v))
+    return d.err("type", p, V && `expected ${shapeKind(s)}, got ${k}`);
+  switch (s.k) {
+    case "str": {
+      const str = v;
+      if (s.re && !s.re.test(str)) {
+        const name = s.re === NAME || s.re === DOC_NAME;
+        return d.err(
+          name ? "bad-name" : "bad-value",
+          p,
+          V && (name ? `"${str}" is not a valid name` : `"${str}" does not match ${s.re.source}`),
+          V && name && `names match ${s.re.source}`
+        );
+      }
+      if (s.of && !s.of.includes(str))
+        d.err(
+          "bad-value",
+          p,
+          V && `"${str}" is not one of ${s.of.join(", ")}`,
+          V && suggest(str, s.of)
+        );
+      return;
+    }
+    case "num": {
+      const n = v;
+      if (n < (s.min ?? -Infinity) || n > (s.max ?? Infinity) || n <= (s.gt ?? -Infinity))
+        return d.err("bad-value", p, V && `${n} is out of range`, V && rangeText(s));
+      if (s.int && !Number.isInteger(n)) d.err("bad-value", p, V && `${n} is not an integer`);
+      return;
+    }
+    case "arr":
+    case "tup": {
+      const a = v;
+      if (s.min && a.length < s.min || s.k === "tup" && a.length > s.of.length)
+        return d.err(
+          "bad-value",
+          p,
+          V && (s.k === "tup" ? `needs ${s.min === s.of.length ? s.min : `${s.min} to ${s.of.length}`} items, has ${a.length}` : `needs at least ${s.min} item${s.min > 1 ? "s" : ""}`)
+        );
+      return a.forEach(
+        (x, i) => check(x, s.k === "arr" ? s.of : s.of[i], p + "/" + i, d, depth + 1)
+      );
+    }
+    case "map": {
+      for (const [key, x] of Object.entries(v)) {
+        const kp = ptr(p, key);
+        if (key === "$comment") continue;
+        if (s.key && !s.key.test(key))
+          d.err(
+            "bad-name",
+            kp,
+            V && `"${key}" is not a valid name`,
+            V && `names match ${s.key.source}`
+          );
+        else check(x, s.of, kp, d, depth + 1);
+      }
+      return;
+    }
+    case "obj":
+      return checkObj(v, s, p, d, depth);
+    case "node": {
+      const o = v;
+      if (!("type" in o))
+        return d.err(
+          "missing-key",
+          p,
+          V && 'node has no "type"',
+          V && `one of ${NODE_TYPES.join(", ")}`
+        );
+      if (typeof o.type !== "string" || !NODE_TYPES.includes(o.type))
+        return d.err(
+          "unknown-node-type",
+          p + "/type",
+          V && `unknown node type ${JSON.stringify(o.type)}`,
+          V && (suggest(String(o.type), NODE_TYPES) ?? `one of ${NODE_TYPES.join(", ")}`)
+        );
+      return checkObj(o, nodeShape(o.type), p, d, depth);
+    }
+  }
+}
+function checkObj(o, s, p, d, depth) {
+  for (const [key, x] of Object.entries(o)) {
+    const kp = ptr(p, key);
+    if (key === "$comment") {
+      if (typeof x !== "string") d.err("type", kp, V && `expected string, got ${kind(x)}`);
+    } else if (Object.hasOwn(s.p, key)) check(x, s.p[key], kp, d, depth + 1);
+    else if (s.reserved && Object.hasOwn(s.reserved, key))
+      d.err("reserved", kp, V && `"${key}" is reserved: ${s.reserved[key]}`);
+    else d.err("unknown-key", kp, V && `unknown key "${key}"`, V && suggest(key, Object.keys(s.p)));
+  }
+  for (const r of s.req ?? []) if (!(r in o)) d.err("missing-key", p, V && `missing "${r}"`);
+}
+function rangeText(s) {
+  if (s.gt !== void 0) return `must be > ${s.gt}`;
+  if (s.min !== void 0 && s.max !== void 0) return `must lie in [${s.min}, ${s.max}]`;
+  return s.min !== void 0 ? `must be \u2265 ${s.min}` : `must be \u2264 ${s.max}`;
+}
+export {
+  check,
+  checkDoc
+};

package/packages/core/src/color.d.ts

@@ -0,0 +1,8 @@
+/** A colour as non-premultiplied sRGB channels 0..255: [r, g, b, a]. */
+export type RGBA = [number, number, number, number];
+/** Parse `#rgb`, `#rrggbb` or `#rrggbbaa` (spec §6). Returns null otherwise. */
+export declare function parseHex(s: string): RGBA | null;
+/** Canonical lowercase hex: `#rrggbb`, or `#rrggbbaa` when not opaque. */
+export declare function formatHex(c: RGBA): string;
+/** Spec §5: per channel, `floor(c + 0.5)`, clamped to 0..255. */
+export declare function lerpColor(a: RGBA, b: RGBA, w: number): RGBA;

package/packages/core/src/color.js

@@ -0,0 +1,21 @@
+import { clamp } from "./geom.js";
+function parseHex(s) {
+  const m = /^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(s);
+  if (!m) return null;
+  let h = m[1];
+  if (h.length === 3) h = h.replace(/./g, "$&$&");
+  if (h.length === 6) h += "ff";
+  return [0, 2, 4, 6].map((i) => parseInt(h.slice(i, i + 2), 16));
+}
+function formatHex(c) {
+  const hex = (v) => v.toString(16).padStart(2, "0");
+  return "#" + c.slice(0, c[3] === 255 ? 3 : 4).map(hex).join("");
+}
+function lerpColor(a, b, w) {
+  return a.map((v, i) => clamp(Math.floor(v + (b[i] - v) * w + 0.5), 0, 255));
+}
+export {
+  formatHex,
+  lerpColor,
+  parseHex
+};

package/packages/core/src/cond.d.ts

@@ -0,0 +1,32 @@
+import type { Model, Value } from './load.js';
+import type { Diags } from './diag.js';
+export type Op = '==' | '!=' | '<' | '<=' | '>' | '>=';
+export type Term = {
+    k: 'is';
+    name: string;
+    not: boolean;
+} | {
+    k: 'cmp';
+    name: string;
+    op: Op;
+    value: number;
+} | {
+    k: 'expr';
+    a: string;
+    b: string;
+    op: Op;
+    test?: (scope: ReadonlyMap<string, Value>) => boolean;
+} | {
+    k: 'end';
+} | {
+    k: 'after';
+    s: number;
+};
+/** Parse a condition. Returns its terms, or an error message. */
+export declare function parseCondition(src: string): Term[] | string;
+/** Typed scalar comparison shared by guard and bind expression evaluation. */
+export declare function compare(x: Value, y: Value, op: string): boolean;
+/** Modules own literal type/name validation; core owns syntax and comparison. */
+export declare function literalCondition(model: Model, term: Extract<Term, {
+    k: 'expr';
+}>, at: string, d: Diags): boolean;

package/packages/core/src/cond.js

@@ -0,0 +1,58 @@
+import { VERBOSE as V } from "./flags.js";
+const NAME = "((?:\\$[a-zA-Z][a-zA-Z0-9-]*:)?\\$?[a-zA-Z][a-zA-Z0-9-]*(?:\\.[a-zA-Z0-9-]+)*)";
+const NUM = "(-?(?:\\d+\\.?\\d*|\\.\\d+)(?:[eE][-+]?\\d+)?)";
+const IS = new RegExp(`^(!?)\\s*${NAME}$`);
+const CMP = new RegExp(`^${NAME}\\s*(==|!=|<=|>=|<|>)\\s*${NUM}$`);
+const AFTER = new RegExp(`^@after\\(\\s*${NUM}\\s*\\)$`);
+function parseCondition(src) {
+  const parts = [""];
+  for (const token of src.split(/("(?:[^"\\]|\\.)*"|&&)/)) {
+    if (token === "&&") parts.push("");
+    else parts[parts.length - 1] += token;
+  }
+  const terms = [];
+  for (const raw of parts) {
+    const t = raw.trim();
+    let m;
+    if (t === "@end") terms.push({ k: "end" });
+    else if (m = AFTER.exec(t)) {
+      const s = Number(m[1]);
+      if (s < 0) return V ? "@after needs a time \u2265 0" : "";
+      terms.push({ k: "after", s });
+    } else if (m = IS.exec(t)) terms.push({ k: "is", name: m[2], not: m[1] === "!" });
+    else if (m = CMP.exec(t))
+      terms.push({ k: "cmp", name: m[1], op: m[2], value: Number(m[3]) });
+    else if (m = /^(.+?)\s*(==|!=|<=|>=|<|>)\s*(.+)$/.exec(t))
+      terms.push({ k: "expr", a: m[1], op: m[2], b: m[3] });
+    else return V ? t ? `cannot read "${t}"` : "empty term" : "";
+  }
+  return terms;
+}
+function compare(x, y, op) {
+  return { "==": x === y, "!=": x !== y, "<": x < y, "<=": x <= y, ">": x > y, ">=": x >= y }[op];
+}
+function literalCondition(model, term, at, d) {
+  const call = /^([a-z][a-zA-Z0-9-]*)\(\s*("(?:[^"\\]|\\.)*")\s*\)$/.exec(term.b.trim());
+  const functions = model.guardLiterals;
+  const resolve = call && functions && Object.hasOwn(functions, call[1]) && functions[call[1]];
+  if (!resolve) return false;
+  let value;
+  try {
+    value = resolve(JSON.parse(call[2]), term.a.trim());
+  } catch {
+  }
+  if (value === void 0 || !["==", "!="].includes(term.op))
+    d.err(
+      "guard-literal",
+      at,
+      V && "literal function does not match the property or comparison",
+      V && "use == or != with a declared name and the matching property type"
+    );
+  term.test = (scope) => compare(scope.get(term.a.trim()), value, term.op);
+  return true;
+}
+export {
+  compare,
+  literalCondition,
+  parseCondition
+};

package/packages/core/src/diag.d.ts

@@ -0,0 +1,25 @@
+/** A load or validation finding (spec §2 "Strictness", codes in §11.3). */
+export interface Diagnostic {
+    code: string;
+    severity: 'error' | 'warning';
+    /** RFC 6901 JSON pointer to the offending value; "" is the document. */
+    pointer: string;
+    message: string;
+    hint?: string;
+}
+type Text = string | false | undefined;
+/** `s` in verbose builds, '' in the terse browser build (terser inlines the call away). */
+export declare const text: (s: string) => string;
+export declare class Diags {
+    features?: string[];
+    readonly list: Diagnostic[];
+    /** Returns undefined, so `return d.err(…)` ends a function that returns a value or nothing. */
+    err(code: string, pointer: string, message?: Text, hint?: Text, severity?: Diagnostic['severity']): undefined;
+    warn(code: string, pointer: string, message?: Text): void;
+    get failed(): boolean;
+}
+/** Append one reference token to a JSON pointer. */
+export declare const ptr: (base: string, key: string | number) => string;
+/** `did you mean "x"?` for the closest option, if it is close enough. */
+export declare function suggest(word: string, options: Iterable<string>): string | undefined;
+export {};

package/packages/core/src/diag.js

@@ -0,0 +1,49 @@
+import { VERBOSE as V } from "./flags.js";
+const text = (s) => V ? s : "";
+class Diags {
+  list = [];
+  /** Returns undefined, so `return d.err(…)` ends a function that returns a value or nothing. */
+  err(code, pointer, message, hint, severity = "error") {
+    const x = { code, severity, pointer, message: message || code };
+    if (hint) x.hint = hint;
+    this.list.push(x);
+  }
+  warn(code, pointer, message) {
+    this.err(code, pointer, message, false, "warning");
+  }
+  get failed() {
+    return this.list.some((d) => d.severity === "error");
+  }
+}
+const ptr = (base, key) => base + "/" + String(key).replace(/~/g, "~0").replace(/\//g, "~1");
+function distance(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    let prev = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const cur = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+      prev = cur;
+    }
+  }
+  return row[b.length];
+}
+function suggest(word, options) {
+  let best;
+  let bestD = Infinity;
+  const lw = word.toLowerCase();
+  for (const o of options) {
+    const lo = o.toLowerCase();
+    const stem = lw.length > 3 && lo.length > 3 && (lw.startsWith(lo.slice(0, 5)) || lo.startsWith(lw.slice(0, 5)));
+    const d = stem ? 1 : distance(lw, lo);
+    if (d < bestD) [best, bestD] = [o, d];
+  }
+  return best !== void 0 && bestD <= Math.max(2, Math.ceil(word.length / 3)) ? `did you mean "${best}"?` : void 0;
+}
+export {
+  Diags,
+  ptr,
+  suggest,
+  text
+};

package/packages/core/src/draw.d.ts

@@ -0,0 +1,166 @@
+import { type Mat } from './geom.js';
+import type { Model } from './load.js';
+import type { Player } from './player.js';
+export type DrawColor = string | {
+    slot: string;
+    fallback: string;
+};
+export interface DrawPaint {
+    kind: 'fill' | 'stroke';
+    blend?: string;
+    blendAmount?: number;
+    geometry?: Geometry;
+    key?: string;
+    color?: DrawColor;
+    type?: 'linear' | 'radial' | 'angular';
+    gradientTransform?: Mat;
+    image?: {
+        source: string;
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+        rotate: number;
+        scaleX: number;
+        scaleY: number;
+        modulate?: number[];
+    };
+    feather?: {
+        inner: number;
+        outer: number;
+        offset: [number, number];
+        enabled: boolean;
+        space?: string;
+    };
+    coordinates?: Record<string, number>;
+    stops?: {
+        position: number;
+        color: DrawColor;
+    }[];
+    rule?: string;
+    visible: boolean;
+    width?: number;
+    cap?: string;
+    join?: string;
+    trim?: {
+        start: number;
+        end: number;
+        offset: number;
+    };
+    dash?: number[];
+    /** Authored fractions retained as neutral unit metadata; backends use resolved grid lengths. */
+    dashNormalized?: number[];
+    dashOffsetNormalized?: number;
+    dashOffset?: number;
+    scale?: string;
+    position?: string;
+}
+export interface Geometry {
+    image?: {
+        asset: string;
+        source: string;
+        width?: number;
+        height?: number;
+        fit: string;
+        align: string;
+        sampling: string;
+        wrap?: string;
+        wrapX?: string;
+        wrapY?: string;
+    };
+    kind: string;
+    d?: string;
+    cx?: number;
+    cy?: number;
+    r?: number;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    rx?: number;
+}
+export declare function geometryLength(g: Geometry | undefined, owner?: object): number;
+export interface DrawEntry {
+    imageWrap?: boolean;
+    pointer?: string;
+    /** Scoped identity supplied by nested draw trees. */
+    id?: string;
+    node: number;
+    kind: string;
+    parent: number;
+    children: number[];
+    /** Node slots whose changes invalidate this entry (including spatial sources). */
+    dependencies?: number[];
+    knockout?: number;
+    blend?: string;
+    mask?: DrawNode['mask'];
+    clip?: DrawNode['clip'];
+    paints?: DrawPaint[];
+    slice?: {
+        x: number[];
+        y: number[];
+        width: number;
+        height: number;
+        modes: string[];
+    };
+    position?: string;
+}
+export interface DrawTree {
+    nodes: DrawEntry[];
+    roots: number[];
+    resources: {
+        node: number;
+        kind: string;
+        key?: string;
+        source?: number;
+        paint?: DrawPaint;
+        pointer?: string;
+    }[];
+}
+export interface DrawNode {
+    mesh?: {
+        points: number[];
+        uv: number[];
+        triangles: number[][];
+    };
+    transform: Mat;
+    world?: Mat;
+    opacity: number;
+    visible: boolean;
+    geometry?: Geometry;
+    paints: DrawPaint[];
+    blend?: string;
+    blendAmount?: number;
+    mask?: {
+        source: number;
+        mode: string;
+        sourceDraws: boolean;
+    };
+    clip?: {
+        source: number;
+        rule: string;
+    };
+    patches?: {
+        source: number[];
+        target: number[];
+        mode: string;
+    }[];
+}
+export interface DrawFrame {
+    /** Resolved sibling ranks, indexed by node. Absent means authored order. */
+    order?: number[];
+    revision: number;
+    tree: DrawTree;
+    nodes: DrawNode[];
+    viewBox: Model['viewBox'];
+    /** Entries whose resolved drawing changed since the preceding frame. */
+    changed: number[];
+}
+export declare function drawTree(model: Model): DrawTree;
+export declare const drawColor: (p: Player, value: unknown) => DrawColor;
+export declare function drawPaint(p: Player, i: number, kind: 'fill' | 'stroke', key?: string, raw?: any): DrawPaint | undefined;
+export declare const fmt: (v: number) => string;
+export declare function drawFrame(p: Player): DrawFrame;
+export declare function drawOrder(f: DrawFrame, nodes: number[]): number[];
+/** Geometry-to-artboard matrix, including module drawing transforms. */
+export declare function drawWorld(p: Player, i: number, frame?: DrawFrame | undefined): Mat;