animl 0.0.0-stage → 0.1.0

package/modules/pathfollow/core/index.js

@@ -0,0 +1,164 @@
+import { apply, invert, mul } from "../../../packages/core/src/geom.js";
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { nodePointer } from "../../components/core/node-pointer.js";
+import {
+  blend,
+  compose,
+  decompose,
+  registerConstraint
+} from "../../rig/core/api.js";
+import { entries as followEntries } from "../capabilities/rigging-follow-path/registry.js";
+import { entries as listEntries } from "../capabilities/rigging-list-follow-path/registry.js";
+import { after } from "../manifest.js";
+import { pathMeasure } from "./measure.js";
+const number = { k: "num" };
+const boolean = { k: "bool" };
+let outlines = [];
+let activeRig;
+function pivot(ctx, node) {
+  const n = ctx.model.nodes[node];
+  return n.type === "bone" ? [0, 0] : n.raw.pivot ?? [0, 0];
+}
+function sample(ctx, id, fraction) {
+  const target = ctx.model.ids.get(id);
+  if (target === void 0) return;
+  const local = pathMeasure(ctx.player, target, outlines)?.at(fraction);
+  if (!local) return;
+  const world = ctx.world(target), point = apply(world, local[0], local[1]), dx = world[0] * local[2] + world[2] * local[3], dy = world[1] * local[2] + world[3] * local[3];
+  return [point[0], point[1], Math.atan2(dy, dx)];
+}
+function placed(ctx, node, point, orient, offset) {
+  const current = ctx.world(node), values = decompose(current, pivot(ctx, node));
+  values[0] = point[0];
+  values[1] = point[1];
+  if (orient) values[2] = point[2];
+  if (offset) {
+    const n = ctx.model.nodes[node], parent = n.parent, frame = parent < 0 ? [1, 0, 0, 1, 0, 0] : ctx.world(parent), dx = ctx.player.num(node, "x", n.raw.x ?? 0) - (n.raw.x ?? 0), dy = ctx.player.num(node, "y", n.raw.y ?? 0) - (n.raw.y ?? 0);
+    values[0] += frame[0] * dx + frame[2] * dy;
+    values[1] += frame[1] * dx + frame[3] * dy;
+  }
+  return compose(values, pivot(ctx, node));
+}
+function spread(ctx, node, raw, k) {
+  const children = ctx.model.nodes[node].children, count = children.length, start = ctx.num(node, k, "start", 0), end = ctx.num(node, k, "end", 1), shift = ctx.num(node, k, "shift", 0), strength = ctx.num(node, k, "strength", 1);
+  children.forEach((child, index) => {
+    const point = sample(
+      ctx,
+      raw.path,
+      start + (end - start) * index / Math.max(count - 1, 1) + shift
+    );
+    if (!point) return;
+    const current = ctx.world(child), desired = placed(ctx, child, point, !!raw.orient, false);
+    ctx.setWorld(child, ctx.blend(current, desired, strength, child));
+  });
+}
+let activeLists;
+function placeRepeats(player, frame) {
+  if (!player.model.doc.requires?.includes("pathfollow")) return;
+  const ctx = activeRig?.context(player), state = activeLists?.listState(player);
+  if (!ctx || !frame || !state) return;
+  for (const run of state.runs) {
+    const host = run.spec.node, constraints = player.model.nodes[host].raw.constraints ?? [];
+    for (const [k, raw] of constraints.entries()) {
+      if (raw.kind !== "spreadAlongPath") continue;
+      const count = run.items.length, start = ctx.num(host, k, "start", 0), end = ctx.num(host, k, "end", 1), shift = ctx.num(host, k, "shift", 0), strength = ctx.num(host, k, "strength", 1), hostWorld = ctx.world(host), inverseHost = invert(hostWorld);
+      if (!inverseHost) continue;
+      for (const [index, item] of run.items.entries()) {
+        const point = sample(
+          ctx,
+          raw.path,
+          start + (end - start) * index / Math.max(count - 1, 1) + shift
+        );
+        if (!point) continue;
+        const id = player.model.nodes[host].id + "/" + item.index, group = frame.tree.nodes.findIndex((entry) => entry?.id === id), data = frame.nodes[group];
+        if (group < 0 || !data?.world) continue;
+        const old = data.world, values = decompose(old);
+        values[0] = point[0];
+        values[1] = point[1];
+        if (raw.orient) values[2] = point[2];
+        const next = blend(old, compose(values), strength), oldInverse = invert(old), delta = oldInverse && mul(next, oldInverse);
+        data.transform = mul(inverseHost, next);
+        data.world = next;
+        if (delta) {
+          const visit = (at) => {
+            for (const child of frame.tree.nodes[at].children) {
+              const childData = frame.nodes[child];
+              if (childData?.world) childData.world = mul(delta, childData.world);
+              visit(child);
+            }
+          };
+          visit(group);
+        }
+      }
+    }
+  }
+}
+const pathfollow = {
+  name: "pathfollow",
+  after,
+  entries: [...followEntries, ...listEntries],
+  init(registry) {
+    outlines = [...registry.values()].filter((module) => !!module.outline);
+    activeRig = registry.get("rig");
+    registerConstraint({
+      kind: "alongPath",
+      shape: {
+        k: "obj",
+        p: {
+          path: { k: "str", feature: "pathfollow" },
+          at: number,
+          orient: boolean,
+          offset: boolean
+        },
+        req: ["path"]
+      },
+      targets: (raw) => [raw.path],
+      solve(ctx, node, raw, k) {
+        const point = sample(ctx, raw.path, ctx.num(node, k, "at", 0));
+        if (point) return placed(ctx, node, point, !!raw.orient, !!raw.offset);
+      }
+    });
+    registerConstraint({
+      kind: "spreadAlongPath",
+      shape: {
+        k: "obj",
+        p: {
+          path: { k: "str", feature: "pathfollow" },
+          start: number,
+          end: number,
+          shift: number,
+          orient: boolean
+        },
+        req: ["path"]
+      },
+      targets: (raw) => [raw.path],
+      writes: (_raw, node, model) => model.nodes[node]?.type === "repeat" ? [] : model.nodes[node]?.children ?? [],
+      solve: spread
+    });
+    activeLists = registry.get("lists");
+    return pathfollow;
+  },
+  draw: {
+    end(player, frame) {
+      placeRepeats(player, frame);
+    }
+  },
+  load(model, _raw, d) {
+    if (!model.doc.requires?.includes("pathfollow")) return;
+    for (const [node, n] of model.nodes.entries())
+      for (const [k, raw] of (n.raw.constraints ?? []).entries()) {
+        if (raw.kind !== "alongPath" && raw.kind !== "spreadAlongPath") continue;
+        const target = model.ids.get(raw.path), type = target === void 0 ? void 0 : model.nodes[target].type;
+        if (target !== void 0 && !["path", "contour", "circle", "rect", "arc"].includes(type))
+          d.err(
+            "rig-path-target",
+            nodePointer(model, node) + "/constraints/" + k + "/path",
+            V && "path constraint target is not a measurable shape",
+            V && "target a path, contour, circle, rect or arc node"
+          );
+      }
+  }
+};
+export {
+  pathfollow
+};

package/modules/pathfollow/core/measure.d.ts

@@ -0,0 +1,10 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+import type { Player } from '../../../packages/core/src/player.js';
+type Sample = [number, number, number, number];
+export interface PathMeasure {
+    closed: boolean;
+    at(fraction: number): Sample | undefined;
+}
+/** Private measurement used only by the pathfollow runtime. */
+export declare function pathMeasure(player: Player, node: number, outlineModules?: readonly Module[]): PathMeasure | undefined;
+export {};

package/modules/pathfollow/core/measure.js

@@ -0,0 +1,136 @@
+import { C, L, M, Z, parsePath } from "../../../packages/core/src/path.js";
+const cache = /* @__PURE__ */ new WeakMap();
+const dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
+const mid = (a, b) => [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+function table(paths, closed) {
+  const pieces = [];
+  let total = 0;
+  const line = (a, b, length = dist(a, b)) => {
+    if (length) pieces.push({ a, b, end: total += length });
+  };
+  const cubic = (a, b, c, d, depth) => {
+    const chord = dist(a, d), polygon = dist(a, b) + dist(b, c) + dist(c, d);
+    if (depth === 20 || polygon - chord <= 1e-4) return line(a, d, (polygon + chord) / 2);
+    const ab = mid(a, b), bc = mid(b, c), cd = mid(c, d), abc = mid(ab, bc), bcd = mid(bc, cd), centre = mid(abc, bcd);
+    cubic(a, ab, abc, centre, depth + 1);
+    cubic(centre, bcd, cd, d, depth + 1);
+  };
+  for (const path of paths) {
+    let at = [0, 0], start = at;
+    for (let i = 0; i < path.segs.length; ) {
+      const op = path.segs[i++];
+      if (op === Z) {
+        line(at, start);
+        at = start;
+        continue;
+      }
+      const end = path.segs.slice(i + (op === C ? 4 : 0), i + (op === C ? 6 : 2));
+      if (op === M) start = end;
+      else if (op === C)
+        cubic(
+          at,
+          path.segs.slice(i, i + 2),
+          path.segs.slice(i + 2, i + 4),
+          end,
+          0
+        );
+      else if (op === L) line(at, end);
+      at = end;
+      i += op === C ? 6 : 2;
+    }
+  }
+  return {
+    closed,
+    at(fraction) {
+      if (!pieces.length || !total) return;
+      const f = closed ? (fraction % 1 + 1) % 1 : Math.max(0, Math.min(1, fraction)), target = f * total;
+      let previous = 0, piece = pieces[pieces.length - 1];
+      for (const candidate of pieces)
+        if (target <= candidate.end) {
+          piece = candidate;
+          break;
+        } else previous = candidate.end;
+      const span = piece.end - previous, t = span ? (target - previous) / span : 0, dx = piece.b[0] - piece.a[0], dy = piece.b[1] - piece.a[1];
+      return [piece.a[0] + dx * t, piece.a[1] + dy * t, dx, dy];
+    }
+  };
+}
+function primitive(cx, cy, radius, from, sweep, closed) {
+  return {
+    closed,
+    at(fraction) {
+      if (!(radius > 0) || !(sweep > 0)) return;
+      const f = closed ? (fraction % 1 + 1) % 1 : Math.max(0, Math.min(1, fraction)), angle = (from + sweep * f) * Math.PI / 180, sign = sweep < 0 ? -1 : 1;
+      return [
+        cx + radius * Math.cos(angle),
+        cy + radius * Math.sin(angle),
+        -Math.sin(angle) * sign,
+        Math.cos(angle) * sign
+      ];
+    }
+  };
+}
+function roundedRect(x, y, w, h, radius) {
+  const rx = Math.min(radius, w / 2), ry = Math.min(radius, h / 2);
+  if (!(rx > 0 && ry > 0)) return `M${x} ${y}L${x + w} ${y}L${x + w} ${y + h}L${x} ${y + h}Z`;
+  return `M${x + rx} ${y}L${x + w - rx} ${y}A${rx} ${ry} 0 0 1 ${x + w} ${y + ry}L${x + w} ${y + h - ry}A${rx} ${ry} 0 0 1 ${x + w - rx} ${y + h}L${x + rx} ${y + h}A${rx} ${ry} 0 0 1 ${x} ${y + h - ry}L${x} ${y + ry}A${rx} ${ry} 0 0 1 ${x + rx} ${y}Z`;
+}
+function fromPolys(polys) {
+  const paths = [];
+  for (const poly of polys) {
+    if (poly.pts.length < 2) continue;
+    const segs = [M, poly.pts[0], poly.pts[1]];
+    for (let i = 2; i < poly.pts.length; i += 2) segs.push(L, poly.pts[i], poly.pts[i + 1]);
+    if (poly.closed) segs.push(Z);
+    paths.push({ start: 0, end: 0, absolute: true, segs });
+  }
+  if (!paths.length) return;
+  return table(paths, paths.length === 1 && polys[0].closed);
+}
+function pathMeasure(player, node, outlineModules = []) {
+  const n = player.model.nodes[node];
+  if (!n) return;
+  const r = n.raw, value = (key2, fallback = 0) => player.num(node, key2, fallback);
+  let key = String(n.type), measured;
+  if (n.type === "circle") {
+    const radius = value("r");
+    key += `:${radius}`;
+    measured = primitive(r.center[0], r.center[1], radius, 0, 360, true);
+  } else if (n.type === "arc") {
+    const radius = value("r"), from = value("from"), sweep = Math.min(360, Math.max(0, value("to") - from));
+    key += `:${radius}:${from}:${sweep}`;
+    measured = primitive(r.center[0], r.center[1], radius, from, sweep, false);
+  } else if (n.type === "rect") {
+    const w = value("w"), h = value("h"), rx = value("rx");
+    key += `:${w}:${h}:${rx}:${r.x0}:${r.y0}`;
+    measured = table(parsePath(roundedRect(r.x0, r.y0, w, h, rx)), true);
+  } else if (n.type === "path") {
+    const current = player.value(n.id + ".d"), d = typeof current === "string" ? current : n.d;
+    if (d) {
+      key += ":" + d;
+      const paths = parsePath(d);
+      measured = table(paths, paths.length === 1 && paths[0].segs.at(-1) === Z);
+    }
+  } else if (n.type === "contour") {
+    key += ":" + player.drawVersions[node];
+    for (const module of outlineModules) {
+      const exact = module.pathfollowPath?.(player, node);
+      if (exact) {
+        key += ":" + exact;
+        const paths = parsePath(exact);
+        measured = table(paths, paths.length === 1 && paths[0].segs.at(-1) === Z);
+        break;
+      }
+      const polys = module.outline?.(player, node);
+      if (measured = polys && fromPolys(polys)) break;
+    }
+  }
+  const entries = cache.get(player) ?? /* @__PURE__ */ new Map(), hit = entries.get(node);
+  if (!cache.has(player)) cache.set(player, entries);
+  if (hit?.[0] === key) return hit[1];
+  entries.set(node, [key, measured]);
+  return measured;
+}
+export {
+  pathMeasure
+};

package/modules/pathfollow/core/svg.d.ts

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

package/modules/pathfollow/core/svg.js

@@ -0,0 +1,4 @@
+const pathfollowSVG = {};
+export {
+  pathfollowSVG
+};

package/modules/pathfollow/manifest.d.ts

@@ -0,0 +1,33 @@
+export declare const after: string[];
+declare const _default: {
+    after: string[];
+    name: string;
+    summary: string;
+    core: {
+        entry: string;
+        export: string;
+        svg: string;
+        svgExport: string;
+    };
+    web: {
+        name: string;
+        budget: number;
+        heavy: boolean;
+        over: string;
+    }[];
+    adapters: {
+        'packages/core/src/modules/pathfollow/index.ts': string;
+        'packages/core/src/modules/pathfollow/svg.ts': string;
+        'packages/markup/src/pathfollow.ts': string;
+        'packages/web/src/pathfollow.ts': string;
+    };
+    exports: {
+        'core:./pathfollow': string;
+        'markup:./pathfollow': string;
+        'web:./pathfollow': string;
+    };
+    tests: string[];
+    conformance: string[];
+    docs: string[];
+};
+export default _default;

package/modules/pathfollow/manifest.js

@@ -0,0 +1,39 @@
+const after = ["rig", "lists", "contour"];
+var manifest_default = {
+  ...{
+    name: "pathfollow",
+    summary: "Follow path: place or orient nodes along a path outline, with offsets and spreading.",
+    after: [],
+    core: {
+      entry: "core/index.ts",
+      export: "pathfollow",
+      svg: "core/svg.ts",
+      svgExport: "pathfollowSVG"
+    },
+    web: [{ name: "pathfollow", budget: 1280, heavy: true, over: "rig" }],
+    adapters: {
+      "packages/core/src/modules/pathfollow/index.ts": "core/index.ts",
+      "packages/core/src/modules/pathfollow/svg.ts": "core/svg.ts",
+      "packages/markup/src/pathfollow.ts": "markup/index.ts",
+      "packages/web/src/pathfollow.ts": "web/index.ts"
+    },
+    exports: {
+      "core:./pathfollow": "packages/core/src/modules/pathfollow/index.ts",
+      "markup:./pathfollow": "packages/markup/src/pathfollow.ts",
+      "web:./pathfollow": "packages/web/src/pathfollow.ts"
+    },
+    tests: [
+      "modules/pathfollow/test/**/*.test.ts",
+      "packages/markup/test/corpus.test.ts",
+      "packages/markup/test/names.test.ts",
+      "packages/markup/test/decompile.test.ts"
+    ],
+    conformance: ["rigging-follow-path", "rigging-list-follow-path"],
+    docs: ["spec/SPEC.md"]
+  },
+  after
+};
+export {
+  after,
+  manifest_default as default
+};

package/modules/pathfollow/markup/index.d.ts

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

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

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

package/modules/pathfollow/web/index.js

@@ -0,0 +1,8 @@
+import { pathfollow } from "../core/index.js";
+import { pathfollowSVG } from "../core/svg.js";
+import "../../../packages/web/src/index.js";
+customElements.get("anima-icon").registerModule(pathfollow);
+customElements.get("anima-icon").registerSVGBackend(
+  "pathfollow",
+  pathfollowSVG
+);

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

@@ -0,0 +1,7 @@
+import type { Player } from '../../../packages/core/src/player.js';
+import type { Model } from '../../../packages/core/src/load.js';
+import type { Diags } from '../../../packages/core/src/diag.js';
+export declare const handles: {
+    read(p: Player, i: number): [number, number] | undefined;
+    validate(model: Model, pads: number[], d: Diags): void;
+};

package/modules/posepad/core/handle.js

@@ -0,0 +1,87 @@
+import { ptr } from "../../../packages/core/src/diag.js";
+import { nodePointer } from "../../components/core/node-pointer.js";
+import { apply, invert } from "../../../packages/core/src/geom.js";
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+const handles = {
+  read(p, i) {
+    if (p.model.nodes[i].raw.handle === void 0) return;
+    const h = p.model.ids.get(p.model.nodes[i].raw.handle), inverse = invert(p.world(i));
+    const rest = p.model.nodes[h].raw.pivot ?? [0, 0];
+    const pivot = p.playbackPolicy?.pivot(p, h) ?? rest;
+    return inverse ? apply(inverse, ...apply(p.world(h), ...pivot)) : void 0;
+  },
+  validate(model, pads, d) {
+    for (const i of pads) {
+      const n = model.nodes[i], r = n.raw, at = nodePointer(model, i);
+      if (!model.ids.has(r.handle))
+        d.err(
+          "posepad-handle",
+          at + "/handle",
+          V && "unknown handle node",
+          V && "name an existing node"
+        );
+      if (!r.box)
+        d.err(
+          "posepad-box",
+          at + "/box",
+          V && "handle needs a box",
+          V && "add [x0, y0, width > 0, height > 0]"
+        );
+      const outputs = ["valueX", "valueY"].map((key) => n.id + "." + key);
+      const check = (map, path) => {
+        for (const address of Object.keys(map))
+          if (outputs.includes(address))
+            d.err(
+              "posepad-output",
+              ptr(path, address),
+              V && "handle-driven values are outputs",
+              V && "drive the handle instead"
+            );
+      };
+      for (const [name, t] of Object.entries(model.doc.timelines ?? {}))
+        check(t.tracks ?? {}, ptr("/timelines", name) + "/tracks");
+      check(model.doc.bind ?? {}, "/bind");
+      for (const layer of model.layers)
+        for (const state of layer.states)
+          if (state.pose)
+            check(
+              Object.fromEntries(state.pose),
+              ptr(ptr("/machine/layers", layer.name) + "/states", state.name) + "/pose"
+            );
+      const dependencies = /* @__PURE__ */ new Set(), visit = (j) => {
+        if (j < 0 || dependencies.has(j)) return;
+        dependencies.add(j);
+        const node = model.nodes[j];
+        visit(node.parent);
+        for (const c of node.raw.constraints ?? [])
+          for (const key of ["from", "to", "target", "path", "viewport", "scroll", "track"]) {
+            const target = model.ids.get(c[key]);
+            if (target !== void 0) visit(target);
+          }
+      };
+      const h = model.ids.get(r.handle);
+      if (h !== void 0) visit(h);
+      visit(i);
+      for (const axis of ["X", "Y"]) {
+        const t = model.timelines.find((t2) => t2.name === r["timeline" + axis]);
+        if (t?.tracks.some((tr) => dependencies.has(model.addrs.get(tr.addr).node)))
+          d.err(
+            "posepad-cycle",
+            at + "/timeline" + axis,
+            V && "pad timeline writes a handle dependency or pad frame",
+            V && "pose nodes independent of the handle and pad frame"
+          );
+      }
+      for (const key of outputs)
+        model.addrs.set(key, {
+          node: i,
+          key: key.slice(n.id.length + 1),
+          prop: { type: "number", min: -1, max: 1 },
+          rest: 0
+        });
+    }
+  }
+};
+export {
+  handles
+};

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

@@ -0,0 +1,12 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+import type { Player } from '../../../packages/core/src/player.js';
+import { handles } from './handle.js';
+export interface PosePadModule extends Module {
+    handles?: typeof handles;
+}
+declare module '../../../packages/core/src/load.ts' {
+    interface Model {
+        rigPose?: (p: Player) => boolean;
+    }
+}
+export declare const posepad: PosePadModule;

package/modules/posepad/core/index.js

@@ -0,0 +1,104 @@
+import { clamp } from "../../../packages/core/src/geom.js";
+import { formatHex } from "../../../packages/core/src/color.js";
+import { after } from "../manifest.js";
+import { entries } from "./registry.js";
+import { nodePointer } from "../../components/core/node-pointer.js";
+import { handles } from "./handle.js";
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+let sample;
+const states = /* @__PURE__ */ new WeakMap();
+function overlay(p) {
+  let values = states.get(p);
+  if (!values) {
+    states.set(p, values = /* @__PURE__ */ new Map());
+    const prop = p.prop.bind(p), value = p.value.bind(p);
+    p.prop = (i, k) => values.get(p.model.nodes[i].id + "." + k) ?? prop(i, k);
+    p.value = (a) => {
+      const v = values.get(a) ?? value(a);
+      return Array.isArray(v) && v.length === 4 ? formatHex(v) : v;
+    };
+  }
+  return values;
+}
+const posepad = {
+  name: "posepad",
+  after,
+  entries,
+  init(_modules, shared) {
+    sample = shared.sampleTrack;
+    if (V) posepad.handles = handles;
+    return posepad;
+  },
+  draw: {
+    tree(model, tree) {
+      model.nodes.forEach((n, i) => {
+        if (n.type === "posepad") tree.nodes[i].kind = "group";
+      });
+    }
+  },
+  load(model, _raw, d) {
+    if (!model.doc.requires?.includes("posepad")) return;
+    const pads = model.nodes.flatMap((n, i) => n.type === "posepad" ? [i] : []);
+    const timelines = pads.map((i) => {
+      const raw = model.nodes[i].raw;
+      if (raw.handle !== void 0) {
+        if (posepad.handles) posepad.handles.validate(model, [i], d);
+        else
+          d.err(
+            "posepad-handle",
+            nodePointer(model, i) + "/handle",
+            V && "handle support is not installed",
+            V && "import @anima-format/web/posepad-handle"
+          );
+      }
+      return ["X", "Y"].map((axis) => {
+        const name = raw["timeline" + axis], timeline = model.timelines.find((t) => t.name === name);
+        if (name !== void 0 && !timeline)
+          d.err(
+            "posepad-timeline",
+            nodePointer(model, i) + "/timeline" + axis,
+            V && "unknown timeline",
+            V && "name a declared timeline"
+          );
+        return timeline;
+      });
+    });
+    const pose = (p) => {
+      const values = overlay(p);
+      values.clear();
+      for (const [index, i] of pads.entries()) {
+        const r = model.nodes[i].raw, point = posepad.handles?.read(p, i);
+        for (const [a, axis] of ["X", "Y"].entries()) {
+          const v = clamp(
+            point ? 2 * (point[a] - r.box[a]) / r.box[a + 2] - 1 : p.num(i, "value" + axis, 0),
+            -1,
+            1
+          );
+          values.set(model.nodes[i].id + ".value" + axis, v);
+          const timeline = timelines[index][a];
+          for (const tr of timeline?.tracks ?? []) {
+            const addr = model.addrs.get(tr.addr), sampled = sample(
+              tr,
+              ((r["invert" + axis] ? -v : v) + 1) / 2 * timeline.duration,
+              p
+            );
+            values.set(
+              tr.addr,
+              typeof sampled === "number" ? clamp(sampled, addr.prop.min ?? -Infinity, addr.prop.max ?? Infinity) : sampled
+            );
+            p.drawVersions[addr.node] = ++p.drawRevision;
+          }
+        }
+      }
+      return !!values.size;
+    };
+    const stage = model.doc.requires.includes("rig") ? "rigPose" : "afterStep", previous = model[stage];
+    model[stage] = (p) => {
+      const wrote = previous?.(p);
+      return pose(p) || !!wrote;
+    };
+  }
+};
+export {
+  posepad
+};

package/modules/posepad/core/registry.d.ts

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

package/modules/posepad/core/registry.js

@@ -0,0 +1,27 @@
+const entries = [
+  {
+    target: "posepad",
+    node: {},
+    shapes: {
+      timelineX: { k: "str", markup: "timeline-x" },
+      timelineY: { k: "str", markup: "timeline-y" },
+      invertX: { k: "bool", markup: "invert-x" },
+      invertY: { k: "bool", markup: "invert-y" },
+      handle: { k: "str" },
+      box: {
+        k: "tup",
+        of: [{ k: "num" }, { k: "num" }, { k: "num", gt: 0 }, { k: "num", gt: 0 }],
+        min: 4
+      },
+      valueX: { k: "num", markup: "value-x" },
+      valueY: { k: "num", markup: "value-y" }
+    },
+    props: {
+      valueX: { type: "number", def: 0, min: -1, max: 1, markup: "value-x" },
+      valueY: { type: "number", def: 0, min: -1, max: 1, markup: "value-y" }
+    }
+  }
+];
+export {
+  entries
+};