animl 0.0.0-stage → 0.1.0

package/modules/posepad/manifest.d.ts

@@ -0,0 +1,35 @@
+export declare const after: string[];
+declare const _default: {
+    after: string[];
+    name: string;
+    summary: string;
+    core: {
+        entry: string;
+        export: string;
+    };
+    web: ({
+        name: string;
+        budget: number;
+        heavy: boolean;
+        over?: undefined;
+    } | {
+        name: string;
+        budget: number;
+        over: string;
+        heavy: boolean;
+    })[];
+    adapters: {
+        'packages/core/src/modules/posepad/index.ts': string;
+        'packages/web/src/posepad.ts': string;
+        'packages/web/src/posepad-handle.ts': string;
+    };
+    exports: {
+        'core:./posepad': string;
+        'web:./posepad': string;
+        'web:./posepad-handle': string;
+    };
+    tests: string[];
+    conformance: string[];
+    docs: string[];
+};
+export default _default;

package/modules/posepad/manifest.js

@@ -0,0 +1,46 @@
+const after = ["layout", "rig"];
+var manifest_default = {
+  ...{
+    name: "posepad",
+    summary: "Pose pads: a draggable handle whose position blends poses (joystick-style, one or two axes).",
+    after: [],
+    core: {
+      entry: "core/index.ts",
+      export: "posepad"
+    },
+    web: [
+      // P3c reset rule: 772 B after the P8-5 tuple printer.
+      { name: "posepad", budget: 896, heavy: true },
+      { name: "posepad-handle", budget: 512, over: "posepad", heavy: true }
+    ],
+    adapters: {
+      "packages/core/src/modules/posepad/index.ts": "core/index.ts",
+      "packages/web/src/posepad.ts": "web/index.ts",
+      "packages/web/src/posepad-handle.ts": "web/handle.ts"
+    },
+    exports: {
+      "core:./posepad": "packages/core/src/modules/posepad/index.ts",
+      "web:./posepad": "packages/web/src/posepad.ts",
+      "web:./posepad-handle": "packages/web/src/posepad-handle.ts"
+    },
+    tests: [
+      "modules/posepad/test/**/*.test.ts",
+      "packages/markup/test/corpus.test.ts",
+      "packages/markup/test/names.test.ts",
+      "packages/markup/test/compile.test.ts",
+      "packages/markup/test/decompile.test.ts"
+    ],
+    conformance: [
+      "rigging-joystick",
+      "animation-joystick-two-axis",
+      "animation-joystick-invert",
+      "animation-joystick-handle"
+    ],
+    docs: ["spec/SPEC.md"]
+  },
+  after
+};
+export {
+  after,
+  manifest_default as default
+};

package/modules/posepad/web/handle.d.ts

@@ -0,0 +1 @@
+import './index.js';

package/modules/posepad/web/handle.js

@@ -0,0 +1,4 @@
+import "./index.js";
+import { handles } from "../core/handle.js";
+const Icon = customElements.get("anima-icon");
+Icon.modules.get("posepad").handles ??= handles;

package/modules/posepad/web/index.d.ts

@@ -0,0 +1 @@
+import '../../../packages/web/src/index.js';

package/modules/posepad/web/index.js

@@ -0,0 +1,3 @@
+import { posepad } from "../core/index.js";
+import "../../../packages/web/src/index.js";
+customElements.get("anima-icon").registerModule(posepad);

package/modules/rig/core/all.d.ts

@@ -0,0 +1,2 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+export declare const rig: Module;

package/modules/rig/core/all.js

@@ -0,0 +1,13 @@
+import { rig as base } from "./index.js";
+import { installOrigin } from "./origin.js";
+const rig = {
+  ...base,
+  init(registry, shared) {
+    const active = base.init?.call(base, registry, shared) ?? base;
+    installOrigin(active.origin, registry.get("bind"));
+    return active;
+  }
+};
+export {
+  rig
+};

package/modules/rig/core/api.d.ts

@@ -0,0 +1,55 @@
+import type { Model } from '../../../packages/core/src/load.js';
+import type { Player } from '../../../packages/core/src/player.js';
+import type { ObjShape } from '../../../packages/core/src/registry.js';
+import { type Mat } from '../../../packages/core/src/geom.js';
+/** Structurally checked JSON, shared with independently loaded constraint modules. */
+export type Constraint = {
+    kind: string;
+    strength?: number;
+    [key: string]: any;
+};
+export interface RigContext {
+    readonly player: Player;
+    readonly model: Model;
+    /** Solved world frame: bones start at (0,0); ordinary nodes retain grid coordinates. */
+    world(node: number): Mat;
+    /** Replace a solved frame. A solver that writes other nodes declares them in writes(). */
+    setWorld(node: number, matrix: Mat): void;
+    /** Document rest frame, in the same coordinate convention as world(). */
+    rest(node: number): Mat;
+    /** World pivot (bone start), optionally evaluated in a supplied frame. */
+    position(node: number, matrix?: Mat): [number, number];
+    num(node: number, k: number, key: string, fallback: number): number;
+    blend(a: Mat, b: Mat, strength: number, node?: number): Mat;
+    i(): void;
+}
+export interface ConstraintKind {
+    kind: string;
+    /** Object fields for both JSON and structural AniML; kind/strength are added by rig. */
+    shape: ObjShape;
+    /** Referenced node ids. Missing ids are diagnosed by rig before solve. */
+    targets(raw: Constraint, model: Model): string[];
+    /** Additional node indices written by this solver, excluding its host. */
+    writes?(raw: Constraint, node: number, model: Model): number[];
+    /** Return the host's desired world frame, or mutate frames with ctx.setWorld(). */
+    solve(ctx: RigContext, node: number, raw: Constraint, k: number): Mat | void;
+}
+export declare const constraintKinds: Map<string, ConstraintKind>;
+/** Derived values other modules add to `Player.values()`, called by rig's single wrapper in
+ *  registration (dependency) order, so key order never depends on module arrival order. */
+export declare const valueProviders: Map<string, (player: Player, out: Record<string, unknown>) => void>;
+export declare function registerConstraint(kind: ConstraintKind): void;
+declare module '../../../packages/core/src/load.ts' {
+    interface Model {
+        /** Pose after the first solve; true requests exactly one additional solve. */
+        rigPose?: (player: Player) => boolean;
+    }
+}
+/** The call site stays in the rig module: no branch in a non-rig Player.step(). */
+export declare function solvePasses(ctx: RigContext, solve: () => void): void;
+export declare function position(matrix: Mat, pivot?: readonly number[]): [number, number];
+/** QR decomposition with signed Y scale, shear, and deterministic singular-axis fallback. */
+export declare function decompose(m: Mat, pivot?: readonly number[]): number[];
+export declare function compose(v: number[], pivot?: readonly number[]): Mat;
+/** Componentwise blend around the same pivot; shortest arc, +π wins a half-turn tie. */
+export declare function blend(a: Mat, b: Mat, strength: number, pivot?: readonly number[]): Mat;

package/modules/rig/core/api.js

@@ -0,0 +1,43 @@
+import { apply } from "../../../packages/core/src/geom.js";
+const constraintKinds = /* @__PURE__ */ new Map();
+const valueProviders = /* @__PURE__ */ new Map();
+function registerConstraint(kind) {
+  constraintKinds.set(kind.kind, kind);
+}
+function solvePasses(ctx, solve) {
+  solve();
+  if (ctx.model.rigPose?.(ctx.player)) solve();
+}
+function position(matrix, pivot = [0, 0]) {
+  return apply(matrix, pivot[0], pivot[1]);
+}
+function decompose(m, pivot = [0, 0]) {
+  const sx = Math.hypot(m[0], m[1]), angle = sx ? Math.atan2(m[1], m[0]) : Math.atan2(-m[2], m[3]), c = Math.cos(angle), s = Math.sin(angle);
+  return [...position(m, pivot), angle, sx, -s * m[2] + c * m[3], c * m[2] + s * m[3]];
+}
+function compose(v, pivot = [0, 0]) {
+  const [x, y, r, sx, sy, h] = v, c = Math.cos(r), s = Math.sin(r), a = c * sx, b = s * sx, u = c * h - s * sy, w = s * h + c * sy;
+  return [a, b, u, w, x - a * pivot[0] - u * pivot[1], y - b * pivot[0] - w * pivot[1]];
+}
+function blend(a, b, strength, pivot) {
+  if (strength <= 0) return a;
+  if (strength >= 1) return b;
+  const x = decompose(a, pivot), y = decompose(b, pivot), tau = 2 * Math.PI;
+  let delta = ((y[2] - x[2]) % tau + tau) % tau;
+  if (delta > Math.PI) delta -= tau;
+  y[2] = x[2] + delta;
+  return compose(
+    x.map((v, i) => v + (y[i] - v) * strength),
+    pivot
+  );
+}
+export {
+  blend,
+  compose,
+  constraintKinds,
+  decompose,
+  position,
+  registerConstraint,
+  solvePasses,
+  valueProviders
+};

package/modules/rig/core/constraints.d.ts

@@ -0,0 +1,10 @@
+import { type Mat } from '../../../packages/core/src/geom.js';
+import type { Shape } from '../../../packages/core/src/registry.js';
+import { type RigContext } from './api.js';
+export declare const number: (min?: number, max?: number) => Shape;
+export declare const origin: {
+    point?: (ctx: RigContext, node: number, uv: number[], frame: Mat) => [number, number];
+};
+export declare const space: Shape;
+export declare function parentFrame(ctx: RigContext, i: number, rest?: boolean): Mat;
+export declare function registerCopies(): void;

package/modules/rig/core/constraints.js

@@ -0,0 +1,96 @@
+import { IDENTITY, mul, clamp } from "../../../packages/core/src/geom.js";
+import { compose, decompose, registerConstraint } from "./api.js";
+import { bone, inverse, pivot } from "./solve.js";
+const number = (min, max) => ({ k: "num", min, max });
+const string = (of) => ({ k: "str", of });
+const origin = {};
+const space = string(["world", "local"]);
+const spaces = { fromSpace: space, toSpace: space };
+function parentFrame(ctx, i, rest = false) {
+  const p = ctx.model.nodes[i].parent;
+  if (p < 0) return IDENTITY;
+  let m = rest ? ctx.rest(p) : ctx.world(p);
+  if (bone(ctx.model, p) && !(bone(ctx.model, i) && !ctx.model.nodes[i].raw.root)) {
+    let a = p;
+    while (bone(ctx.model, a)) a = ctx.model.nodes[a].parent;
+    m = mul(mul(m, inverse(ctx.rest(p))), ctx.rest(a));
+  }
+  return m;
+}
+const inSpace = (ctx, i, m, s, rest = false) => s === "local" ? mul(inverse(parentFrame(ctx, i, rest)), m) : m;
+const outSpace = (ctx, i, m, s) => s === "local" ? mul(parentFrame(ctx, i), m) : m;
+function registerCopies() {
+  for (const [kind, axis] of [
+    ["copyPosition", 0],
+    ["copyRotation", 2],
+    ["copyScale", 3],
+    ["copyTransform", -1]
+  ]) {
+    const vector = axis === 0 || axis === 3;
+    const shape = {
+      k: "obj",
+      p: {
+        from: string(),
+        ...spaces,
+        ...axis === -1 ? { origin: { k: "tup", of: [number(), number()], min: 2 } } : {
+          limitSpace: space,
+          offset: { k: "bool" },
+          ...vector ? {
+            factorX: number(),
+            factorY: number(),
+            copyX: { k: "bool" },
+            copyY: { k: "bool" },
+            minX: number(),
+            maxX: number(),
+            minY: number(),
+            maxY: number()
+          } : { factor: number(), min: number(), max: number() }
+        }
+      },
+      req: axis === -1 ? ["from"] : []
+    };
+    registerConstraint({
+      kind,
+      shape,
+      targets: (r) => r.from ? [r.from] : [],
+      solve(ctx, i, r, k) {
+        const j = ctx.model.ids.get(r.from), pv = pivot(ctx.model, i), target = j === void 0 ? r.fromSpace === "local" ? IDENTITY : parentFrame(ctx, i) : inSpace(ctx, j, ctx.world(j), r.fromSpace), source = decompose(
+          target,
+          j === void 0 ? r.fromSpace === "local" ? void 0 : pivot(ctx.model, ctx.model.nodes[i].parent) : pivot(ctx.model, j)
+        ), current = decompose(inSpace(ctx, i, ctx.world(i), r.toSpace), pv), rest = decompose(inSpace(ctx, i, ctx.rest(i), r.toSpace, true), pv);
+        if (axis === -1) {
+          current.splice(0, 6, ...source);
+          const value = ctx.player.prop(i, `constraints.${k}.origin`) ?? r.origin;
+          if (j !== void 0 && Array.isArray(value) && origin.point)
+            [current[0], current[1]] = origin.point(ctx, j, value, target);
+        } else
+          for (let a = 0; a < (vector ? 2 : 1); a++) {
+            const suffix = vector ? "XY"[a] : "", index = axis + a;
+            if (r["copy" + suffix] === false) continue;
+            current[index] = source[index] * ctx.num(i, k, "factor" + suffix, 1) * (axis === 3 && r.offset ? rest[index] : 1) + (axis !== 3 && r.offset ? rest[index] : 0);
+          }
+        let desired = outSpace(ctx, i, compose(current, pv), r.toSpace);
+        if (axis !== -1) {
+          const limited = (r.limitSpace ?? r.toSpace ?? "world") === (r.toSpace ?? "world") ? current : decompose(inSpace(ctx, i, desired, r.limitSpace), pv);
+          for (let a = 0; a < (vector ? 2 : 1); a++) {
+            const suffix = vector ? "XY"[a] : "", index = axis + a, units = axis === 2 ? 180 / Math.PI : 1;
+            limited[index] = clamp(
+              limited[index] * units,
+              ctx.num(i, k, "min" + suffix, -Infinity),
+              ctx.num(i, k, "max" + suffix, Infinity)
+            ) / units;
+          }
+          desired = outSpace(ctx, i, compose(limited, pv), r.limitSpace ?? r.toSpace);
+        }
+        return desired;
+      }
+    });
+  }
+}
+export {
+  number,
+  origin,
+  parentFrame,
+  registerCopies,
+  space
+};

package/modules/rig/core/distance.d.ts

@@ -0,0 +1,2 @@
+import { type ConstraintKind } from './api.js';
+export declare function registerDistance(register?: (c: ConstraintKind) => void): void;

package/modules/rig/core/distance.js

@@ -0,0 +1,27 @@
+import { registerConstraint } from "./api.js";
+function registerDistance(register = registerConstraint) {
+  register({
+    kind: "keepDistance",
+    shape: {
+      k: "obj",
+      p: {
+        to: { k: "str" },
+        distance: { k: "num", min: 0 },
+        mode: { k: "str", of: ["within", "beyond", "exact"] }
+      },
+      req: ["to", "distance"]
+    },
+    targets: (r) => [r.to],
+    solve(ctx, i, r, k) {
+      const m = [...ctx.world(i)], a = ctx.position(i), b = ctx.position(ctx.model.ids.get(r.to)), x = a[0] - b[0], y = a[1] - b[1], length = Math.hypot(x, y), d = ctx.num(i, k, "distance", 0);
+      if (r.mode === "exact" || (r.mode === "beyond" ? length < d : length > d)) {
+        m[4] += (length ? x / length : 1) * d - x;
+        m[5] += (length ? y / length : 0) * d - y;
+      }
+      return m;
+    }
+  });
+}
+export {
+  registerDistance
+};

package/modules/rig/core/index.d.ts

@@ -0,0 +1,12 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+import { constraintKinds, registerConstraint, type RigContext } from './api.js';
+import { origin } from './constraints.js';
+export * from './api.js';
+export { contexts, bone, pivot } from './solve.js';
+export interface RigModule extends Module {
+    registerConstraint: typeof registerConstraint;
+    kinds: typeof constraintKinds;
+    origin: typeof origin;
+    context(player: import('../../../packages/core/src/player.js').Player): RigContext | undefined;
+}
+export declare const rig: RigModule;

package/modules/rig/core/index.js

@@ -0,0 +1,243 @@
+import { check } from "../../../packages/core/src/check.js";
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { nodePointer } from "../../components/core/node-pointer.js";
+import { apply } from "../../../packages/core/src/geom.js";
+import {
+  constraintKinds,
+  valueProviders,
+  registerConstraint,
+  decompose
+} from "./api.js";
+import { bone, pivot, install, contexts } from "./solve.js";
+import { constraintElements } from "../markup/elements.js";
+import { number, origin, registerCopies } from "./constraints.js";
+import { registerDistance } from "./distance.js";
+import { after } from "../manifest.js";
+export * from "./api.js";
+import { contexts as contexts2, bone as bone2, pivot as pivot2 } from "./solve.js";
+const shape = {
+  k: "alt",
+  get of() {
+    return [...constraintKinds.values()].map((c) => ({
+      k: "obj",
+      p: { kind: { k: "str", of: [c.kind] }, strength: number(0, 1), ...c.shape.p },
+      req: ["kind", ...c.shape.req ?? []]
+    }));
+  }
+};
+const constraints = {
+  k: "arr",
+  of: { k: "any" },
+  ...V ? { schema: { k: "arr", of: shape } } : {},
+  element: "constraint"
+};
+const rig = {
+  name: "rig",
+  after,
+  registerConstraint,
+  kinds: constraintKinds,
+  origin,
+  context: (p) => contexts.get(p),
+  entries: [
+    {
+      target: "bone",
+      node: {},
+      shapes: { length: number(0), root: { k: "bool" }, children: { k: "arr", of: { k: "node" } } },
+      props: { length: { type: "number", def: 0, min: 0 } }
+    },
+    { target: "node", shapes: { constraints } }
+  ],
+  init(_registry, shared) {
+    constraintKinds.clear();
+    valueProviders.clear();
+    registerCopies();
+    if (V) registerDistance();
+    if (V)
+      Object.defineProperty(rig.entries[1], "elements", {
+        configurable: true,
+        get: () => constraintElements(constraintKinds)
+      });
+    const values = shared.Player.prototype.values;
+    if (!shared.Player.prototype.rigValues) {
+      shared.Player.prototype.rigValues = true;
+      shared.Player.prototype.values = function() {
+        const out = values.call(this), ctx = contexts.get(this);
+        if (ctx)
+          for (const [i, n] of this.model.nodes.entries()) {
+            const v = decompose(ctx.world(i), pivot(this.model, i));
+            if (v[2] === Math.PI) v[2] = -Math.PI;
+            ["x", "y", "rotate", "scaleX", "scaleY"].forEach(
+              (key, k) => out[n.id + ".world." + key] = v[k] * (k === 2 ? 180 / Math.PI : 1)
+            );
+            if (bone(this.model, i)) {
+              const tip = apply(ctx.world(i), this.num(i, "length", 0), 0);
+              out[n.id + ".tip.x"] = tip[0];
+              out[n.id + ".tip.y"] = tip[1];
+            }
+          }
+        for (const add of valueProviders.values()) add(this, out);
+        return out;
+      };
+    }
+    return rig;
+  },
+  model(n, key) {
+    const match = /^constraints\.(0|[1-9]\d*)\.(\w+)$/.exec(key);
+    if (!match) return;
+    const raw = n.raw.constraints?.[+match[1]], field = match[2];
+    if (!raw) return;
+    const s = field === "strength" ? number(0, 1) : constraintKinds.get(raw?.kind)?.shape.p[field];
+    if (s?.k !== "num" && !(s?.k === "tup" && field === "origin")) return;
+    return {
+      prop: {
+        type: s.k === "num" ? "number" : "point",
+        min: s.k === "num" ? s.min : void 0,
+        max: s.k === "num" ? s.max : void 0,
+        feature: "rig"
+      },
+      rest: s.k === "tup" ? raw[field] ?? [0, 0] : raw[field] ?? s.default ?? (field.startsWith("min") ? -Infinity : field.startsWith("max") ? Infinity : field === "strength" || field.startsWith("factor") ? 1 : 0)
+    };
+  },
+  value(_addr, value, pointer, d) {
+    if (typeof value === "string") {
+      try {
+        value = JSON.parse(value);
+      } catch {
+      }
+    }
+    if (Array.isArray(value) && value.length === 2 && value.every((x) => typeof x === "number" && Number.isFinite(x)))
+      return value;
+    d.err("value-type", pointer, V && "origin needs two finite numbers", V && "use [u,v]");
+  },
+  prepare(model, d) {
+    if (!model.doc.requires?.includes("rig")) return;
+    for (const [i, n] of model.nodes.entries())
+      for (const [k, r] of (n.raw.constraints ?? []).entries()) {
+        const kind = constraintKinds.get(r?.kind);
+        check(
+          r,
+          {
+            ...kind?.shape,
+            k: "obj",
+            p: {
+              kind: { k: "str", of: kind ? [kind.kind] : [...constraintKinds.keys()] },
+              strength: number(0, 1),
+              ...kind?.shape.p
+            },
+            req: ["kind", ...kind?.shape.req ?? []]
+          },
+          nodePointer(model, i) + "/constraints/" + k,
+          d,
+          0
+        );
+      }
+  },
+  load(model, _raw, d) {
+    if (d.failed || !model.doc.requires?.includes("rig")) return;
+    const edges = model.nodes.map(() => /* @__PURE__ */ new Set()), order = [];
+    model.nodes.forEach((n, i) => {
+      if (n.parent >= 0) edges[n.parent].add(i);
+    });
+    const reach = (from, to, seen = /* @__PURE__ */ new Set()) => {
+      if (from === to) return true;
+      if (seen.has(from)) return false;
+      seen.add(from);
+      return [...edges[from]].some((i) => reach(i, to, seen));
+    };
+    const link = (from, to, at) => {
+      if (reach(to, from))
+        d.err(
+          "rig-cycle",
+          at,
+          V && "constraint closes a dependency cycle",
+          V && "target a node outside the constrained subtree"
+        );
+      else edges[from].add(to);
+    };
+    for (const [i, n] of model.nodes.entries()) {
+      const at = nodePointer(model, i);
+      if (bone(model, i)) {
+        for (let a = i; a >= 0; a = model.nodes[a].parent) {
+          if (["scale", "scaleX", "scaleY"].some((k) => model.nodes[a].raw[k] === 0))
+            d.err(
+              "bad-value",
+              at,
+              V && "bone rest frames must be invertible",
+              V && "use nonzero rest scales; animate collapse from a nonzero rest pose"
+            );
+        }
+        if (n.raw.pivot !== void 0)
+          d.err(
+            "rig-bone-pivot",
+            at + "/pivot",
+            V && "bones pivot at their start",
+            V && "remove pivot"
+          );
+        if (bone(model, n.parent) && !n.raw.root) {
+          for (const key of ["x", "y"])
+            if (n.raw[key] !== void 0 || model.addrs.has(n.id + "." + key))
+              d.err(
+                "rig-bone-offset",
+                n.raw[key] === void 0 ? at : at + "/" + key,
+                V && "a chained bone starts at its parent tip",
+                V && "remove x/y or set root=true"
+              );
+        }
+        if (n.parent >= 0 && !["group", "bone"].includes(model.nodes[n.parent].type))
+          d.err(
+            "rig-bone-parent",
+            at,
+            V && "bone parent cannot contain a chain",
+            V && "wrap the bones in a <group>"
+          );
+      }
+      (n.raw.constraints ?? []).forEach((r, k) => {
+        const kind = constraintKinds.get(r.kind), pointer = at + "/constraints/" + k;
+        if (r.kind === "copyTransform" && !origin.point && (r.origin !== void 0 || model.addrs.has(n.id + `.constraints.${k}.origin`)))
+          d.err(
+            "rig-origin",
+            pointer + "/origin",
+            V && "transform origin support is not installed",
+            V && "import @anima-format/web/rig-origin"
+          );
+        for (const id of kind.targets(r, model)) {
+          const j = model.ids.get(id);
+          if (j === void 0)
+            d.err(
+              "rig-target",
+              pointer,
+              V && "unknown constraint target " + id,
+              V && "use an existing node id"
+            );
+          else link(j, i, pointer);
+        }
+        const writes = kind.writes?.(r, i, model) ?? [];
+        for (const j of writes) {
+          if (j !== i && !reach(i, j)) link(j, i, pointer);
+          for (const child of model.nodes[j]?.children ?? [])
+            if (child !== i && !writes.includes(child)) link(i, child, pointer);
+        }
+      });
+    }
+    const visited = [];
+    const visit = (i) => {
+      if (visited[i]) return;
+      visited[i] = true;
+      edges[i].forEach(visit);
+      order.push(i);
+    };
+    edges.forEach((_, i) => visit(i));
+    if (!d.failed) install(model, order.reverse());
+  },
+  draw: {
+    tree(model, tree) {
+      for (const [i] of model.nodes.entries()) if (bone(model, i)) tree.nodes[i].kind = "group";
+    }
+  }
+};
+export {
+  bone2 as bone,
+  contexts2 as contexts,
+  pivot2 as pivot,
+  rig
+};

package/modules/rig/core/origin.d.ts

@@ -0,0 +1,6 @@
+import { type Mat } from '../../../packages/core/src/geom.js';
+import type { Module } from '../../../packages/core/src/modules.js';
+import type { RigContext } from './api.js';
+export declare function installOrigin(target?: {
+    point?: (ctx: RigContext, node: number, uv: number[], frame: Mat) => [number, number];
+}, bind?: Module): void;