animl 0.0.0-stage → 0.1.0

package/modules/nested/capabilities/components-nested-remap/registry.js

@@ -0,0 +1,59 @@
+const name = /^[a-z][a-zA-Z0-9-]*$/;
+const entries = [
+  {
+    target: "instance",
+    shapes: {
+      component: {
+        k: "str",
+        feature: "components",
+        re: /^(?:[a-z][a-zA-Z0-9-]*(?::[a-z][a-zA-Z0-9-]*)*|\$[\w:.-]+)$/
+      },
+      time: { k: "alt", of: [{ k: "num", min: 0 }, { k: "str" }] },
+      fps: { k: "num", gt: 0 },
+      size: {
+        k: "tup",
+        min: 2,
+        of: [
+          { k: "num", min: 0 },
+          { k: "num", min: 0 }
+        ]
+      },
+      fit: {
+        k: "str",
+        of: ["contain", "cover", "fill", "none", "scale-down", "fit-width", "fit-height"]
+      },
+      align: {
+        k: "str",
+        of: [
+          "center",
+          "top-left",
+          "top",
+          "top-right",
+          "left",
+          "right",
+          "bottom-left",
+          "bottom",
+          "bottom-right"
+        ]
+      }
+    }
+  },
+  {
+    target: "document",
+    shapes: {
+      outputs: { k: "map", key: name, of: { k: "str" }, markup: "outputs" }
+    },
+    elements: {
+      output: {
+        shape: {
+          k: "obj",
+          req: ["name", "value"],
+          p: { name: { k: "str", re: name }, value: { k: "str" } }
+        }
+      }
+    }
+  }
+];
+export {
+  entries
+};

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

@@ -0,0 +1,7 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+import type { Diags } from '../../../packages/core/src/diag.js';
+import { dynamicTrees } from './render.js';
+export declare const nested: Module & {
+    dynamicTrees: typeof dynamicTrees;
+};
+export declare function error(d: Diags, code: string, at: string, message: string, hint: string): void;

package/modules/nested/core/index.js

@@ -0,0 +1,315 @@
+import { nodePointer as pointer } from "../../components/core/node-pointer.js";
+import { same } from "../../data/core/types.js";
+import { formatHex } from "../../../packages/core/src/color.js";
+import { ptr } from "../../../packages/core/src/diag.js";
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { entries } from "../capabilities/components-nested-remap/registry.js";
+import { after } from "../manifest.js";
+import { fit, dynamic, render, dynamicTrees } from "./render.js";
+import { clock } from "./time.js";
+const outputs = /* @__PURE__ */ new WeakMap();
+const reads = /* @__PURE__ */ new WeakMap();
+const times = /* @__PURE__ */ new WeakMap();
+const points = /* @__PURE__ */ new WeakMap();
+const enabled = (m) => m.doc.requires?.includes("nested");
+const nested = {
+  name: "nested",
+  after,
+  entries,
+  dynamicTrees,
+  init(registry, shared) {
+    const components = registry.get("components");
+    const data = registry.get("data");
+    if (!components) return { ...nested, entries: [] };
+    const previous = components.externalDrawing;
+    components.externalDrawing = (m) => enabled(m) || !!previous?.(m);
+    components.selected = (p, n) => !enabled(p.model) || !n.raw.component.startsWith("$") || data?.dataState(p)?.read(n.raw.component) !== "";
+    components.choices = (m, n) => enabled(m) && n.raw.component.startsWith("$") ? Object.keys(m.doc.components ?? {}).filter((k) => k !== "$comment") : void 0;
+    components.matrix = (p, child, node) => enabled(p.model) ? fit(node, child.model) : [1, 0, 0, 1, 0, 0];
+    components.configure = (parent, child, node) => {
+      if (!enabled(parent.model)) return;
+      const time = times.get(node);
+      if (time || node.raw.fps) clock(parent, child, node, time, points.get(node));
+    };
+    return {
+      ...nested,
+      prepare(model, d) {
+        if (!enabled(model)) return;
+        if (!model.doc.requires.includes("components"))
+          error(
+            d,
+            "undeclared-feature",
+            "/requires",
+            "nested needs components",
+            "add components to requires"
+          );
+      },
+      resolve(model, d) {
+        if (!enabled(model)) return;
+        (model.guardLiterals ??= {}).component = (name, path) => data?.compiled.get(model)?.refs.get(path)?.property.type === "component" && Object.hasOwn(model.doc.components ?? {}, name) && name !== "$comment" ? name : void 0;
+        const plans = /* @__PURE__ */ new Map();
+        outputs.set(model, plans);
+        const used = /* @__PURE__ */ new Set();
+        reads.set(model, used);
+        const bind = registry.get("bind");
+        for (const [name, value] of Object.entries(model.doc.outputs ?? {})) {
+          if (name === "$comment") continue;
+          const at = ptr("/outputs", name);
+          if (!model.doc.requires.includes("bind") || !bind) {
+            error(
+              d,
+              "undeclared-feature",
+              at,
+              "outputs need bind expressions",
+              "add bind to requires"
+            );
+            continue;
+          }
+          try {
+            const parsed = bind.parse(
+              String(value),
+              new Map(
+                [...model.inputs].filter(([n]) => !n.startsWith("outputs.")).map(([n, i]) => [n, i.type])
+              )
+            );
+            const run = shared.inputExpression(
+              model,
+              String(value),
+              parsed.type,
+              at,
+              d,
+              (n) => used.add(n)
+            );
+            if (!run) continue;
+            const key = "outputs." + name;
+            plans.set(key, run);
+            model.inputs.set(key, {
+              name: key,
+              type: parsed.type,
+              def: parsed.type === "bool" ? false : parsed.type === "number" ? 0 : parsed.type === "color" ? [0, 0, 0, 255] : "",
+              min: -Infinity,
+              max: Infinity,
+              buffer: 0,
+              readonly: true,
+              accepts: (v) => parsed.type === "color" ? Array.isArray(v) : typeof v === (parsed.type === "bool" ? "boolean" : parsed.type)
+            });
+          } catch (e) {
+            error(
+              d,
+              "output-expression",
+              at,
+              e.message,
+              "use declared inputs and a scalar expression"
+            );
+          }
+        }
+        for (const [i, node] of model.nodes.entries()) {
+          if (node.type === "repeat") {
+            for (const child of new Set(components.placements.get(node)?.values()))
+              for (const [name, input] of child.inputs)
+                if (name.startsWith("outputs."))
+                  for (let index = 0; index < 256; index++) {
+                    const address = node.id + "." + index + "." + name, previous2 = model.inputs.get(address);
+                    if (previous2 && previous2.type !== input.type)
+                      error(
+                        d,
+                        "component-input-type",
+                        pointer(model, i) + "/component",
+                        "mapped outputs have different types",
+                        "use consistent output types across mapped components"
+                      );
+                    model.inputs.set(address, { ...input, name: address });
+                  }
+            continue;
+          }
+          if (node.type !== "instance") continue;
+          const at = pointer(model, i);
+          points.set(node, at);
+          if ((node.raw.fit || node.raw.align) && !node.raw.size)
+            error(
+              d,
+              "instance-size",
+              at + "/size",
+              "fit and align need size",
+              'set size="width height"'
+            );
+          if (node.raw.size?.some((n) => n <= 0))
+            error(
+              d,
+              "instance-size",
+              at + "/size",
+              "size must be positive",
+              "use positive width and height"
+            );
+          if (typeof node.raw.time === "string") {
+            const run = shared.inputExpression(
+              model,
+              node.raw.time,
+              "number",
+              at + "/time",
+              d,
+              (n) => used.add(n)
+            );
+            if (run) times.set(node, run);
+          } else if (node.raw.time !== void 0) times.set(node, () => node.raw.time);
+          if (node.raw.component.startsWith("$")) {
+            const choices = components.placements.get(node);
+            for (const child of new Set(choices?.values()))
+              for (const [name, input] of child.inputs) {
+                const address = node.id + "." + name;
+                const previous2 = model.inputs.get(address);
+                model.inputs.set(address, {
+                  ...input,
+                  name: address,
+                  min: Math.min(previous2?.min ?? Infinity, input.min),
+                  max: Math.max(previous2?.max ?? -Infinity, input.max)
+                });
+              }
+            for (const name of Object.keys(node.raw.inputs ?? {}))
+              if ([...new Set(choices?.values())].some((child) => !child.inputs.has(name)))
+                error(
+                  d,
+                  "unknown-input",
+                  ptr(at + "/inputs", name),
+                  "initializer is absent from a selectable component",
+                  "declare the initialized input in every choice"
+                );
+            const ref = data?.compiled.get(model)?.refs.get(node.raw.component);
+            if (ref?.property.type !== "component")
+              error(
+                d,
+                "component-path",
+                at + "/component",
+                "instance component needs a component property",
+                "declare a component property and use its $path"
+              );
+            if (!components.placements.get(node)?.size)
+              error(
+                d,
+                "unknown-component",
+                at + "/component",
+                "dynamic instance needs component definitions",
+                "declare at least one component"
+              );
+          }
+        }
+        const scan = (value, at) => {
+          if (!value || typeof value !== "object") return;
+          for (const [k, v] of Object.entries(value)) {
+            if (k === "components" || k === "data") continue;
+            const loc = ptr(at, k);
+            const targets = k === "set" || k === "bind" || k === "pose" || k === "tracks" ? Object.keys(v) : k === "toggle" || k === "fire" ? Array.isArray(v) ? v : [v] : [];
+            for (const target of targets)
+              if (String(target).includes(".outputs.") || String(target).startsWith("outputs."))
+                error(
+                  d,
+                  "read-only-path",
+                  k === "set" || k === "bind" || k === "pose" || k === "tracks" ? ptr(loc, String(target)) : loc,
+                  "component outputs are read-only",
+                  "write the child input that supplies the output"
+                );
+            scan(v, loc);
+          }
+        };
+        scan(model.doc, "");
+      },
+      load(model, _raw, d) {
+        if (!enabled(model)) return;
+        for (let i = d.list.length - 1; i >= 0; i--)
+          if (d.list[i].code === "unused-input" && [...reads.get(model) ?? []].some((n) => d.list[i].pointer === ptr("/inputs", n)))
+            d.list.splice(i, 1);
+        const inputScope = model.inputScope;
+        const plans = outputs.get(model);
+        model.inputScope = (p) => {
+          const scope = inputScope?.(p) ?? /* @__PURE__ */ new Map(), read = scope.get.bind(scope), get = p.get.bind(p), values = p.values.bind(p), toggle = p.toggle.bind(p);
+          if (plans?.size) {
+            p.get = (name) => plans.get(name)?.(
+              new Map(
+                [...model.inputs.keys()].filter((key) => !key.startsWith("outputs.")).map((key) => [key, get(key)])
+              )
+            ) ?? get(name);
+            p.values = () => ({
+              ...values(),
+              ...Object.fromEntries(
+                [...plans.keys()].map((name) => {
+                  const v = p.get(name);
+                  return [
+                    name,
+                    Array.isArray(v) ? formatHex(v) : v
+                  ];
+                })
+              )
+            });
+          }
+          p.toggle = (name) => {
+            if (name.startsWith("outputs.") || name.includes(".outputs.")) throw readonly(name);
+            toggle(name);
+          };
+          scope.get = (name) => plans?.has(name) ? p.get(name) : name.includes(".outputs.") ? p.nested?.get(name) ?? read(name) : read(name);
+          return scope;
+        };
+        const factory = model.nesting;
+        if (!factory) return;
+        model.nesting = (p) => {
+          const base = factory(
+            p
+          );
+          if (!base) return base;
+          if (!model.doc.requires.includes("lists")) dynamic(p, components, data);
+          const plans2 = outputs.get(model);
+          if (plans2) outputs.set(p.model, plans2);
+          const names = /* @__PURE__ */ new Map();
+          const step = base.step.bind(base);
+          base.step = (dt) => {
+            const before = new Map(
+              [...model.inputs].filter(([name, input]) => input.readonly && name.includes(".outputs.")).map(([name]) => [name, p.get(name)])
+            );
+            for (const node of model.nodes) {
+              if (node.type !== "instance" || !node.raw.component.startsWith("$"))
+                continue;
+              const name = data?.dataState(p)?.read(node.raw.component), current = base.players.get(node.id);
+              if (names.get(node.id) !== name) {
+                names.set(node.id, name);
+                p.drawVersions[model.ids.get(node.id)] = ++p.drawRevision;
+              }
+              const childModel = typeof name === "string" ? components.placements.get(node)?.get(name) : void 0;
+              if (childModel && current?.model.doc !== childModel.doc) {
+                const child = new shared.Player(childModel, { reducedMotion: p.reducedMotion });
+                components.configure?.(p, child, node);
+                model.bindData?.(p, child, node);
+                for (const [key, v] of Object.entries(node.raw.inputs ?? {}))
+                  if (typeof v !== "string") child.set(key, v);
+                base.players.set(node.id, child);
+              } else if (name === "") {
+                base.players.delete(node.id);
+              } else if (!childModel)
+                throw Object.assign(new Error("unknown component " + String(name)), {
+                  code: "unknown-component",
+                  pointer: "/nodes/" + model.nodes.indexOf(node) + "/component",
+                  hint: "write a declared component name"
+                });
+            }
+            const result = step(dt);
+            return [...before].some(([name, value]) => !same(p.get(name), value)) ? { ...result, settled: false } : result;
+          };
+          return base;
+        };
+      },
+      draw: { end: render }
+    };
+  }
+};
+function error(d, code, at, message, hint) {
+  d.err(code, at, V && message, V && hint);
+}
+function readonly(name) {
+  return Object.assign(new Error("component output is read-only (read-only-path)"), {
+    code: "read-only-path",
+    pointer: ptr("/inputs", name),
+    hint: "write the child input that supplies the output"
+  });
+}
+export {
+  error,
+  nested
+};

package/modules/nested/core/render.d.ts

@@ -0,0 +1,10 @@
+import type { Model, NodeM } from '../../../packages/core/src/load.js';
+import type { Player } from '../../../packages/core/src/player.js';
+import type { ComponentModule } from '../../components/core/index.js';
+import type { DataModule } from '../../data/core/index.js';
+import { type DrawTree } from '../../../packages/core/src/draw.js';
+import { type Mat } from '../../../packages/core/src/geom.js';
+export declare const dynamicTrees: WeakSet<DrawTree>;
+export declare function fit(node: NodeM, child: Model): Mat;
+export declare function dynamic(p: Player, components: ComponentModule, data?: DataModule): void;
+export declare function render(p: Player, frame: import('../../../packages/core/src/draw.js').DrawFrame): void;

package/modules/nested/core/render.js

@@ -0,0 +1,172 @@
+import {
+  drawFrame,
+  drawTree
+} from "../../../packages/core/src/draw.js";
+import { mul, invert } from "../../../packages/core/src/geom.js";
+const dynamicTrees = /* @__PURE__ */ new WeakSet();
+const origins = /* @__PURE__ */ new WeakMap();
+function fit(node, child) {
+  const raw = node.raw;
+  if (!raw.size) return [1, 0, 0, 1, 0, 0];
+  const [x, y, w, h] = child.viewBox, [tw, th] = raw.size;
+  let sx = tw / w, sy = th / h;
+  const scale = raw.fit === "cover" ? Math.max(sx, sy) : raw.fit === "none" ? 1 : raw.fit === "scale-down" ? Math.min(1, sx, sy) : raw.fit === "fit-width" ? sx : raw.fit === "fit-height" ? sy : Math.min(sx, sy);
+  if (raw.fit !== "fill") sx = sy = scale;
+  const align = raw.align ?? "center";
+  const factor = (lo, hi) => align.includes(lo) ? 0 : align.includes(hi) ? 1 : 0.5;
+  return [
+    sx,
+    0,
+    0,
+    sy,
+    (tw - w * sx) * factor("left", "right") - x * sx,
+    (th - h * sy) * factor("top", "bottom") - y * sy
+  ];
+}
+function dynamic(p, components, data) {
+  const model = p.model, origin = origins.get(drawTree(model)), tree = origin?.tree ?? drawTree(model);
+  const draw = {
+    ...tree,
+    nodes: tree.nodes.map((n) => ({ ...n, children: [...n.children] })),
+    roots: [...tree.roots],
+    resources: [...tree.resources]
+  };
+  const previous = origin ? origin.afterStep : model.afterStep;
+  const clone = {
+    ...model,
+    draw,
+    afterStep: (p2) => {
+      previous?.(p2);
+      drawFrame(p2);
+    }
+  };
+  Object.defineProperty(p, "model", { value: clone });
+  components.forkModel(model, clone);
+  const c = data?.compiled.get(model);
+  if (c) data.compiled.set(clone, c);
+  dynamicTrees.add(draw);
+  origins.set(draw, { tree, afterStep: previous });
+  drawings.set(p, { mappings: /* @__PURE__ */ new Map(), free: [], resources: [...draw.resources] });
+}
+function fitLists(p, frame) {
+  if (!p.model.doc.requires?.includes("nested") || !p.model.doc.requires.includes("lists")) return;
+  const players = p.nested?.players;
+  for (const [id, child] of players ?? []) {
+    const index = p.model.ids.get(id), n = p.model.nodes[index];
+    for (const group of frame.tree.nodes[index].children) {
+      const t = fit(n, child.model), f = frame.nodes[group];
+      if (n.raw.component.startsWith("$") && p.get(n.raw.component) === "") {
+        f.visible = false;
+        frame.changed.push(group);
+        continue;
+      }
+      const world = mul(p.world(index), t), inverse = f.world && invert(f.world);
+      if (inverse) {
+        const delta = mul(world, inverse);
+        const visit = (node) => {
+          const f2 = frame.nodes[node];
+          if (f2.world) f2.world = mul(delta, f2.world);
+          for (const c of frame.tree.nodes[node].children) visit(c);
+        };
+        for (const node of frame.tree.nodes[group].children) visit(node);
+      }
+      f.transform = t;
+      f.world = world;
+      frame.changed.push(group);
+    }
+  }
+}
+const drawings = /* @__PURE__ */ new WeakMap();
+function render(p, frame) {
+  const drawing = drawings.get(p);
+  if (!drawing) {
+    fitLists(p, frame);
+    return;
+  }
+  const tree = frame.tree;
+  const retire = (node) => {
+    tree.nodes[node] = { node, kind: "group", parent: -1, children: [] };
+    frame.nodes[node] = { transform: [1, 0, 0, 1, 0, 0], opacity: 1, visible: false, paints: [] };
+    return node;
+  };
+  const entries = [];
+  const players = p.nested?.players;
+  for (const [id, child] of players ?? [])
+    if (!p.model.nodes[p.model.ids.get(id)].raw.component.startsWith("$") || p.get(p.model.nodes[p.model.ids.get(id)].raw.component) !== "")
+      entries.push({ player: child, parent: p.model.ids.get(id), id });
+  const active = new Set(entries.map((e) => e.player));
+  for (const [player, m] of drawing.mappings)
+    if (!active.has(player)) {
+      drawing.free.push(m.group, ...m.nodes);
+      for (const n of [m.group, ...m.nodes]) {
+        retire(n);
+        frame.changed.push(n);
+      }
+      drawing.mappings.delete(player);
+    }
+  for (const n of p.model.nodes)
+    if (n.type === "instance") {
+      const e = tree.nodes[p.model.ids.get(n.id)];
+      e.kind = "group";
+      e.children = [];
+    }
+  tree.resources = [...drawing.resources];
+  const allocate = () => retire(drawing.free.pop() ?? tree.nodes.length);
+  for (const entry of entries) {
+    const child = drawFrame(entry.player);
+    let mapping = drawing.mappings.get(entry.player);
+    if (!mapping) {
+      mapping = { group: allocate(), nodes: [] };
+      drawing.mappings.set(entry.player, mapping);
+    }
+    while (mapping.nodes.length < child.tree.nodes.length) mapping.nodes.push(allocate());
+    const group = mapping.group, shift = (n) => mapping.nodes[n];
+    const transform = fit(p.model.nodes[entry.parent], entry.player.model);
+    tree.nodes[group] = {
+      node: group,
+      kind: "group",
+      id: entry.id,
+      parent: entry.parent,
+      children: child.tree.roots.map(shift)
+    };
+    tree.nodes[entry.parent].children.push(group);
+    frame.nodes[group] = { transform, opacity: 1, visible: true, paints: [] };
+    frame.changed.push(group);
+    (frame.order ??= [])[group] = entry.index ?? group;
+    const world = mul(p.world(entry.parent), transform);
+    frame.nodes[group].world = world;
+    child.tree.nodes.forEach((n, i) => {
+      const source = child.nodes[i];
+      tree.nodes[shift(i)] = {
+        ...n,
+        node: shift(i),
+        id: entry.id + "/" + (n.id ?? entry.player.model.nodes[n.node]?.id),
+        parent: n.parent < 0 ? group : shift(n.parent),
+        children: n.children.map(shift),
+        dependencies: void 0,
+        mask: n.mask ? { ...n.mask, source: shift(n.mask.source) } : void 0,
+        clip: n.clip ? { ...n.clip, source: shift(n.clip.source) } : void 0
+      };
+      frame.nodes[shift(i)] = {
+        ...source,
+        world: source.world ? mul(world, source.world) : void 0,
+        mask: source.mask ? { ...source.mask, source: shift(source.mask.source) } : void 0,
+        clip: source.clip ? { ...source.clip, source: shift(source.clip.source) } : void 0
+      };
+      frame.changed.push(shift(i));
+      (frame.order ??= [])[shift(i)] = child.order?.[i] ?? i;
+    });
+    for (const r of child.tree.resources)
+      tree.resources.push({
+        ...r,
+        node: shift(r.node),
+        source: r.source === void 0 ? void 0 : shift(r.source)
+      });
+  }
+}
+export {
+  dynamic,
+  dynamicTrees,
+  fit,
+  render
+};

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

@@ -0,0 +1 @@
+export { componentsSVG as nestedSVG } from '../../components/core/svg.js';

package/modules/nested/core/svg.js

@@ -0,0 +1,4 @@
+import { componentsSVG } from "../../components/core/svg.js";
+export {
+  componentsSVG as nestedSVG
+};

package/modules/nested/core/time.d.ts

@@ -0,0 +1,3 @@
+import type { Player } from '../../../packages/core/src/player.js';
+import type { NodeM, InputEvaluator } from '../../../packages/core/src/load.js';
+export declare function clock(parent: Player, child: Player, node: NodeM, expression: InputEvaluator | undefined, at: string): void;

package/modules/nested/core/time.js

@@ -0,0 +1,83 @@
+import { foldTime, timeFloor, reached } from "../../../packages/core/src/time.js";
+import { crossings } from "../../motion/core/clock.js";
+function clock(parent, child, node, expression, at) {
+  let source = 0, before = 0, elapsed = 0;
+  const state = /* @__PURE__ */ new WeakMap(), rates = /* @__PURE__ */ new WeakMap();
+  const old = child.playbackPolicy;
+  const local = (t, time) => t.loop === "once" ? Math.max(0, Math.min(t.duration, time)) : foldTime(time, t.duration, t.loop === "pingpong");
+  const policy = {
+    get busy() {
+      return old?.busy ?? false;
+    },
+    states: () => old?.states() ?? {},
+    inspect: () => old?.inspect() ?? [],
+    transition: (t) => old?.transition?.(t) ?? t,
+    enter(run, from, to, transition, carry) {
+      state.set(run, transition ? source - carry : 0);
+      old?.enter(run, from, to, transition, carry);
+    },
+    prepare(run, s, dt, eligible) {
+      rates.set(run, s.speed);
+      old?.prepare(run, s, dt, eligible);
+    },
+    rest: (run, s) => old?.rest(run, s) ?? false,
+    local(t, _elapsed, speed, run) {
+      const elapsed2 = source - (state.get(run) ?? 0);
+      return old?.local(t, elapsed2, speed, run) ?? local(t, elapsed2 * speed);
+    },
+    duration: (t, speed, run) => old?.duration(t, speed, run) ?? t.duration / speed,
+    finished: (t, _elapsed, run) => old?.finished(t, source - (state.get(run) ?? 0), run) ?? reached((source - (state.get(run) ?? 0)) * (rates.get(run) ?? 1), t.duration),
+    events(t, _a, _b, closed, layer, out, speed, run, markers) {
+      const start = state.get(run) ?? 0;
+      if (old)
+        old.events(t, before - start, source - start, closed, layer, out, speed, run, markers);
+      else
+        crossings(
+          t,
+          (before - start) * speed,
+          (source - start) * speed,
+          closed,
+          layer,
+          out,
+          t.loop,
+          markers
+        );
+    },
+    resume(run, time) {
+      state.set(
+        run,
+        // Resuming happens inside this step: the origin precedes its source advance.
+        before - (old ? run.time : time / (rates.get(run) ?? 1))
+      );
+      old?.resume(run, time);
+    },
+    reduce(t, speed, end, layer, events) {
+      if (old) return old.reduce(t, speed, end, layer, events);
+      if (end) crossings(t, 0, t.duration, true, layer, events, "once");
+      return end ? t.duration : 0;
+    },
+    gate: (t, s, e, run) => old?.gate(t, s, e, run) ?? true,
+    carry: (t, s, e, run) => old?.carry(t, s, e, run),
+    pivot: (p, n) => old?.pivot(p, n) ?? p.model.nodes[n].raw.pivot ?? [0, 0],
+    compose: (dt, values, events) => old?.compose(dt, values, events) ?? true
+  };
+  Object.defineProperty(child, "playbackPolicy", { value: policy });
+  const step = child.step.bind(child);
+  child.step = (dt, base) => {
+    elapsed += dt;
+    const scope = new Map([...parent.model.inputs.keys()].map((n) => [n, parent.get(n)]));
+    const value = expression ? Number(expression(scope)) : elapsed;
+    if (!Number.isFinite(value) || value < 0)
+      throw Object.assign(new Error("instance time must be finite and nonnegative"), {
+        code: "instance-time",
+        pointer: at + "/time",
+        hint: "use a finite nonnegative time in seconds"
+      });
+    before = source;
+    source = node.raw.fps ? timeFloor(value, 1 / node.raw.fps) / node.raw.fps : value;
+    return step(Math.max(0, source - before), base);
+  };
+}
+export {
+  clock
+};