@weasel-js/animator 1.10.1 → 1.11.1

package/dist/index.js

@@ -1,3264 +1,8 @@
-import { useRef, useCallback, useMemo, useInsertionEffect, useEffect } from 'react';
-import { useLatest, useVisibleRaf } from '@weasel-js/react';
-import { isPlainObject, createEmitter } from '@weasel-js/registry';
-import { keys, patch, tween, glide, spring, mix, kit, vec, sum } from '@msb235/blits';
-import { EASINGS, resolveEasing, mat3, PATH_M, PATH_L, PATH_Z, reviveTypedArrays, tagTypedArrays, easeOut, SPRING_PRESETS, linear } from '@weasel-js/geom';
+import { axisIndexes } from './chunk-H7WENFPC.js';
+export { ColorOverrideRegistry, axesOf, createTarget, createTargetTable, sampleTrack } from './chunk-H7WENFPC.js';
+import { EASINGS, resolveEasing, mat3, PATH_M, PATH_L, PATH_Z, reviveTypedArrays, tagTypedArrays, linear } from '@weasel-js/geom';
 import { hslToSrgb, lerpColorArray } from '@weasel-js/paint';
 
-// src/useAnimator.ts
-
-// src/axisNames.ts
-var LISTED = 8;
-function axisIndexes(axes, wanted, what = "animator: `axes`") {
-  const { count, names } = axes;
-  const out = [];
-  for (const w of wanted) {
-    if (typeof w === "number") {
-      if (!Number.isInteger(w) || w < 0 || w >= count) throw new Error(`${what} names axis ${w} of a target with ${count}`);
-      out.push(w);
-      continue;
-    }
-    if (!names) throw new Error(`${what} names "${w}" on a target whose axes have no names`);
-    const before = out.length;
-    const under = `${w}.`;
-    for (let i = 0; i < names.length; i++) {
-      if (names[i] === w || names[i].startsWith(under)) out.push(i);
-    }
-    if (out.length === before) {
-      const some = names.slice(0, LISTED).map((n) => `"${n}"`).join(", ");
-      throw new Error(`${what} names "${w}", and the target's axes are ${some}${names.length > LISTED ? ", \u2026" : ""}`);
-    }
-  }
-  return out;
-}
-function fieldByField(keys) {
-  const [a, b, c, e] = keys;
-  switch (keys.length) {
-    case 1:
-      return {
-        add: (v, d) => ({ [a]: v[a] + d[0] }),
-        write: (v, o, at) => {
-          o[at] = v[a];
-        }
-      };
-    case 2:
-      return {
-        add: (v, d) => ({ [a]: v[a] + d[0], [b]: v[b] + d[1] }),
-        write: (v, o, at) => {
-          o[at] = v[a];
-          o[at + 1] = v[b];
-        }
-      };
-    case 3:
-      return {
-        add: (v, d) => ({ [a]: v[a] + d[0], [b]: v[b] + d[1], [c]: v[c] + d[2] }),
-        write: (v, o, at) => {
-          o[at] = v[a];
-          o[at + 1] = v[b];
-          o[at + 2] = v[c];
-        }
-      };
-    case 4:
-      return {
-        add: (v, d) => ({ [a]: v[a] + d[0], [b]: v[b] + d[1], [c]: v[c] + d[2], [e]: v[e] + d[3] }),
-        write: (v, o, at) => {
-          o[at] = v[a];
-          o[at + 1] = v[b];
-          o[at + 2] = v[c];
-          o[at + 3] = v[e];
-        }
-      };
-    default:
-      return null;
-  }
-}
-function axesOf(sample) {
-  if (typeof sample === "number") {
-    return {
-      count: 1,
-      shape: "number",
-      to: (v) => [v],
-      from: (a, at = 0) => a[at],
-      add: (v, delta) => v + delta[0],
-      write: (v, out, at) => {
-        out[at] = v;
-      }
-    };
-  }
-  if (Array.isArray(sample)) {
-    if (!sample.every((x) => typeof x === "number")) return null;
-    return {
-      count: sample.length,
-      shape: `array:${sample.length}`,
-      to: (v) => v.slice(),
-      from: (a, at = 0) => {
-        const out = new Array(sample.length);
-        for (let i = 0; i < out.length; i++) out[i] = a[at + i];
-        return out;
-      },
-      add: (v, delta) => {
-        const out = new Array(sample.length);
-        for (let i = 0; i < out.length; i++) out[i] = v[i] + delta[i];
-        return out;
-      },
-      write: (v, out, at) => {
-        for (let i = 0; i < sample.length; i++) out[at + i] = v[i];
-      }
-    };
-  }
-  if (!isPlainObject(sample)) return null;
-  const keys = Object.keys(sample).sort();
-  if (keys.length === 0 || !keys.every((k) => typeof sample[k] === "number")) return null;
-  return {
-    count: keys.length,
-    shape: `object:${JSON.stringify(keys)}`,
-    names: keys,
-    to: (v) => keys.map((k) => v[k]),
-    from: (a, at = 0) => {
-      const out = {};
-      for (let i = 0; i < keys.length; i++) out[keys[i]] = a[at + i];
-      return out;
-    },
-    ...fieldByField(keys) ?? {
-      add: (v, delta) => {
-        const out = {};
-        for (let i = 0; i < keys.length; i++) out[keys[i]] = v[keys[i]] + delta[i];
-        return out;
-      },
-      write: (v, out, at) => {
-        for (let i = 0; i < keys.length; i++) out[at + i] = v[keys[i]];
-      }
-    }
-  };
-}
-
-// src/target.ts
-var states = /* @__PURE__ */ new WeakMap();
-var scratch = new Float64Array(16);
-function hidden(s) {
-  const { cover } = s;
-  if (s.behind.size === 0 || !cover && !s.dimmed) return null;
-  const out = new Array(s.axes.count).fill(0);
-  for (const b of s.behind) {
-    const left = b.left();
-    for (let i = 0; i < out.length; i++) {
-      const shows = (cover ? 1 - cover[i] : 1) * (b.kept ? b.kept[i] : 1);
-      out[i] = out[i] + left[i] * (1 - shows);
-    }
-  }
-  return out;
-}
-function committedInto(s, out, at) {
-  if (s.write) s.write(out, at);
-  else if (s.axes.write) s.axes.write(s.get(), out, at);
-  else {
-    const a = s.axes.to(s.get());
-    for (let i = 0; i < a.length; i++) out[at + i] = a[i];
-  }
-}
-function heldAxes(s, committed) {
-  const a = s.axes.to(committed);
-  if (s.heldAt && a.some((x, i) => x !== s.heldAt[i])) s.owner?.reread(s);
-  return a;
-}
-function readTarget(s) {
-  const committed = s.get();
-  if (s.live === 0) return committed;
-  const { axes, slot, beside, adjust } = s;
-  if (!axes.add || s.heldAt || s.dimmed) {
-    const a = heldAxes(s, committed);
-    const hid = hidden(s);
-    for (let i = 0; i < a.length; i++) {
-      a[i] = a[i] + (slot ? slot.cols[slot.at + i] : 0) + adjust[i] + (beside ? beside[i] : 0) - (hid ? hid[i] : 0);
-    }
-    return axes.from(a);
-  }
-  const n = axes.count;
-  if (scratch.length < n) scratch = new Float64Array(n);
-  const d = scratch;
-  for (let i = 0; i < n; i++) {
-    d[i] = (slot ? slot.cols[slot.at + i] : 0) + adjust[i] + (beside ? beside[i] : 0);
-  }
-  return axes.add(committed, d);
-}
-function readTargetInto(s, out, at) {
-  const committed = s.get();
-  const { axes, slot, beside, adjust } = s;
-  const moving = s.live > 0;
-  if (axes.write && !(moving && s.heldAt)) axes.write(committed, out, at);
-  else {
-    const a = moving ? heldAxes(s, committed) : axes.to(committed);
-    for (let i = 0; i < a.length; i++) out[at + i] = a[i];
-  }
-  if (!moving) return;
-  const hid = hidden(s);
-  for (let i = 0; i < axes.count; i++) {
-    out[at + i] = out[at + i] + (slot ? slot.cols[slot.at + i] : 0) + adjust[i] + (beside ? beside[i] : 0) - (hid ? hid[i] : 0);
-  }
-}
-function isTarget(x) {
-  return typeof x === "object" && x !== null && states.has(x);
-}
-function stateOf(target) {
-  const s = states.get(target);
-  if (!s) throw new Error("animator: `target` was not made by createTarget");
-  return s;
-}
-function createTarget(opts) {
-  const axes = opts.axes ?? axesOf(opts.get());
-  if (!axes) {
-    throw new Error("createTarget: `axes` is required for a value that is not a number, an array of numbers, or an object of numeric fields");
-  }
-  const s = {
-    get: opts.get,
-    set: opts.set,
-    show: opts.show,
-    publish: opts.publish,
-    axes,
-    write: null,
-    owner: null,
-    discard: false,
-    heldAt: null,
-    held: 0,
-    cover: null,
-    behind: /* @__PURE__ */ new Set(),
-    dimmed: false,
-    beside: null,
-    row: null,
-    live: 0,
-    slot: null,
-    adjust: new Array(axes.count).fill(0),
-    stale: false
-  };
-  const target = {
-    read: () => readTarget(s),
-    readInto: (out, at = 0) => readTargetInto(s, out, at),
-    axisCount: axes.count,
-    axes,
-    axisIndexes: (wanted) => axisIndexes(axes, wanted),
-    committed: opts.get,
-    commit: opts.set,
-    get active() {
-      return s.live > 0;
-    },
-    stop(o) {
-      const owner = s.owner;
-      if (!owner) return;
-      s.discard = o?.commit === false;
-      try {
-        owner.stop(s);
-      } finally {
-        s.discard = false;
-      }
-    }
-  };
-  states.set(target, s);
-  return target;
-}
-
-// src/targetTable.ts
-function put(into, n, row, value) {
-  if (value.length !== n) throw new Error(`target table: a row is ${n} numbers, and this value is ${value.length}`);
-  for (let k = 0; k < n; k++) into[row * n + k] = value[k];
-}
-function rowTarget(n, row, rows, committed, commit) {
-  const target = createTarget({
-    get: () => {
-      const from = committed();
-      const value = new Array(n);
-      for (let k = 0; k < n; k++) value[k] = from[row * n + k];
-      return value;
-    },
-    set: (value) => {
-      committed();
-      commit(row, value);
-    }
-  });
-  const state = stateOf(target);
-  state.row = { table: rows, index: row };
-  state.write = (out, at) => {
-    const from = committed();
-    for (let k = 0; k < n; k++) out[at + k] = from[row * n + k];
-  };
-  return target;
-}
-function createTargetTable(opts) {
-  const n = opts.axes;
-  const Shown = opts.shown ?? Float64Array;
-  if (!Number.isInteger(n) || n < 1) throw new Error("createTargetTable: `axes` is a whole number of at least 1");
-  let committed = new Float64Array(Math.max(opts.capacity ?? 64, 1) * n);
-  let shown = new Shown(committed.length);
-  let high = 0;
-  let size = 0;
-  const free = [];
-  const targets = [];
-  const states2 = [];
-  const removals = [];
-  const marks = /* @__PURE__ */ new Set();
-  const flush = () => {
-    for (const row of marks) {
-      const s = states2[row];
-      if (s) readTargetInto(s, shown, row * n);
-    }
-  };
-  const commit = (row, value) => {
-    put(committed, n, row, value);
-    const s = states2[row];
-    if (s && s.live > 0) marks.add(row);
-    else put(shown, n, row, value);
-    opts.set?.(row);
-  };
-  const rows = {
-    mark: (row) => {
-      marks.add(row);
-    },
-    settle() {
-      flush();
-      for (const row of marks) {
-        const s = states2[row];
-        if (!s || s.live === 0 || !(s.beside || s.dimmed || s.held > 0 && s.behind.size > 0)) marks.delete(row);
-      }
-    },
-    fill(columns) {
-      if (columns) {
-        const { cols, tags, count } = columns;
-        for (let j = 0; j < count; j++) {
-          const at = tags[j] * n;
-          for (let k = 0; k < n; k++) shown[at + k] = committed[at + k] + cols[j * n + k];
-        }
-      }
-      flush();
-      opts.show?.();
-    }
-  };
-  return {
-    axes: n,
-    get size() {
-      return size;
-    },
-    get committed() {
-      return committed;
-    },
-    get shown() {
-      flush();
-      return shown;
-    },
-    add(value) {
-      const row = free.pop() ?? high++;
-      if ((row + 1) * n > committed.length) {
-        const grown = new Float64Array(Math.max(committed.length * 2, (row + 1) * n));
-        grown.set(committed);
-        committed = grown;
-        const wider = new Shown(grown.length);
-        wider.set(shown);
-        shown = wider;
-      }
-      put(committed, n, row, value);
-      put(shown, n, row, value);
-      size += 1;
-      return row;
-    },
-    remove(row) {
-      targets[row]?.stop();
-      targets[row] = void 0;
-      removals[row] = (removals[row] ?? 0) + 1;
-      states2[row] = void 0;
-      marks.delete(row);
-      free.push(row);
-      size -= 1;
-    },
-    set: commit,
-    target(row) {
-      const held = targets[row];
-      if (held) return held;
-      const made = removals[row] ??= 0;
-      const mine = () => {
-        if (removals[row] !== made) throw new Error(`target table: row ${row} was removed, and this is its old target`);
-      };
-      const target = rowTarget(n, row, rows, () => {
-        mine();
-        return committed;
-      }, commit);
-      targets[row] = target;
-      states2[row] = stateOf(target);
-      return target;
-    }
-  };
-}
-
-// src/colorRegistry.ts
-var ColorOverrideRegistry = class {
-  map = /* @__PURE__ */ new Map();
-  slots = /* @__PURE__ */ new Map();
-  tables = /* @__PURE__ */ new Map();
-  _version = 0;
-  set(id, channel, override) {
-    let entry = this.map.get(id);
-    if (!entry) {
-      entry = {};
-      this.map.set(id, entry);
-    }
-    entry[channel] = override;
-    this._version++;
-  }
-  /** Drops `id`'s override on `channel`, and the colors a finished or canceled animation on its
-   *  {@link target} left painted. An animation still running goes on. */
-  clear(id, channel) {
-    this.release(id, channel);
-    const entry = this.map.get(id);
-    if (!entry) return;
-    if (!(channel in entry)) return;
-    delete entry[channel];
-    if (!entry.fill && !entry.stroke) this.map.delete(id);
-    this._version++;
-  }
-  clearAll() {
-    for (const [id, node] of this.slots) {
-      for (const channel of Object.keys(node)) this.release(id, channel);
-    }
-    if (this.map.size === 0) return;
-    this.map.clear();
-    this._version++;
-  }
-  /** What `set` stored for `id`'s `channel`; failing that, the colors its {@link target} paints. */
-  get(id, channel) {
-    const override = this.map.get(id)?.[channel];
-    if (override !== void 0) return override;
-    const slot = this.slots.get(id)?.[channel];
-    return slot?.painted ? shownOf(slot) : void 0;
-  }
-  /** Whether anything overrides `id`, on either channel. */
-  has(id) {
-    return this.map.has(id) || this.slots.has(id);
-  }
-  /**
-   * The {@link Target} for `id`'s colors on `channel`: `length` numbers, flat RGBA per anchor.
-   * Every caller for one node and channel gets the same one, so their animations add. The
-   * registry holds its committed colors and nothing writes the scene.
-   *
-   * What it paints: with no override from `set`, its colors in place of the painter's own; over
-   * one, only what its animations have left to travel, added on top. Ask again for each
-   * animation rather than keeping it: {@link release} and {@link clear} drop a resting one, and
-   * the target it had throws from then on.
-   */
-  target(id, channel, length) {
-    if (!(length > 0) || length % 4 !== 0) {
-      throw new Error(`vertex colors: length ${length} must be a positive multiple of 4`);
-    }
-    let node = this.slots.get(id);
-    const held = node?.[channel];
-    if (held?.length === length) return held.table.target(held.row);
-    if (held) {
-      if (held.table.target(held.row).active) {
-        throw new Error(`vertex colors: ${id}'s ${channel} is moving as ${held.length} numbers, not ${length}`);
-      }
-      this.drop(held);
-    }
-    const at = this.tableOf(length);
-    const row = at.table.add(new Float64Array(length));
-    const slot = { table: at.table, row, length, painted: false };
-    at.rows[row] = slot;
-    if (!node) {
-      node = {};
-      this.slots.set(id, node);
-    }
-    node[channel] = slot;
-    return at.table.target(row);
-  }
-  tableOf(length) {
-    const held = this.tables.get(length);
-    if (held) return held;
-    const rows = [];
-    const table = createTargetTable({
-      axes: length,
-      set: (row) => {
-        const slot = rows[row];
-        if (slot) slot.painted = true;
-        this._version++;
-      },
-      show: () => {
-        this._version++;
-      }
-    });
-    const made = { table, rows };
-    this.tables.set(length, made);
-    return made;
-  }
-  drop(slot) {
-    const at = this.tables.get(slot.length);
-    at.rows[slot.row] = void 0;
-    slot.table.remove(slot.row);
-    if (slot.table.size === 0) this.tables.delete(slot.length);
-  }
-  /** Drops the colors `id`'s {@link target} on `channel` left painted, unless an animation is
-   *  still moving it. An override from `set` stays. */
-  release(id, channel) {
-    const node = this.slots.get(id);
-    const slot = node?.[channel];
-    if (!node || !slot || slot.table.target(slot.row).active) return;
-    delete node[channel];
-    if (!node.fill && !node.stroke) this.slots.delete(id);
-    this.drop(slot);
-    if (slot.painted) this._version++;
-  }
-  /**
-   * The colors to paint on `id`'s `channel`, given the colors the painter would
-   * otherwise paint and the frame's timestamp. A function override needs that
-   * `base` and must return an array of its length; failing either, `base`
-   * stands. A {@link target} in motion then adds what it has left to travel.
-   */
-  resolve(id, channel, base, tMs) {
-    const override = this.map.get(id)?.[channel];
-    const slot = this.slots.get(id)?.[channel];
-    if (override === void 0) return slot?.painted ? shownOf(slot) : base;
-    const under = typeof override === "function" ? this.apply(override, base, tMs) : override;
-    if (!slot?.painted || under?.length !== slot.length || !slot.table.target(slot.row).active) return under;
-    const { shown, committed } = slot.table;
-    const at = slot.row * slot.length;
-    return under.map((x, i) => x + shown[at + i] - committed[at + i]);
-  }
-  apply(override, base, tMs) {
-    if (base === void 0) return void 0;
-    const result = override(base, tMs);
-    return result.length === base.length ? result : base;
-  }
-  version() {
-    return this._version;
-  }
-};
-function shownOf(slot) {
-  const { shown } = slot.table;
-  const at = slot.row * slot.length;
-  const out = new Array(slot.length);
-  for (let i = 0; i < out.length; i++) out[i] = shown[at + i];
-  return out;
-}
-var AnimatorEventHub = class {
-  events = createEmitter();
-  get watched() {
-    return this.events.size > 0;
-  }
-  add(listener) {
-    return this.events.subscribe(listener);
-  }
-  emit(event) {
-    this.events.emit(event);
-  }
-};
-
-// src/loop.ts
-function createLoop(createSupervisor, factory, opts = {}) {
-  const max = opts.count ?? Infinity;
-  let iteration = 0;
-  let cancelled = false;
-  let current = null;
-  const supervisor = createSupervisor({ kind: "loop", cancelKey: opts.cancelKey, label: opts.label });
-  supervisor.setOnCancel(() => {
-    cancelled = true;
-    current?.cancel();
-    current = null;
-  });
-  const applyRate = (paused, timeScale) => {
-    if (!current) return;
-    if (paused) current.pause();
-    else current.resume();
-    current.setTimeScale(timeScale);
-  };
-  supervisor.setOnRate(applyRate);
-  const next = () => {
-    if (cancelled) return;
-    if (iteration >= max) {
-      current = null;
-      cancelled = true;
-      supervisor.finish();
-      opts.onDone?.();
-      return;
-    }
-    const i = iteration++;
-    current = factory(i, next);
-    if (supervisor.isPaused() || supervisor.timeScale() !== 1) {
-      applyRate(supervisor.isPaused(), supervisor.timeScale());
-    }
-  };
-  next();
-  return {
-    id: supervisor.id,
-    cancel: () => supervisor.cancel(),
-    pause: () => supervisor.pause(),
-    resume: () => supervisor.resume(),
-    setTimeScale: (s) => supervisor.setTimeScale(s),
-    timeScale: () => supervisor.timeScale(),
-    isPaused: () => supervisor.isPaused()
-  };
-}
-function createTweenLoop(animator, createSupervisor, opts) {
-  const direction = opts.direction ?? "restart";
-  return createLoop(
-    (o) => createSupervisor({ ...o, kind: "tweenLoop" }),
-    (i, next) => {
-      const flipped = direction === "reverse" || direction === "alternate" && i % 2 === 1;
-      const from = flipped ? opts.to : opts.from;
-      const to = flipped ? opts.from : opts.to;
-      return animator.tween({
-        from,
-        to,
-        ms: opts.ms,
-        easing: opts.easing,
-        interpolate: opts.interpolate,
-        onTick: opts.onTick,
-        onDone: next
-      });
-    },
-    { count: opts.count, onDone: opts.onDone, cancelKey: opts.cancelKey, label: opts.label }
-  );
-}
-
-// src/stagger.ts
-var CompositeHandle = class {
-  constructor(supervisor, totalItems) {
-    this.supervisor = supervisor;
-    this.id = supervisor.id;
-    this.outstanding = totalItems;
-    supervisor.setOnCancel(() => this.handleSupervisorCancel());
-    supervisor.setOnRate((paused, timeScale) => {
-      if (paused) this.applyPause();
-      else this.applyResume();
-      this.applyTimeScale(timeScale);
-    });
-    supervisor.setOnFrame((virtualNow) => this.fireDue(virtualNow));
-  }
-  supervisor;
-  id;
-  cancelled = false;
-  paused_ = false;
-  timeScale_ = 1;
-  children = [];
-  pending = [];
-  outstanding;
-  finished = false;
-  /** Invoked when the supervisor is cancelled externally (animator.cancel /
-   *  cancelKey) OR via this composite's own `cancel`. */
-  handleSupervisorCancel() {
-    if (this.cancelled) return;
-    this.cancelled = true;
-    this.pending = [];
-    const kids = this.children.slice();
-    this.children = [];
-    for (const c of kids) c.cancel();
-  }
-  noteChildDone() {
-    if (this.cancelled || this.finished) return;
-    this.outstanding -= 1;
-    if (this.outstanding <= 0) {
-      this.finished = true;
-      this.children = [];
-      this.supervisor.finish();
-    }
-  }
-  addChild(h) {
-    if (this.cancelled) {
-      h.cancel();
-      return;
-    }
-    this.children.push(h);
-    if (this.paused_) h.pause();
-    if (this.timeScale_ !== 1) h.setTimeScale(this.timeScale_);
-  }
-  schedule(delayMs, fire) {
-    if (this.cancelled) return;
-    this.pending.push({ at: delayMs, fire });
-  }
-  fireDue(virtualNow) {
-    if (this.cancelled || this.pending.length === 0) return;
-    const due = this.pending.filter((p) => p.at <= virtualNow).sort((a, b) => a.at - b.at);
-    this.pending = this.pending.filter((p) => p.at > virtualNow);
-    for (const p of due) {
-      if (this.cancelled) return;
-      p.fire();
-    }
-  }
-  cancel() {
-    this.supervisor.cancel();
-  }
-  pause() {
-    this.supervisor.pause();
-  }
-  resume() {
-    this.supervisor.resume();
-  }
-  setTimeScale(s) {
-    this.supervisor.setTimeScale(s);
-  }
-  applyPause() {
-    if (this.paused_) return;
-    this.paused_ = true;
-    for (const c of this.children) c.pause();
-  }
-  applyResume() {
-    if (!this.paused_) return;
-    this.paused_ = false;
-    for (const c of this.children) c.resume();
-  }
-  applyTimeScale(s) {
-    if (s === this.timeScale_) return;
-    this.timeScale_ = s;
-    for (const c of this.children) c.setTimeScale(s);
-  }
-  timeScale() {
-    return this.timeScale_;
-  }
-  isPaused() {
-    return this.paused_;
-  }
-};
-function delayFor(delay, i) {
-  return typeof delay === "function" ? delay(i) : delay * i;
-}
-function createStagger(animator, createSupervisor, watchCompletion, items, delay, factory, opts) {
-  if (factory) return runStagger(createSupervisor, watchCompletion, items, delay, factory, opts);
-  return makeBuilder(animator, createSupervisor, watchCompletion, items, delay);
-}
-function runStagger(createSupervisor, watchCompletion, items, delay, factory, opts) {
-  const supervisor = createSupervisor({ kind: "stagger", cancelKey: opts?.cancelKey, label: opts?.label });
-  const composite = new CompositeHandle(supervisor, items.length);
-  if (items.length === 0) {
-    supervisor.finish();
-    return composite;
-  }
-  items.forEach((item, i) => {
-    const ms = delayFor(delay, i);
-    const fire = () => {
-      const child = factory(item, i);
-      watchCompletion(child.id, () => composite.noteChildDone());
-      composite.addChild(child);
-    };
-    if (ms <= 0) fire();
-    else composite.schedule(ms, fire);
-  });
-  return composite;
-}
-function resolvePerItem(v, item, i) {
-  return typeof v === "function" ? v(item, i) : v;
-}
-function perItem(opts, item, i) {
-  const target = opts.target !== void 0 ? resolvePerItem(opts.target, item, i) : isTarget(item) ? item : null;
-  return {
-    target,
-    from: opts.from === void 0 ? void 0 : resolvePerItem(opts.from, item, i),
-    to: resolvePerItem(opts.to, item, i),
-    onTick: opts.onTick && ((v) => opts.onTick(v, item, i)),
-    onDone: opts.onDone && (() => opts.onDone(item, i))
-  };
-}
-function makeBuilder(animator, createSupervisor, watchCompletion, items, delay) {
-  const run = (method, opts, start) => {
-    if (opts.target === void 0 && !opts.onTick && !items.every(isTarget)) {
-      throw new Error(`animator.stagger: \`.${method}\` needs a \`target\`, items that are targets, or an \`onTick\``);
-    }
-    return runStagger(createSupervisor, watchCompletion, items, delay, (item, i) => start(perItem(opts, item, i), item, i), opts);
-  };
-  return {
-    each: (factory, opts) => runStagger(createSupervisor, watchCompletion, items, delay, factory, opts),
-    tween: ((opts) => run("tween", opts, ({ target, ...own }, item, i) => {
-      const shared = {
-        ...own,
-        ms: resolvePerItem(opts.ms, item, i),
-        easing: opts.easing,
-        interpolate: opts.interpolate,
-        interpolator: opts.interpolator
-      };
-      return target ? animator.tween({ ...shared, target }) : animator.tween(shared);
-    })),
-    spring: ((opts) => run("spring", opts, ({ target, ...own }, item, i) => {
-      const shared = {
-        ...own,
-        velocity: opts.velocity === void 0 ? void 0 : resolvePerItem(opts.velocity, item, i),
-        preset: opts.preset,
-        stiffness: opts.stiffness,
-        damping: opts.damping,
-        mass: opts.mass,
-        restThreshold: opts.restThreshold
-      };
-      if (target) return animator.spring({ ...shared, target });
-      const { interpolate, add, subtract, scale, magnitude } = opts;
-      return animator.spring({ ...shared, interpolate, add, subtract, scale, magnitude });
-    }))
-  };
-}
-
-// src/supervisor.ts
-function supervisors(host) {
-  return ({ kind, cancelKey, label }) => {
-    const id = host.nextId();
-    let onCancelCb;
-    let onRateCb;
-    let onFrameCb;
-    const base = host.register({
-      id,
-      kind,
-      cancelKey,
-      label,
-      tick: (virtualNow) => {
-        if (onFrameCb) host.afterTicks(() => onFrameCb?.(virtualNow));
-        return false;
-      },
-      onCancel: () => onCancelCb?.(),
-      onRate: (paused, timeScale) => onRateCb?.(paused, timeScale)
-    });
-    return {
-      id: base.id,
-      cancel: base.cancel,
-      pause: base.pause,
-      resume: base.resume,
-      setTimeScale: base.setTimeScale,
-      timeScale: base.timeScale,
-      isPaused: base.isPaused,
-      setOnCancel: (cb) => {
-        onCancelCb = cb;
-      },
-      setOnRate: (cb) => {
-        onRateCb = cb;
-      },
-      setOnFrame: (cb) => {
-        onFrameCb = cb;
-      },
-      finish: () => host.finish(id),
-      cancelKey
-    };
-  };
-}
-
-// src/timeline/booking.ts
-var RESYNC_MS = 50;
-var SLEW = 0.05;
-var RETIME_MS = 1;
-function firstAfter(events, t) {
-  let lo = 0;
-  let hi = events.length;
-  while (lo < hi) {
-    const mid = lo + hi >> 1;
-    if (events[mid].t > t) hi = mid;
-    else lo = mid + 1;
-  }
-  return lo;
-}
-function firstAtOrAfter(events, t) {
-  let i = firstAfter(events, t);
-  while (i > 0 && events[i - 1].t === t) i -= 1;
-  return i;
-}
-var isAfter = (a, b) => a.lap > b.lap || a.lap === b.lap && a.r > b.r;
-function createBooker(opts, host) {
-  const lookahead = opts.lookahead ?? 100;
-  const maxLate = opts.maxLate ?? Infinity;
-  const cursors = /* @__PURE__ */ new Map();
-  let start = { lap: 0, r: -Infinity };
-  let bookings = [];
-  let est = null;
-  let mapVirtual = 0;
-  let lastScale = 0;
-  const playheadCursor = () => ({ lap: host.lap(), r: host.playhead() });
-  const unwrapped = (b) => (b.lap - host.lap()) * host.duration() + b.r;
-  const ahead = (b) => isAfter(b, playheadCursor());
-  const stopWhere = (now, pred) => {
-    bookings = bookings.filter((b) => {
-      if (!b.handle || b.when <= now || !ahead(b) || !pred(b)) return true;
-      try {
-        b.handle.stop();
-      } catch (err) {
-        console.error("timeline: booking stop threw", err);
-      }
-      return false;
-    });
-    const at = playheadCursor();
-    for (const [track, c] of cursors) if (isAfter(c, at)) cursors.set(track, at);
-    if (isAfter(start, at)) start = at;
-  };
-  const whenFor = (u, playhead, scale, now) => Math.max(est + (u - playhead) / scale, now);
-  const scanTrack = (track, at, horizon, lastLap, now, scale) => {
-    const lap = host.lap();
-    const duration = host.duration();
-    const playhead = host.playhead();
-    const { events } = track;
-    let c = cursors.get(track) ?? start;
-    for (; ; ) {
-      const lapStart = (c.lap - lap) * duration;
-      if (lapStart > horizon) break;
-      const i = (c.open ? firstAtOrAfter : firstAfter)(events, c.r - at);
-      if (i >= events.length || at + events[i].t > duration) {
-        if (c.lap >= lastLap) break;
-        c = { lap: Math.max(c.lap + 1, lap), r: -Infinity };
-        continue;
-      }
-      const r = at + events[i].t;
-      const u = lapStart + r;
-      if (u > horizon) break;
-      c = { lap: c.lap, r };
-      for (let j = i; j < events.length && events[j].t === events[i].t; j += 1) {
-        const ev = events[j];
-        if (!ev.book || bookings.some((b) => b.event === ev && b.lap === c.lap)) continue;
-        if ((playhead - u) / scale > maxLate) continue;
-        const when = whenFor(u, playhead, scale, now);
-        let handle;
-        try {
-          handle = ev.book(when) ?? void 0;
-        } catch (err) {
-          console.error("timeline: book threw", err);
-        }
-        bookings.push({ event: ev, lap: c.lap, r, when, handle });
-      }
-    }
-    cursors.set(track, c);
-  };
-  const visit = (tracks, at, horizon, lastLap, now, scale) => {
-    for (const track of tracks) {
-      if (track.kind === "event") scanTrack(track, at, horizon, lastLap, now, scale);
-      else if (track.kind === "timeline") {
-        visit(track.timeline.tracks, at + track.at, horizon, lastLap, now, scale);
-      }
-    }
-  };
-  return {
-    tick(virtualNow, scale) {
-      const now = opts.clock.now();
-      bookings = bookings.filter(ahead);
-      if (!(scale > 0)) {
-        if (lastScale > 0) stopWhere(now, () => true);
-        lastScale = 0;
-        est = null;
-        return;
-      }
-      let moved = lastScale > 0 && scale !== lastScale;
-      if (est === null) {
-        est = now;
-      } else {
-        est += (virtualNow - mapVirtual) / scale;
-        const residual = now - est;
-        if (Math.abs(residual) > RESYNC_MS) {
-          est = now;
-          moved = true;
-        } else {
-          est += residual * SLEW;
-        }
-      }
-      mapVirtual = virtualNow;
-      lastScale = scale;
-      const playhead = host.playhead();
-      if (moved) {
-        stopWhere(now, (b) => Math.abs(whenFor(unwrapped(b), playhead, scale, now) - b.when) > RETIME_MS);
-      }
-      const duration = host.duration();
-      const lastLap = host.lap() + (duration > 0 ? host.lapsLeft() : 0);
-      visit(host.tracks, 0, playhead + lookahead * scale, lastLap, now, scale);
-    },
-    retract() {
-      stopWhere(opts.clock.now(), () => true);
-    },
-    seek() {
-      bookings = [];
-      cursors.clear();
-      start = { ...playheadCursor(), open: true };
-    },
-    rearm() {
-      est = null;
-    }
-  };
-}
-
-// src/timeline/fireEvents.ts
-function createEventFirer(report, booked) {
-  const path = [];
-  let warnedUnbooked = false;
-  const fire = (tracks, from, to, fromOpen) => {
-    for (let k = 0; k < tracks.length; k += 1) {
-      const track = tracks[k];
-      if (track.kind === "event") {
-        const end = firstAfter(track.events, to);
-        const first = (fromOpen ? firstAtOrAfter : firstAfter)(track.events, from);
-        for (let i = first; i < end; i += 1) {
-          const ev = track.events[i];
-          ev.fire?.(to - ev.t);
-          if (report?.watched) {
-            path.push(k);
-            report.fire(track, path, ev, to - ev.t);
-            path.pop();
-          }
-          if (ev.book && !booked && !warnedUnbooked) {
-            warnedUnbooked = true;
-            console.warn("timeline: an event has `book` but the timeline has no `booking` clock; it never books.");
-          }
-        }
-      } else if (track.kind === "timeline") {
-        path.push(k);
-        fire(track.timeline.tracks, from - track.at, to - track.at, fromOpen);
-        path.pop();
-      }
-    }
-  };
-  return fire;
-}
-
-// src/engine/offsets.ts
-var TAU = Math.PI * 2;
-function axesFor(axes, value, what) {
-  const a = axes.to(value);
-  if (a.length !== axes.count || !a.every((x) => typeof x === "number" && !Number.isNaN(x))) {
-    throw new Error(`animator: \`${what}\` is not the target's shape`);
-  }
-  return a;
-}
-function shortWay(x) {
-  x %= TAU;
-  if (x > Math.PI) return x - TAU;
-  if (x <= -Math.PI) return x + TAU;
-  return x;
-}
-function travel(axes, a, b) {
-  const d = a.map((x, i) => x - b[i]);
-  for (const i of axes.angles ?? []) d[i] = shortWay(d[i]);
-  return d;
-}
-var plus = (a, b) => a.map((x, i) => x + b[i]);
-var minus = (a, b) => a.map((x, i) => x - b[i]);
-var norm = (a) => Math.hypot(...a);
-function bump(s, delta, sign) {
-  for (let i = 0; i < delta.length; i++) s.adjust[i] = s.adjust[i] + sign * delta[i];
-  stale(s);
-  s.row?.table.mark(s.row.index);
-}
-function stale(s) {
-  if (s.stale || !s.owner) return;
-  s.stale = true;
-  s.owner.adjusted(s);
-}
-function absorb(s, delta) {
-  if (s.discard) return;
-  s.set(s.axes.from(plus(s.axes.to(s.get()), delta)));
-}
-function shareBehind(axes, committed, to, start) {
-  return travel(axes, committed, to).map((m, i) => start[i] === 0 ? 0 : m / start[i]);
-}
-var times = (a, b) => a.map((x, i) => x * b[i]);
-function goBehind(s, left) {
-  const b = { left, kept: null };
-  s.behind.add(b);
-  return b;
-}
-function comeOut(s, b, left) {
-  s.behind.delete(b);
-  if (b.kept) {
-    s.dimmed = false;
-    for (const other of s.behind) if (other.kept) s.dimmed = true;
-  }
-  return b.kept ? times(left, b.kept) : left.slice();
-}
-function commitOffset(s, own, left, shown) {
-  const top = minus(own, left);
-  if (s.held === 0) {
-    keep(s, plus(shown, top));
-    return;
-  }
-  if (shown.some((x) => x !== 0)) absorb(s, shown);
-  if (top.some((x) => x !== 0)) keep(s, top);
-}
-function keep(s, delta) {
-  if (s.discard) return;
-  if (s.held === 0) absorb(s, delta);
-  else s.beside = s.beside ? plus(s.beside, delta) : delta.slice();
-  s.row?.table.mark(s.row.index);
-}
-function takeUp(s) {
-  const committed = s.axes.to(s.get());
-  const beside = s.beside;
-  s.beside = null;
-  return beside ? plus(committed, beside) : committed;
-}
-function createTargetBook(owner) {
-  const adjusted = [];
-  const token = { ...owner, adjusted: (s) => {
-    adjusted.push(s);
-  } };
-  const showing = /* @__PURE__ */ new Set();
-  const rested = /* @__PURE__ */ new Set();
-  const publishes = /* @__PURE__ */ new Set();
-  const tables = /* @__PURE__ */ new Map();
-  const shown = (s, value) => {
-    s.show(value);
-    if (s.publish) publishes.add(s.publish);
-  };
-  const publish = () => {
-    for (const p of publishes) p();
-    publishes.clear();
-  };
-  return {
-    attach(s) {
-      if (s.owner && s.owner !== token) {
-        throw new Error("animator: this target is being moved by another animator");
-      }
-      s.owner = token;
-      s.live += 1;
-      if (s.show) showing.add(s);
-      rested.delete(s);
-      if (s.row) {
-        tables.set(s.row.table, (tables.get(s.row.table) ?? 0) + 1);
-        s.row.table.mark(s.row.index);
-      }
-    },
-    detach(s) {
-      s.live -= 1;
-      if (s.row) {
-        tables.set(s.row.table, tables.get(s.row.table) - 1);
-        s.row.table.mark(s.row.index);
-      }
-      if (s.live > 0) return;
-      s.owner = null;
-      s.slot = null;
-      s.beside = null;
-      s.behind.clear();
-      s.dimmed = false;
-      s.adjust.fill(0);
-      s.stale = false;
-      if (s.show && showing.delete(s)) rested.add(s);
-    },
-    settle() {
-      for (const s of adjusted) {
-        if (!s.stale || s.owner !== token) continue;
-        s.adjust.fill(0);
-        s.stale = false;
-      }
-      adjusted.length = 0;
-      for (const t of tables.keys()) t.settle();
-    },
-    reread(s, queued) {
-      for (let i = 0; i < queued.length; i++) s.adjust[i] = queued[i];
-      stale(s);
-      s.row?.table.mark(s.row.index);
-    },
-    show() {
-      for (const s of showing) shown(s, readTarget(s));
-      for (const s of rested) shown(s, s.get());
-      rested.clear();
-      for (const [t, moving] of tables) {
-        t.fill(owner.columns(t));
-        if (moving === 0) tables.delete(t);
-      }
-      publish();
-    },
-    showNow(s) {
-      if (!s.show) return;
-      shown(s, readTarget(s));
-      publish();
-    },
-    get resting() {
-      return rested.size > 0;
-    }
-  };
-}
-
-// src/timeline/targetStops.ts
-function targetStops(track) {
-  const { axes } = stateOf(track.target);
-  const stops = [];
-  for (const k of track.keys) {
-    const row = axes.to(k.value);
-    if (row.length !== axes.count || !row.every((x) => typeof x === "number" && !Number.isNaN(x))) {
-      throw new Error("sampleTrack: a key's value is not its target's shape");
-    }
-    const prev = stops[stops.length - 1];
-    if (prev && axes.angles) {
-      const short = travel(axes, row, prev);
-      for (const i of axes.angles) if (short[i] !== row[i] - prev[i]) row[i] = prev[i] + short[i];
-    }
-    stops.push(row);
-  }
-  return { axes, stops };
-}
-
-// src/timeline/sampleTrack.ts
-var NO_SETTING = {};
-var BUILT = -1;
-function build(track, cache) {
-  const { keys: keys$1 } = track;
-  let t0 = Infinity;
-  let t1 = -Infinity;
-  const exact = /* @__PURE__ */ new Map();
-  for (const k of keys$1) {
-    t0 = Math.min(t0, k.t);
-    t1 = Math.max(t1, k.t);
-    exact.set(k.t, k.value);
-  }
-  const span = t1 - t0;
-  const out = { track, keys: keys$1, patch: null, t0, span, exact, fresh: null, first: keys$1[0].value, last: keys$1[keys$1.length - 1].value, read: (v) => v };
-  const { interpolator, interpolate } = track;
-  const onTarget = track.target && !interpolator && !interpolate ? targetStops(track) : null;
-  if (onTarget) {
-    const { axes: axes2, stops } = onTarget;
-    out.fresh = new Map(keys$1.map((k, i) => [k.t, () => axes2.from(stops[i])]));
-    out.first = axes2.from(stops[0]);
-    out.last = axes2.from(stops[stops.length - 1]);
-  }
-  if (span <= 0) return out;
-  const ease = (k) => k.easing ? resolveEasing(k.easing) : void 0;
-  if (onTarget) {
-    const { axes: axes2, stops } = onTarget;
-    out.patch = keys(
-      1,
-      keys$1.map((k, i) => ({ at: (k.t - t0) / span, delta: { v: stops[i] }, ease: ease(k) }))
-    );
-    out.read = (v) => axes2.from(v);
-    return out;
-  }
-  if (interpolator || interpolate) {
-    const boxes = keys$1.map((k, i) => ({ i, value: k.value }));
-    const lerp = (a, b, u) => {
-      if (interpolator) {
-        let fn = cache?.get(b.i);
-        if (!fn) {
-          fn = interpolator(a.value, b.value);
-          cache?.set(b.i, fn);
-        }
-        return { i: -1, value: fn(u) };
-      }
-      return { i: -1, value: interpolate(a.value, b.value, u) };
-    };
-    out.patch = keys(
-      1,
-      keys$1.map((k, i) => ({ at: (k.t - t0) / span, delta: { v: boxes[i] }, ease: ease(k) })),
-      { lerpBy: () => lerp }
-    );
-    out.read = (v) => v.value;
-    out.fresh = /* @__PURE__ */ new Map();
-    for (let i = 0; i < keys$1.length - 1; i++) {
-      const at = keys$1[i].t;
-      if (at > t0 && at < t1) out.fresh.set(at, () => lerp(boxes[i], boxes[i + 1], 0).value);
-    }
-    return out;
-  }
-  const axes = axesOf(keys$1[0].value);
-  if (!axes) return out;
-  for (const k of keys$1) {
-    if (axesOf(k.value)?.shape !== axes.shape) {
-      throw new Error(`sampleTrack: every key needs the shape of the first (${axes.shape})`);
-    }
-  }
-  const scalar = axes.shape === "number";
-  out.patch = keys(
-    1,
-    keys$1.map((k) => ({ at: (k.t - t0) / span, delta: { v: scalar ? k.value : axes.to(k.value) }, ease: ease(k) }))
-  );
-  if (!scalar) out.read = (v) => axes.from(v);
-  return out;
-}
-function sampleTrack(track, t, segmentCache) {
-  if (track.keys.length === 0) return void 0;
-  const cache = segmentCache;
-  let b = cache?.get(BUILT);
-  if (!b || b.track !== track || b.keys !== track.keys) {
-    cache?.clear();
-    b = build(track, segmentCache);
-    cache?.set(BUILT, b);
-  }
-  if (Number.isNaN(t)) return b.first;
-  const fresh = b.fresh?.get(t);
-  if (fresh) return fresh();
-  const hit = b.exact.get(t);
-  if (hit !== void 0 || b.exact.has(t)) return hit;
-  if (!b.patch) {
-    if (t < b.t0) return b.first;
-    if (t >= b.t0 + b.span) return b.last;
-    throw new Error("sampleTrack: interpolate or interpolator is required for non-numeric keyframe values");
-  }
-  return b.read(b.patch.at((t - b.t0) / b.span, 0, NO_SETTING).v);
-}
-
-// src/timeline/trackHolds.ts
-function createTrackSampler(open) {
-  let caches = /* @__PURE__ */ new WeakMap();
-  const cacheFor = (track) => {
-    let c = caches.get(track);
-    if (!c) {
-      c = /* @__PURE__ */ new Map();
-      caches.set(track, c);
-    }
-    return c;
-  };
-  const held = /* @__PURE__ */ new Map();
-  let edit = 0;
-  let pass = 0;
-  const openOn = (st, h) => {
-    if (!open) throw new Error("timeline: a track with a `target` needs a timeline made by an animator");
-    const w = st.weight ?? 1;
-    return open(st.target, () => h.value, typeof w === "function" ? w : () => w, st.axes);
-  };
-  const place = (st, value, t) => {
-    let h = held.get(st);
-    if (!h) held.set(st, h = { hold: null, value, where: null, t, edit, pass });
-    const moved = h.t !== t || h.edit !== edit;
-    h.value = value;
-    h.t = t;
-    h.edit = edit;
-    h.pass = pass;
-    const { keys } = st;
-    const where = t < keys[0].t ? "before" : t > keys[keys.length - 1].t ? "after" : "inside";
-    if (where === "inside") {
-      if (!h.hold) h.hold = openOn(st, h);
-      else if (moved) h.hold.touch();
-    } else if (where === "before") {
-      h.hold?.leave(false);
-      h.hold = null;
-    } else if (h.where !== "after") {
-      (h.hold ?? openOn(st, h)).leave(true);
-      h.hold = null;
-    }
-    h.where = where;
-  };
-  const visit = (tracks, t) => {
-    for (const track of tracks) {
-      if (track.kind === "sampled") {
-        const st = track;
-        const v = sampleTrack(st, t, cacheFor(st));
-        if (v === void 0) continue;
-        if (st.target) place(st, v, t);
-        st.onTick?.(v);
-      } else if (track.kind === "timeline") {
-        visit(track.timeline.tracks, t - track.at);
-      }
-    }
-  };
-  return {
-    apply(tracks, t) {
-      pass += 1;
-      visit(tracks, t);
-      for (const [st, h] of held) {
-        if (h.pass === pass) continue;
-        h.hold?.leave(true);
-        held.delete(st);
-      }
-    },
-    edited() {
-      caches = /* @__PURE__ */ new WeakMap();
-      edit += 1;
-    },
-    release() {
-      for (const h of held.values()) {
-        if (!h.hold) continue;
-        h.hold.leave(true);
-        h.hold = null;
-        h.where = null;
-      }
-    }
-  };
-}
-
-// src/timeline/createTimeline.ts
-function trackEnd(track) {
-  switch (track.kind) {
-    case "sampled":
-      return track.keys.length ? track.keys[track.keys.length - 1].t : 0;
-    case "event":
-      return track.events.length ? track.events[track.events.length - 1].t : 0;
-    case "timeline":
-      return track.at + tracksEnd(track.timeline.tracks, track.timeline.duration);
-  }
-}
-function tracksEnd(tracks, explicit) {
-  if (explicit != null) return explicit;
-  let max = 0;
-  for (const t of tracks) max = Math.max(max, trackEnd(t));
-  return max;
-}
-function crossLaps(playhead, duration, loopsLeft, take) {
-  if (duration <= 0 || playhead < duration) return;
-  const laps = Math.min(Math.floor(playhead / duration), loopsLeft);
-  if (laps > 0) take(laps);
-}
-function createTimeline(register, id, opts, report, hold) {
-  let duration = tracksEnd(opts.tracks, opts.duration);
-  let offset = 0;
-  let lastVirtual = 0;
-  let playhead = 0;
-  let prevPlayhead = -Infinity;
-  let prevOpen = false;
-  let held = false;
-  let done = false;
-  let live = true;
-  let cancelled = false;
-  let wantPaused = opts.autoplay === false;
-  let wantScale = 1;
-  const edited = createEmitter();
-  const playback = createEmitter();
-  const playbackChanged = playback.emit;
-  const loopOpt = opts.loop ?? false;
-  let loopsLeft = loopOpt === true ? Infinity : loopOpt === false ? 0 : loopOpt;
-  let lap = 0;
-  const booker = opts.booking ? createBooker(opts.booking, {
-    tracks: opts.tracks,
-    duration: () => duration,
-    lapsLeft: () => loopsLeft,
-    lap: () => lap,
-    playhead: () => playhead
-  }) : null;
-  const sampler = createTrackSampler(hold);
-  const fireEvents = createEventFirer(report, booker !== null);
-  const onWrap = () => {
-    if (!held) fireEvents(opts.tracks, prevPlayhead, duration, prevOpen);
-    prevPlayhead = -Infinity;
-    prevOpen = false;
-    if (report?.watched) report.lap(lap);
-  };
-  const tick = (virtualNow, scale) => {
-    lastVirtual = virtualNow;
-    const rate = scale ?? (base.isPaused() ? 0 : base.timeScale());
-    held = rate === 0;
-    const parked = held && duration > 0 && playhead === duration && loopsLeft > 0;
-    if (!parked) {
-      playhead = virtualNow + offset;
-      crossLaps(playhead, duration, loopsLeft, (laps) => {
-        loopsLeft -= laps;
-        offset -= laps * duration;
-        playhead -= laps * duration;
-        lap += laps;
-        onWrap();
-      });
-    }
-    const finished = playhead >= duration && !parked;
-    playhead = Math.min(playhead, duration);
-    sampler.apply(opts.tracks, playhead);
-    if (!held) {
-      fireEvents(opts.tracks, prevPlayhead, playhead, prevOpen);
-      prevPlayhead = playhead;
-      prevOpen = false;
-    }
-    booker?.tick(virtualNow, rate);
-    if (finished && !done) {
-      done = true;
-      opts.onDone?.();
-      playbackChanged();
-    }
-    if (playhead < duration || parked) return false;
-    live = false;
-    sampler.release();
-    return true;
-  };
-  const onCancel = () => {
-    const first = !cancelled;
-    cancelled = true;
-    live = false;
-    booker?.retract();
-    sampler.release();
-    if (first) playbackChanged();
-  };
-  const seed = { id, cancelKey: opts.cancelKey, tick, onCancel, kind: "timeline", label: opts.label, progress: () => duration > 0 ? playhead / duration : 1 };
-  const base = register(seed);
-  if (opts.autoplay === false) base.pause();
-  const rearm = () => {
-    if (cancelled || playhead >= duration) return;
-    done = false;
-    if (live) return;
-    booker?.rearm();
-    lastVirtual = 0;
-    offset = playhead;
-    live = true;
-    register({ ...seed, keepExisting: true });
-    if (wantPaused) base.pause();
-    base.setTimeScale(wantScale);
-  };
-  const sampleNow = () => {
-    if (live && playhead >= 0 && playhead < duration) sampler.apply(opts.tracks, playhead);
-  };
-  return {
-    ...base,
-    // Not just `onCancel`: cancelling a finished timeline never reaches the
-    // animator, and must still keep a later seek from reviving it.
-    cancel() {
-      onCancel();
-      base.cancel();
-    },
-    // Playback intent is tracked here, not read back from the entry: a revived
-    // one is a fresh registration, and defaults to running at scale 1.
-    pause() {
-      wantPaused = true;
-      base.pause();
-      booker?.retract();
-      playbackChanged();
-    },
-    resume() {
-      wantPaused = false;
-      base.resume();
-      playbackChanged();
-    },
-    setTimeScale(s) {
-      wantScale = s;
-      base.setTimeScale(s);
-      playbackChanged();
-    },
-    timeScale: () => live ? base.timeScale() : wantScale,
-    isPaused: () => live ? base.isPaused() : wantPaused,
-    seek(t) {
-      booker?.retract();
-      offset = t - lastVirtual;
-      playhead = t;
-      prevPlayhead = t;
-      prevOpen = true;
-      booker?.seek();
-      rearm();
-      sampleNow();
-      playbackChanged();
-    },
-    time: () => playhead,
-    duration: () => duration,
-    tracks: () => opts.tracks,
-    setLoop(loop) {
-      loopsLeft = loop === true ? Infinity : loop === false ? 0 : loop;
-      booker?.retract();
-      playbackChanged();
-    },
-    loop: () => loopsLeft === Infinity ? true : loopsLeft === 0 ? false : loopsLeft,
-    edit(fn) {
-      fn();
-      sampler.edited();
-      duration = tracksEnd(opts.tracks, opts.duration);
-      booker?.retract();
-      rearm();
-      sampleNow();
-      edited.emit();
-    },
-    subscribe: edited.subscribe,
-    subscribePlayback: playback.subscribe
-  };
-}
-
-// src/engine/decay.ts
-function decayAsPhysics(o) {
-  const shared = {
-    from: o.from,
-    to: null,
-    velocity: o.velocity,
-    stiffness: 0,
-    damping: -Math.log(o.friction ?? 0.95),
-    mass: 1,
-    restThreshold: o.threshold ?? 0.5,
-    onTick: o.onTick,
-    onDone: o.onDone,
-    cancelKey: o.cancelKey,
-    label: o.label
-  };
-  if (o.target) return { ...shared, target: o.target, interrupt: o.interrupt };
-  return {
-    ...shared,
-    from: o.from,
-    onTick: o.onTick,
-    add: o.add,
-    // DecayOptions doesn't carry subtract; derive from add+scale.
-    subtract: (a, b) => o.add(a, o.scale(b, -1)),
-    scale: o.scale,
-    magnitude: o.magnitude
-  };
-}
-
-// src/engine/holds.ts
-var groups = /* @__PURE__ */ new WeakMap();
-var share = (w) => w > 0 ? Math.min(w, 1) : 0;
-function fold(group, committed, skip, into) {
-  const n = committed.length;
-  const delta = into ? into.delta : new Array(n);
-  const total = into ? into.total : new Array(n);
-  const { members, angle } = group;
-  for (let h = 0; h < members.length; h++) {
-    const m = members[h];
-    m.w = m === skip ? 0 : m.weight();
-    if (m.w > 0) m.v = m.value();
-  }
-  for (let a = 0; a < n; a++) {
-    const c = committed[a];
-    let held = 0;
-    let sum2 = 0;
-    let sin = 0;
-    let cos = 0;
-    for (let h = 0; h < members.length; h++) {
-      const m = members[h];
-      if (m === skip || !(m.w > 0) || m.covers && !m.covers[a]) continue;
-      held += m.w;
-      if (!angle[a]) sum2 += m.w * (m.v[a] - c);
-      else {
-        sin += m.w * Math.sin(m.v[a]);
-        cos += m.w * Math.cos(m.v[a]);
-      }
-    }
-    total[a] = held;
-    if (held > 0 && angle[a]) {
-      const mean = Math.hypot(sin, cos) < 1e-9 ? null : Math.atan2(sin, cos);
-      for (let h = 0; h < members.length; h++) {
-        const m = members[h];
-        if (m === skip || !(m.w > 0) || m.covers && !m.covers[a]) continue;
-        sum2 += m.w * (mean === null ? shortWay(m.v[a] - c) : shortWay(mean - c) + shortWay(m.v[a] - mean));
-      }
-    }
-    delta[a] = held > 0 ? sum2 / Math.max(1, held) : 0;
-  }
-  return into ?? { delta, total };
-}
-function settle(group, leaving, committed) {
-  const all = fold(group, committed);
-  const rest = fold(group, committed, leaving);
-  const own = leaving.value().slice();
-  return committed.map((c, a) => {
-    if (leaving.covers && !leaving.covers[a]) return 0;
-    if (rest.total[a] >= 1 - 1e-9) return group.angle[a] ? shortWay(own[a] - c) : own[a] - c;
-    return (all.delta[a] - rest.delta[a]) / (1 - rest.total[a]);
-  });
-}
-function dim(s, before, after) {
-  for (const b of s.behind) {
-    for (let a = 0; a < before.length; a++) {
-      const open = 1 - Math.min(after[a], 1);
-      const was = 1 - Math.min(before[a], 1);
-      if (open < 1e-9 || open === was) continue;
-      b.kept ??= new Array(before.length).fill(1);
-      b.kept[a] = b.kept[a] * was / open;
-      s.dimmed = true;
-    }
-  }
-}
-function coverOf(wanted, axes) {
-  if (!wanted) return null;
-  const covers = new Uint8Array(axes.count);
-  for (const a of axisIndexes(axes, wanted)) covers[a] = 1;
-  return covers;
-}
-function openHold(ctx, o) {
-  const s = o.target;
-  const ax = s.axes;
-  const state = s;
-  axesFor(ax, o.value(), "value");
-  let gone = false;
-  const buffer = new Array(ax.count).fill(0);
-  const member = {
-    value: ax.write ? () => {
-      ax.write(o.value(), buffer, 0);
-      return buffer;
-    } : () => ax.to(o.value()),
-    weight: () => gone ? 0 : share(o.weight()),
-    covers: coverOf(o.axes, ax),
-    fixed: o.fixed === true,
-    w: 0,
-    v: buffer
-  };
-  ctx.targets.attach(state);
-  s.held += 1;
-  let group = groups.get(state);
-  if (!group) {
-    const angle = new Uint8Array(ax.count);
-    for (const a of ax.angles ?? []) angle[a] = 1;
-    const made = { members: [], voice: ctx.nextId(), angle };
-    const folded = { delta: [], total: new Array(ax.count).fill(0) };
-    groups.set(state, group = made);
-    ctx.seedClock();
-    s.slot = ctx.codec.hold({
-      id: made.voice,
-      on: s,
-      axes: ax.count,
-      still: member.fixed,
-      at: () => {
-        const committed = s.heldAt ??= new Array(ax.count).fill(0);
-        committedInto(s, committed, 0);
-        folded.delta = new Array(ax.count);
-        const { delta, total } = fold(made, committed, void 0, folded);
-        const cover = s.cover ??= new Array(ax.count).fill(0);
-        for (let a = 0; a < cover.length; a++) cover[a] = Math.min(total[a], 1);
-        return delta;
-      }
-    });
-  }
-  const { members, voice } = group;
-  members.push(member);
-  const still = () => ctx.codec.still(voice, members.every((m) => m.fixed));
-  still();
-  ctx.touch(state, true);
-  return {
-    touch: () => {
-      if (!gone) ctx.touch(state);
-    },
-    leave(commit) {
-      if (gone) return;
-      if (commit && !s.discard) {
-        const group2 = groups.get(state);
-        const committed = ax.to(s.get());
-        absorb(s, settle(group2, member, committed));
-        dim(state, fold(group2, committed).total, fold(group2, committed, member).total);
-      }
-      gone = true;
-      members.splice(members.indexOf(member), 1);
-      s.held -= 1;
-      if (s.held === 0) {
-        s.heldAt = null;
-        s.cover = null;
-        groups.delete(state);
-        ctx.codec.stop(voice);
-        const beside = s.beside;
-        s.beside = null;
-        if (beside) absorb(s, beside);
-      } else still();
-      ctx.targets.detach(state);
-      ctx.touch(state, true);
-    }
-  };
-}
-
-// src/engine/holdAnimation.ts
-var isFn = (x) => typeof x === "function";
-function startHold(ctx, o) {
-  const target = stateOf(o.target);
-  const id = ctx.nextId();
-  const { value, weight = 1 } = o;
-  const fixed = !isFn(value) && !isFn(weight);
-  const seed = {
-    id,
-    kind: "hold",
-    cancelKey: o.cancelKey,
-    label: o.label,
-    target,
-    keepExisting: o.interrupt === false,
-    idle: fixed,
-    // It leaves when released or canceled, and has nothing to do on a frame.
-    due: Infinity
-  };
-  if (o.cancelKey != null && o.interrupt !== false) ctx.interrupt(o.cancelKey, seed);
-  const held = openHold(ctx, {
-    target,
-    value: isFn(value) ? value : () => value,
-    weight: isFn(weight) ? weight : () => weight,
-    axes: o.axes,
-    fixed
-  });
-  seed.onCancel = () => held.leave(true);
-  seed.tick = () => {
-    if (!ctx.tripwire()) return false;
-    held.leave(true);
-    return true;
-  };
-  const base = ctx.register(seed);
-  return {
-    ...base,
-    touch: held.touch,
-    release(r) {
-      if (!ctx.has(id)) return;
-      held.leave(r?.commit !== false);
-      ctx.finish(id);
-    }
-  };
-}
-
-// src/engine/integrator.ts
-function stepSpring(ops, value, velocity, target, k, damping, mass, dt) {
-  const ref = target ?? value;
-  const displacement = ops.subtract(value, ref);
-  const springForce = ops.scale(displacement, target == null ? 0 : -k);
-  const dampingForce = ops.scale(velocity, -damping);
-  const accel = ops.scale(ops.add(springForce, dampingForce), 1 / mass);
-  const v = ops.add(velocity, ops.scale(accel, dt));
-  return { value: ops.add(value, ops.scale(v, dt)), velocity: v };
-}
-
-// src/engine/physicsAnimation.ts
-function resolveSpringConstants(o) {
-  const preset = o.preset ? SPRING_PRESETS[o.preset] : null;
-  return {
-    stiffness: o.stiffness ?? preset?.stiffness ?? 170,
-    damping: o.damping ?? preset?.damping ?? 26,
-    mass: o.mass ?? preset?.mass ?? 1
-  };
-}
-function startPhysics(ctx, o, kind) {
-  const { codec } = ctx;
-  const id = ctx.nextId();
-  const isNumeric = typeof o.from === "number";
-  if (!isNumeric && (!o.add || !o.subtract || !o.scale || !o.magnitude)) {
-    throw new Error("physics: add/subtract/scale/magnitude are required for non-numeric T");
-  }
-  const add = o.add ?? ((a, b) => a + b);
-  const subtract = o.subtract ?? ((a, b) => a - b);
-  const scale = o.scale ?? ((v, k) => v * k);
-  const magnitude = o.magnitude ?? ((v) => Math.abs(v));
-  const { stiffness: kBase, damping, mass } = resolveSpringConstants(o);
-  const restThreshold = o.restThreshold ?? 0.01;
-  let target = o.to ?? null;
-  let value = o.from;
-  let velocity = o.velocity ?? scale(o.from, 0);
-  let lastTime = null;
-  const solvable = damping > 0 && mass > 0 && (kBase > 0 || kind === "decay");
-  const fromAxes = solvable ? axesOf(o.from) : null;
-  const sameShape = (v) => v == null || axesOf(v)?.shape === fromAxes.shape;
-  const axes = fromAxes && sameShape(o.to) && sameShape(o.velocity) ? fromAxes : null;
-  let reader = null;
-  if (axes) {
-    ctx.seedClock();
-    reader = codec.spring({
-      id,
-      axes: axes.count,
-      from: axes.to(o.from),
-      to: o.to == null ? null : axes.to(o.to),
-      velocity: o.velocity == null ? new Array(axes.count).fill(0) : axes.to(o.velocity),
-      stiffness: kBase,
-      damping,
-      mass
-    });
-  }
-  const baseHandle = ctx.register({
-    id,
-    kind,
-    cancelKey: o.cancelKey,
-    label: o.label,
-    tick(nowMs) {
-      if (ctx.tripwire()) {
-        codec.stop(id);
-        return true;
-      }
-      if (lastTime == null) {
-        lastTime = nowMs;
-        if (target == null && magnitude(velocity) < restThreshold) {
-          codec.stop(id);
-          ctx.reportEnd(id);
-          o.onDone?.();
-          return true;
-        }
-        if (!axes) {
-          o.onTick(value);
-          return false;
-        }
-      }
-      if (axes) {
-        const m = reader.motion();
-        value = axes.from(m.value);
-        velocity = axes.from(m.velocity);
-      } else {
-        const dt = Math.min(0.064, (nowMs - lastTime) / 1e3);
-        const next = stepSpring({ add, subtract, scale }, value, velocity, target, kBase, damping, mass, dt);
-        value = next.value;
-        velocity = next.velocity;
-      }
-      lastTime = nowMs;
-      o.onTick(value);
-      const velRested = magnitude(velocity) < restThreshold;
-      const posRested = target == null ? true : magnitude(subtract(value, target)) < restThreshold;
-      if (velRested && posRested) {
-        if (target != null) o.onTick(target);
-        codec.stop(id);
-        if (ctx.has(id)) {
-          ctx.reportEnd(id);
-          o.onDone?.();
-        }
-        return true;
-      }
-      return false;
-    }
-  });
-  const checkShape = (v, what) => {
-    if (!sameShape(v)) throw new Error(`physics: ${what} is not the same shape as \`from\``);
-  };
-  return {
-    ...baseHandle,
-    setTarget: (newTo) => {
-      if (axes && newTo != null) checkShape(newTo, "setTarget");
-      target = newTo;
-      if (axes && codec.has(id)) codec.retarget(id, newTo == null ? null : axes.to(newTo));
-    },
-    setVelocity: (v) => {
-      if (axes) checkShape(v, "setVelocity");
-      velocity = v;
-      if (axes && codec.has(id)) codec.push(id, axes.to(v));
-    }
-  };
-}
-
-// src/engine/springRest.ts
-function earliestRest(value, velocity, stiffness, damping, mass, threshold) {
-  let energy = 0;
-  for (let i = 0; i < value.length; i++) energy += stiffness * value[i] ** 2 + mass * velocity[i] ** 2;
-  const atRest = (stiffness + mass) * threshold ** 2;
-  if (!(energy > atRest)) return 0;
-  return 1e3 * mass / (2 * damping) * Math.log(energy / atRest);
-}
-
-// src/engine/springVoices.ts
-function createSpringVoices(codec, s, o) {
-  const n = s.axes.count;
-  const zeros = () => new Array(n).fill(0);
-  const moving = { id: -1 };
-  const resting = { id: -1 };
-  let first = true;
-  let rate = 1;
-  let coasting = false;
-  const of = (v) => (v.id >= 0 ? codec.own(v.id) : void 0) ?? { value: zeros(), velocity: zeros() };
-  const cue = (v, from, velocity, to) => {
-    if (v.id >= 0) {
-      const was = codec.own(v.id).value;
-      codec.recue(v.id, from.slice(), velocity.slice(), to);
-      bump(s, minus(from, was), 1);
-      return;
-    }
-    v.id = first ? o.id : o.nextId();
-    first = false;
-    s.slot = codec.spring({
-      id: v.id,
-      on: s,
-      axes: n,
-      from: from.slice(),
-      to,
-      velocity: velocity.slice(),
-      stiffness: o.stiffness,
-      damping: o.damping,
-      mass: o.mass
-    });
-    if (rate !== 1) codec.rate(v.id, rate);
-    bump(s, from, 1);
-  };
-  const drop = (v) => {
-    if (v.id < 0) return;
-    const own = codec.own(v.id);
-    if (own) bump(s, own.value, -1);
-    codec.stop(v.id);
-    v.id = -1;
-  };
-  return {
-    own() {
-      const a = of(moving);
-      const b = of(resting);
-      return { value: plus(a.value, b.value), velocity: plus(a.velocity, b.velocity) };
-    },
-    moved: () => of(moving).value,
-    move(delta) {
-      const m = of(moving);
-      cue(moving, plus(m.value, delta), m.velocity, zeros());
-    },
-    settleMove: () => drop(moving),
-    rest(from, velocity, coast) {
-      coasting = coast;
-      cue(resting, from, velocity, coast ? null : zeros());
-    },
-    push(velocity) {
-      const v = minus(velocity, of(moving).velocity);
-      if (resting.id < 0) cue(resting, zeros(), v, coasting ? null : zeros());
-      else codec.push(resting.id, v);
-    },
-    rate(r) {
-      rate = r;
-      for (const v of [moving, resting]) if (v.id >= 0 && codec.has(v.id)) codec.rate(v.id, r);
-    },
-    stop() {
-      drop(moving);
-      drop(resting);
-    }
-  };
-}
-
-// src/engine/offsetPhysics.ts
-var any = (a) => a.some((x) => x !== 0);
-function constantsFor(o, kind, toward) {
-  const c = resolveSpringConstants(o);
-  if (!(c.damping > 0) || !(c.mass > 0) || toward && !(c.stiffness > 0)) {
-    throw new Error(`${kind}: an animation on a target needs positive damping and mass, and stiffness to reach \`to\``);
-  }
-  return c;
-}
-function restWaits(ctx, id, quiet, c, threshold) {
-  const until = (value, velocity, coast) => earliestRest(value, velocity, coast ? 0 : c.stiffness, c.damping, c.mass, threshold);
-  return {
-    /** The `due` it registers with. */
-    first: (value, velocity, coast) => quiet ? until(value, velocity, coast) : void 0,
-    /** Leaves it unticked until then. Answers false, as the tick of one still moving does. */
-    again(value, velocity, coast) {
-      if (quiet) ctx.defer(id, until(value, velocity, coast));
-      return false;
-    }
-  };
-}
-function startOffsetPhysics(ctx, o, kind) {
-  const s = stateOf(o.target);
-  const ax = s.axes;
-  let dest = o.to == null ? null : axesFor(ax, o.to, "to");
-  const constants = constantsFor(o, kind, dest != null);
-  const { stiffness, damping, mass } = constants;
-  const given = o.from === void 0 ? null : axesFor(ax, o.from, "from");
-  let velocity = o.velocity === void 0 ? null : axesFor(ax, o.velocity, "velocity");
-  const restThreshold = o.restThreshold ?? 0.01;
-  const zeros = () => new Array(ax.count).fill(0);
-  const id = ctx.nextId();
-  const waits = restWaits(ctx, id, !o.onTick, constants, restThreshold);
-  const interrupts = o.interrupt !== false;
-  const seed = {
-    id,
-    kind,
-    cancelKey: o.cancelKey,
-    label: o.label,
-    target: s,
-    keepExisting: !interrupts
-  };
-  if (o.cancelKey != null && interrupts) {
-    velocity ??= ctx.velocityUnder(o.cancelKey, s);
-    ctx.interrupt(o.cancelKey, seed);
-  }
-  const before = ax.to(s.get());
-  const committed = dest ? takeUp(s) : before;
-  const start = travel(ax, given ?? committed, dest ?? committed);
-  const move = dest ? travel(ax, before, dest) : zeros();
-  ctx.targets.attach(s);
-  if (o.to != null) s.set(o.to);
-  ctx.seedClock();
-  const voices = createSpringVoices(ctx.codec, s, { id, nextId: ctx.nextId, stiffness, damping, mass });
-  if (any(move)) voices.move(move);
-  const top = minus(start, move);
-  if (!any(move) || any(top) || velocity && any(velocity)) voices.rest(top, velocity ?? zeros(), dest == null);
-  const behind = goBehind(s, voices.moved);
-  let left = false;
-  const leave = (commit) => {
-    if (left) return;
-    left = true;
-    const moved = voices.moved();
-    const shown = comeOut(s, behind, moved);
-    if (commit) commitOffset(s, voices.own().value, moved, shown);
-    voices.stop();
-    ctx.targets.detach(s);
-  };
-  const finish = () => {
-    leave(dest == null);
-    ctx.reportEnd(id);
-    o.onDone?.();
-  };
-  let ticked = false;
-  seed.due = waits.first(start, velocity ?? zeros(), dest == null);
-  seed.onCancel = () => leave(true);
-  seed.onRate = (paused, timeScale) => voices.rate(paused ? 0 : timeScale);
-  seed.velocity = () => voices.own().velocity;
-  seed.tick = () => {
-    if (ctx.tripwire()) {
-      leave(true);
-      return true;
-    }
-    const own = voices.own();
-    if (!ticked && dest == null && norm(own.velocity) < restThreshold) {
-      finish();
-      return true;
-    }
-    ticked = true;
-    o.onTick?.(ax.from(plus(dest ?? ax.to(s.get()), own.value)));
-    if (!ctx.has(id)) return true;
-    if (norm(own.velocity) >= restThreshold || dest && norm(own.value) >= restThreshold) {
-      return waits.again(own.value, own.velocity, dest == null);
-    }
-    if (dest) o.onTick?.(ax.from(dest));
-    if (!ctx.has(id)) return true;
-    finish();
-    return true;
-  };
-  const base = ctx.register(seed);
-  return {
-    ...base,
-    setTarget(next) {
-      if (left) return;
-      const own = voices.own();
-      if (next == null) {
-        if (dest == null) return;
-        const moved = voices.moved();
-        absorb(s, behind.kept ? times(moved, behind.kept) : moved);
-        dest = null;
-        voices.rest(minus(own.value, moved), own.velocity, true);
-        voices.settleMove();
-        waits.again(own.value, own.velocity, true);
-        return;
-      }
-      const to = axesFor(ax, next, "setTarget");
-      if (!(stiffness > 0)) throw new Error(`${kind}: setTarget needs a positive stiffness`);
-      const shift = travel(ax, ax.to(s.get()), to);
-      s.set(next);
-      if (dest == null) voices.rest(own.value, own.velocity, false);
-      dest = to;
-      voices.move(shift);
-      waits.again(plus(own.value, shift), own.velocity, false);
-      ctx.targets.showNow(s);
-    },
-    setVelocity(v) {
-      if (left) return;
-      const pushed = axesFor(ax, v, "setVelocity");
-      waits.again(voices.own().value, pushed, dest == null);
-      voices.push(pushed);
-    }
-  };
-}
-function startOffsetTween(ctx, o) {
-  const { codec } = ctx;
-  const s = stateOf(o.target);
-  const ax = s.axes;
-  const to = axesFor(ax, o.to, "to");
-  const given = o.from === void 0 ? null : axesFor(ax, o.from, "from");
-  const id = ctx.nextId();
-  const interrupts = o.interrupt !== false;
-  const seed = {
-    id,
-    kind: "tween",
-    cancelKey: o.cancelKey,
-    label: o.label,
-    target: s,
-    keepExisting: !interrupts
-  };
-  if (o.cancelKey != null && interrupts) ctx.interrupt(o.cancelKey, seed);
-  const committed = ax.to(s.get());
-  const base = takeUp(s);
-  const from = o.from === void 0 ? ax.from(base) : o.from;
-  const path = o.interpolator ? o.interpolator(from, o.to) : o.interpolate ? (u) => o.interpolate(from, o.to, u) : null;
-  const easing = resolveEasing(o.easing ?? easeOut);
-  const ms = Math.max(o.ms, 1);
-  ctx.targets.attach(s);
-  s.set(o.to);
-  ctx.seedClock();
-  s.slot = path ? codec.path({ id, on: s, ms, axes: ax.count, at: (u) => minus(ax.to(path(easing(u))), to) }) : codec.tween({
-    id,
-    on: s,
-    ms,
-    ease: easing,
-    from: travel(ax, given ?? base, to),
-    to: new Array(ax.count).fill(0)
-  });
-  bump(s, codec.own(id).value, 1);
-  const share2 = shareBehind(ax, committed, to, travel(ax, given ?? base, to));
-  const behind = goBehind(s, () => times(codec.own(id).value, share2));
-  let left = false;
-  const leave = (commit) => {
-    if (left) return;
-    left = true;
-    const own = codec.own(id);
-    const moved = own ? behind.left() : [];
-    const shown = comeOut(s, behind, moved);
-    if (own) {
-      if (commit) commitOffset(s, own.value, moved, shown);
-      bump(s, own.value, -1);
-    }
-    codec.stop(id);
-    ctx.targets.detach(s);
-  };
-  seed.progress = (virtualNow) => o.ms <= 0 ? 1 : Math.min(1, virtualNow / o.ms);
-  if (!o.onTick) seed.due = Math.max(o.ms, 0);
-  seed.onCancel = () => leave(true);
-  seed.tick = (nowMs) => {
-    if (ctx.tripwire()) {
-      leave(true);
-      return true;
-    }
-    const t = o.ms <= 0 ? 1 : Math.min(1, nowMs / o.ms);
-    if (o.onTick) o.onTick(t >= 1 ? o.to : ax.from(plus(to, codec.own(id).value)));
-    if (t < 1) return false;
-    if (!ctx.has(id)) return true;
-    leave(false);
-    ctx.reportEnd(id);
-    o.onDone?.();
-    return true;
-  };
-  return ctx.register(seed);
-}
-
-// src/engine/completions.ts
-function createCompletions(has) {
-  const listeners = /* @__PURE__ */ new Map();
-  return {
-    fire(id) {
-      const ls = listeners.get(id);
-      if (!ls) return;
-      listeners.delete(id);
-      for (const cb of ls) cb();
-    },
-    watch(id, cb) {
-      if (!has(id)) {
-        cb();
-        return () => {
-        };
-      }
-      const ls = listeners.get(id) ?? [];
-      ls.push(cb);
-      listeners.set(id, ls);
-      return () => {
-        const cur = listeners.get(id);
-        if (!cur) return;
-        const idx = cur.indexOf(cb);
-        if (idx >= 0) cur.splice(idx, 1);
-        if (cur.length === 0) listeners.delete(id);
-      };
-    }
-  };
-}
-
-// src/engine/wakes.ts
-function createWakes() {
-  const heap = [];
-  const place = (w, i) => {
-    heap[i] = w;
-    w.heapAt = i;
-  };
-  const up = (w, i) => {
-    while (i > 0) {
-      const parent = i - 1 >> 1;
-      const p = heap[parent];
-      if (p.wakeAt <= w.wakeAt) break;
-      place(p, i);
-      i = parent;
-    }
-    place(w, i);
-  };
-  const down = (w, i) => {
-    const n = heap.length;
-    for (; ; ) {
-      let child = 2 * i + 1;
-      if (child >= n) break;
-      if (child + 1 < n && heap[child + 1].wakeAt < heap[child].wakeAt) child += 1;
-      const c = heap[child];
-      if (c.wakeAt >= w.wakeAt) break;
-      place(c, i);
-      i = child;
-    }
-    place(w, i);
-  };
-  const remove = (w) => {
-    const i = w.heapAt;
-    if (i < 0) return;
-    w.heapAt = -1;
-    const last = heap.pop();
-    if (last === w) return;
-    if (i > 0 && last.wakeAt < heap[i - 1 >> 1].wakeAt) up(last, i);
-    else down(last, i);
-  };
-  return {
-    set(w, at) {
-      remove(w);
-      w.wakeAt = at;
-      heap.push(w);
-      up(w, heap.length - 1);
-    },
-    remove,
-    due(now) {
-      const out = [];
-      while (heap.length > 0 && heap[0].wakeAt <= now) {
-        const w = heap[0];
-        remove(w);
-        out.push(w);
-      }
-      if (out.length > 1) out.sort((a, b) => a.seq - b.seq);
-      return out;
-    },
-    clear() {
-      for (const w of heap) w.heapAt = -1;
-      heap.length = 0;
-    },
-    get size() {
-      return heap.length;
-    }
-  };
-}
-
-// src/engine/schedule.ts
-function createSchedule(elapsed) {
-  const every = /* @__PURE__ */ new Set();
-  const wakes = createWakes();
-  let seq = 0;
-  let awake = 0;
-  let waiting = 0;
-  const rateOf = (a) => a.paused ? 0 : a.timeScale;
-  const clockOf = (a) => a.base + (elapsed() - a.anchor) * rateOf(a);
-  const wait = (a) => {
-    const rate = rateOf(a);
-    if (rate > 0 && a.due < Infinity) wakes.set(a, a.anchor + (a.due - a.base) / rate);
-    else wakes.remove(a);
-  };
-  return {
-    clockOf,
-    add(a) {
-      a.base = 0;
-      a.anchor = elapsed();
-      a.seq = seq++;
-      a.heapAt = -1;
-      a.wakeAt = Infinity;
-      if (!a.idle) awake += 1;
-      if (a.due === void 0) {
-        every.add(a);
-        return;
-      }
-      waiting += 1;
-      wait(a);
-    },
-    remove(a) {
-      if (!a.idle) awake -= 1;
-      if (every.delete(a)) return;
-      waiting -= 1;
-      wakes.remove(a);
-    },
-    pace(a, paused, timeScale) {
-      a.base = clockOf(a);
-      a.anchor = elapsed();
-      a.paused = paused;
-      a.timeScale = timeScale;
-      if (!every.has(a)) wait(a);
-    },
-    defer(a, ms) {
-      if (!a) return;
-      a.due = clockOf(a) + ms;
-      if (every.delete(a)) waiting += 1;
-      wait(a);
-    },
-    ticks() {
-      const steady = [...every];
-      const woke = wakes.due(elapsed());
-      if (woke.length === 0) return steady;
-      waiting -= woke.length;
-      const out = [];
-      let i = 0;
-      for (const a of woke) {
-        a.base = Math.max(clockOf(a), a.due);
-        a.anchor = elapsed();
-        every.add(a);
-        while (i < steady.length && steady[i].seq < a.seq) out.push(steady[i++]);
-        out.push(a);
-      }
-      while (i < steady.length) out.push(steady[i++]);
-      return out;
-    },
-    get awake() {
-      return awake > 0;
-    },
-    get waiting() {
-      return waiting;
-    },
-    clear() {
-      every.clear();
-      wakes.clear();
-      awake = 0;
-      waiting = 0;
-    }
-  };
-}
-
-// src/engine/roster.ts
-var NONE = [];
-function file(index, key, a, on) {
-  let set = index.get(key);
-  if (on) {
-    if (!set) index.set(key, set = /* @__PURE__ */ new Set());
-    set.add(a);
-  } else if (set?.delete(a) && set.size === 0) index.delete(key);
-}
-function createRoster(elapsed) {
-  const animations = /* @__PURE__ */ new Map();
-  const schedule = createSchedule(elapsed);
-  const byKey = /* @__PURE__ */ new Map();
-  const byTarget = /* @__PURE__ */ new Map();
-  const index = (a, on) => {
-    if (a.cancelKey != null) file(byKey, a.cancelKey, a, on);
-    if (a.target) file(byTarget, a.target, a, on);
-  };
-  const remove = (a) => {
-    animations.delete(a.id);
-    schedule.remove(a);
-    index(a, false);
-  };
-  return {
-    animations,
-    schedule,
-    under: (key) => byKey.get(key) ?? NONE,
-    on: (target) => byTarget.get(target) ?? NONE,
-    add(a) {
-      const had = animations.get(a.id);
-      if (had) remove(had);
-      animations.set(a.id, a);
-      schedule.add(a);
-      index(a, true);
-    },
-    remove,
-    clear() {
-      animations.clear();
-      schedule.clear();
-      byKey.clear();
-      byTarget.clear();
-    }
-  };
-}
-
-// src/engine/table.ts
-function timeScaleOf(scale) {
-  if (!(scale >= 0)) {
-    throw new Error(`animator: a time scale is 0 or above, and ${scale} was given; nothing plays backward`);
-  }
-  return scale;
-}
-function createTable(host) {
-  const { codec, hub } = host;
-  const roster = createRoster(host.elapsed);
-  const { animations, schedule, remove } = roster;
-  const { fire: fireCompletion, watch: watchCompletion } = createCompletions((id) => animations.has(id));
-  const infoOf = (a) => {
-    if (!a.info) {
-      const info = { id: a.id, kind: a.kind };
-      if (a.cancelKey != null) info.key = a.cancelKey;
-      if (a.label != null) info.label = a.label;
-      a.info = info;
-    }
-    return a.info;
-  };
-  const reportEnd = (id) => {
-    const a = animations.get(id);
-    if (!a || a.ended) return;
-    a.ended = true;
-    if (hub.watched) hub.emit({ type: "end", animation: infoOf(a) });
-  };
-  const retire = (id, by, error) => {
-    const a = animations.get(id);
-    if (!a) return;
-    a.onCancel?.();
-    codec.stop(id);
-    remove(a);
-    if (host.resting()) host.requestFrame();
-    fireCompletion(id);
-    if (!hub.watched || a.ended || error) return;
-    hub.emit(by ? { type: "interrupt", animation: infoOf(a), by: infoOf(by) } : { type: "cancel", animation: infoOf(a) });
-  };
-  const cancelByKey = (key, by) => {
-    for (const a of [...roster.under(key)]) retire(a.id, by);
-  };
-  const pace = (a, paused, timeScale) => {
-    schedule.pace(a, paused, timeScale);
-    if (codec.has(a.id)) codec.rate(a.id, paused ? 0 : timeScale);
-    a.onRate?.(paused, timeScale);
-  };
-  const register = (seed) => {
-    const anim = seed;
-    if (seed.cancelKey != null && !seed.keepExisting) cancelByKey(seed.cancelKey, anim);
-    anim.paused = false;
-    anim.timeScale = 1;
-    host.seedClock();
-    roster.add(anim);
-    if (anim.target) host.showNow(anim.target);
-    if (hub.watched) hub.emit({ type: "start", animation: infoOf(anim) });
-    if (animations.size > 0 && !host.framing()) host.requestFrame();
-    const live = () => animations.get(anim.id);
-    return {
-      id: anim.id,
-      cancel: () => retire(anim.id),
-      pause: () => {
-        const a = live();
-        if (a) pace(a, true, a.timeScale);
-      },
-      resume: () => {
-        const a = live();
-        if (a) pace(a, false, a.timeScale);
-      },
-      setTimeScale: (s) => {
-        const a = live();
-        if (a) pace(a, a.paused, timeScaleOf(s));
-      },
-      timeScale: () => live()?.timeScale ?? 1,
-      isPaused: () => live()?.paused ?? false
-    };
-  };
-  return {
-    animations,
-    infoOf,
-    reportEnd,
-    retire,
-    cancelByKey,
-    under: roster.under,
-    on: roster.on,
-    pace,
-    clockOf: schedule.clockOf,
-    defer: (id, ms) => schedule.defer(animations.get(id), ms),
-    ticks: schedule.ticks,
-    get awake() {
-      return schedule.awake;
-    },
-    get waiting() {
-      return schedule.waiting;
-    },
-    register,
-    finish(id) {
-      const a = animations.get(id);
-      if (!a) return;
-      reportEnd(id);
-      remove(a);
-      fireCompletion(id);
-    },
-    drop(a) {
-      remove(a);
-      fireCompletion(a.id);
-    },
-    cancelAll(cleared) {
-      const retired = [];
-      for (const a of animations.values()) {
-        a.onCancel?.();
-        codec.stop(a.id);
-        retired.push(a);
-      }
-      roster.clear();
-      cleared();
-      for (const a of retired) fireCompletion(a.id);
-      if (hub.watched) for (const a of retired) hub.emit({ type: "cancel", animation: infoOf(a) });
-    },
-    watchCompletion
-  };
-}
-function startTween(ctx, o) {
-  const { codec } = ctx;
-  const fromAxes = o.interpolate || o.interpolator ? null : axesOf(o.from);
-  const toAxes = fromAxes && axesOf(o.to);
-  const axes = fromAxes && toAxes && toAxes.shape === fromAxes.shape ? fromAxes : null;
-  if (!axes && !o.interpolate && !o.interpolator) {
-    throw new Error("tween: interpolate or interpolator is required for non-numeric T");
-  }
-  const id = ctx.nextId();
-  const easing = resolveEasing(o.easing ?? easeOut);
-  const factoryFn = o.interpolator ? o.interpolator(o.from, o.to) : null;
-  let lastValueEmitted = false;
-  ctx.seedClock();
-  const reader = codec.tween({
-    id,
-    ms: Math.max(o.ms, 1),
-    ease: easing,
-    from: axes ? axes.to(o.from) : [0],
-    to: axes ? axes.to(o.to) : [1]
-  });
-  return ctx.register({
-    id,
-    kind: "tween",
-    cancelKey: o.cancelKey,
-    label: o.label,
-    progress: (virtualNow) => o.ms <= 0 ? 1 : Math.min(1, virtualNow / o.ms),
-    // `nowMs` is the call's own virtual time, so it still decides when the tween ends; the codec
-    // supplies only the value in between.
-    tick(nowMs) {
-      if (ctx.tripwire()) {
-        codec.stop(id);
-        return true;
-      }
-      const t = o.ms <= 0 ? 1 : Math.min(1, nowMs / o.ms);
-      let value;
-      if (axes) {
-        value = t >= 1 ? o.to : axes.from(reader.cols, reader.at);
-      } else {
-        const eased = t >= 1 ? easing(1) : reader.cols[reader.at];
-        value = factoryFn ? factoryFn(eased) : o.interpolate(o.from, o.to, eased);
-      }
-      o.onTick(value);
-      if (t >= 1 && !lastValueEmitted) {
-        lastValueEmitted = true;
-        codec.stop(id);
-        if (ctx.has(id)) {
-          ctx.reportEnd(id);
-          o.onDone?.();
-        }
-        return true;
-      }
-      return false;
-    }
-  });
-}
-
-// src/engine/animatorApi.ts
-function eachUnder(table, key, pace) {
-  for (const a of table.under(key)) table.pace(a, ...pace(a));
-}
-function liveRows(table) {
-  const rows = [];
-  for (const a of table.animations.values()) {
-    rows.push({
-      ...table.infoOf(a),
-      paused: a.paused,
-      timeScale: a.timeScale,
-      elapsed: table.clockOf(a),
-      ...a.progress ? { progress: a.progress(table.clockOf(a)) } : {}
-    });
-  }
-  return rows;
-}
-function startTimeline(host, o) {
-  const { ctx, table, hub } = host;
-  const id = ctx.nextId();
-  const info = () => {
-    const a = table.animations.get(id);
-    return a && table.infoOf(a);
-  };
-  const hold = (target, value, weight, axes) => openHold(ctx, { target: stateOf(target), value, weight, axes });
-  return createTimeline(table.register, id, o, {
-    get watched() {
-      return hub.watched;
-    },
-    fire: (track, path, event, lateBy) => {
-      const animation = info();
-      if (animation) hub.emit({ type: "fire", animation, track, path: path.slice(), event, lateBy });
-    },
-    lap: (lap) => {
-      const animation = info();
-      if (animation) hub.emit({ type: "lap", animation, lap });
-    }
-  }, hold);
-}
-function createAnimatorApi(host) {
-  const { ctx, table, clock, hub } = host;
-  const { animations } = table;
-  const createSupervisor = supervisors({
-    nextId: ctx.nextId,
-    register: table.register,
-    finish: table.finish,
-    afterTicks: host.afterTicks
-  });
-  const physics = (o, kind = "physics") => o.target ? startOffsetPhysics(ctx, o, kind) : startPhysics(ctx, o, kind);
-  const api = {
-    tween: (o) => o.target ? startOffsetTween(ctx, o) : startTween(ctx, o),
-    spring: (o) => physics(o, "spring"),
-    decay: (o) => physics(decayAsPhysics(o), "decay"),
-    physics,
-    hold: (o) => startHold(ctx, o),
-    cancel: (handle) => table.retire(handle.id),
-    cancelKey: (key) => table.cancelByKey(key),
-    cancelAll: () => {
-      table.cancelAll(() => {
-        clock.frameT = null;
-        ctx.targets.show();
-      });
-      host.halt();
-    },
-    isActive: (key) => {
-      if (key == null) return animations.size > 0;
-      for (const _ of table.under(key)) return true;
-      return false;
-    },
-    isTicking: host.ticking,
-    pause: () => {
-      clock.paused = true;
-    },
-    resume: () => {
-      clock.paused = false;
-    },
-    isPaused: () => clock.paused,
-    setTimeScale: (s) => {
-      clock.timeScale = timeScaleOf(s);
-    },
-    timeScale: () => clock.timeScale,
-    pauseKey: (key) => eachUnder(table, key, (a) => [true, a.timeScale]),
-    resumeKey: (key) => eachUnder(table, key, (a) => [false, a.timeScale]),
-    setTimeScaleByKey: (key, s) => {
-      const scale = timeScaleOf(s);
-      eachUnder(table, key, (a) => [a.paused, scale]);
-    },
-    loop: (factory, loopOpts) => createLoop(createSupervisor, factory, loopOpts),
-    tweenLoop: (tweenLoopOpts) => createTweenLoop(api, createSupervisor, tweenLoopOpts),
-    stagger: ((items, delay, factory, staggerOpts) => createStagger(
-      api,
-      createSupervisor,
-      table.watchCompletion,
-      items,
-      delay,
-      factory,
-      staggerOpts
-    )),
-    timeline: (o) => startTimeline(host, o),
-    colorOverrides: host.colorOverrides,
-    onTick: (cb) => host.subscribers.subscribe(cb),
-    keepAlive: () => {
-      const sup = createSupervisor({ kind: "keepAlive" });
-      return () => sup.cancel();
-    },
-    watch: (listener) => hub.add(listener),
-    live: () => liveRows(table)
-  };
-  return api;
-}
-function createHoldVoices() {
-  const asked = /* @__PURE__ */ new Set();
-  const stills = /* @__PURE__ */ new Map();
-  const stale2 = /* @__PURE__ */ new Set();
-  const cue = (v) => {
-    const { start } = v;
-    const { lane, key } = v.slot;
-    v.handle?.fade({ over: 0 });
-    stale2.delete(v);
-    if (start.still) {
-      v.last = start.at();
-      const rest = tween("v", { from: v.last, to: v.last.slice(), ms: 1 });
-      v.handle = lane.mix.cue({ patch: rest, subjects: [key] });
-      return;
-    }
-    const each = patch(
-      1,
-      () => {
-        v.last = start.at();
-        return { v: v.last };
-      },
-      { writes: ["v"] }
-    );
-    v.handle = lane.mix.cue({ patch: each, subjects: [key], loop: true });
-  };
-  const settle2 = () => {
-    for (const v of stale2) cue(v);
-  };
-  return {
-    add(slot, start) {
-      const v = { slot, start: { ...start } };
-      if (start.still) {
-        stills.set(start.on, v);
-        stale2.add(v);
-      } else {
-        cue(v);
-        asked.add(v);
-      }
-      return v;
-    },
-    still(v, still) {
-      if (!v.start.still === !still) return;
-      v.start.still = still;
-      if (still) {
-        asked.delete(v);
-        stills.set(v.start.on, v);
-      } else {
-        stills.delete(v.start.on);
-        asked.add(v);
-      }
-      cue(v);
-    },
-    touch(on) {
-      const v = stills.get(on);
-      if (v) stale2.add(v);
-    },
-    settle: settle2,
-    frame() {
-      for (const v of asked) v.slot.lane.mix.touch(v.slot.key);
-      settle2();
-    },
-    remove(v) {
-      v.handle?.fade({ over: 0 });
-      asked.delete(v);
-      stale2.delete(v);
-      if (stills.get(v.start.on) === v) stills.delete(v.start.on);
-    }
-  };
-}
-function depart(s) {
-  const l = s.lane;
-  l.dirty = true;
-  if (s.index < 0) {
-    l.pending.delete(s);
-    return;
-  }
-  const lastKey = l.keys.pop();
-  const moved = l.slots.pop();
-  if (moved === s) return;
-  const n = l.axes;
-  const from = l.keys.length * n;
-  l.cols.v.copyWithin(s.index * n, from, from + n);
-  l.keys[s.index] = lastKey;
-  l.slots[s.index] = moved;
-  l.tags[s.index] = moved.tag;
-  moved.index = s.index;
-  moved.at = s.index * n;
-}
-function rebuild(l) {
-  const keys = l.keys.slice();
-  const had = keys.length;
-  for (const s of l.pending) {
-    s.index = keys.length;
-    s.at = s.index * l.axes;
-    s.cols = l.cols.v;
-    keys.push(s.key);
-    l.slots.push(s);
-  }
-  l.pending.clear();
-  l.keys = keys;
-  if (l.tags.length < keys.length) {
-    const tags = new Int32Array(Math.max(keys.length, l.tags.length * 2));
-    tags.set(l.tags);
-    l.tags = tags;
-  }
-  for (let i = had; i < keys.length; i++) l.tags[i] = l.slots[i].tag;
-  if (l.cols.v.length !== keys.length * l.axes) {
-    l.cols = { v: new Float64Array(keys.length * l.axes) };
-    for (const s of l.slots) s.cols = l.cols.v;
-  }
-  l.dirty = false;
-}
-function createLanes(placeOf) {
-  const lanes = /* @__PURE__ */ new Map();
-  const slots = /* @__PURE__ */ new Map();
-  const touched = /* @__PURE__ */ new Set();
-  let now = 0;
-  const laneOf = (axes, group) => {
-    const key = group ?? axes;
-    let l = lanes.get(key);
-    if (!l) {
-      const m = mix(kit({ v: vec(axes, sum()) }));
-      m.sync(now);
-      l = {
-        key,
-        axes,
-        mix: m,
-        keys: [],
-        slots: [],
-        tags: new Int32Array(0),
-        pending: /* @__PURE__ */ new Set(),
-        dirty: false,
-        idle: 0,
-        cols: { v: new Float64Array(0) }
-      };
-      lanes.set(key, l);
-    }
-    return l;
-  };
-  return {
-    join(axes, key, held) {
-      const had = slots.get(key);
-      if (had) {
-        if (had.lane.axes !== axes) {
-          throw new Error(`codec: a subject on ${had.lane.axes} axes was given a voice on ${axes}`);
-        }
-        had.refs += 1;
-        return had;
-      }
-      const place = typeof key === "object" && key !== null ? placeOf?.(key) : void 0;
-      const lane = laneOf(axes, place?.group);
-      if (lane.axes !== axes) throw new Error(`codec: a group on ${lane.axes} axes was given a subject on ${axes}`);
-      const own = Float64Array.from(held);
-      const s = { key, lane, refs: 1, index: -1, held: own, cols: own, at: 0, tag: place?.tag ?? -1 };
-      slots.set(key, s);
-      lane.pending.add(s);
-      lane.dirty = true;
-      return s;
-    },
-    leave(s) {
-      s.refs -= 1;
-      if (s.refs > 0) return;
-      s.lane.mix.drop(s.key);
-      depart(s);
-      slots.delete(s.key);
-    },
-    frame(time) {
-      now = time;
-      for (const l of lanes.values()) {
-        if (l.dirty) rebuild(l);
-        if (l.keys.length === 0 && ++l.idle >= 2) {
-          lanes.delete(l.key);
-          continue;
-        }
-        l.mix.sync(time);
-        if (l.keys.length === 0) continue;
-        l.idle = 0;
-        l.mix.pull(l.keys, l.cols);
-      }
-      touched.clear();
-    },
-    columns(group) {
-      const l = lanes.get(group);
-      return l ? { cols: l.cols.v, tags: l.tags, count: l.keys.length } : null;
-    },
-    touch(key) {
-      const s = slots.get(key);
-      if (!s) return;
-      s.lane.mix.touch(key);
-      touched.add(s);
-    },
-    refresh(each) {
-      for (const s of touched) {
-        touched.delete(s);
-        if (slots.get(s.key) !== s) continue;
-        const out = s.lane.mix.probe(s.key, { v: new Array(s.lane.axes).fill(0) });
-        s.cols.set(out.v, s.at);
-        each(s);
-      }
-    }
-  };
-}
-
-// src/engine/codec.ts
-function createCodec(placeOf) {
-  const lanes = createLanes(placeOf);
-  const voices = /* @__PURE__ */ new Map();
-  const queue = [];
-  const holds = createHoldVoices();
-  let time = 0;
-  const springVoice = (slot, sp) => {
-    const patch = sp.to == null ? glide("v", { from: sp.from, ms: 1e3 * sp.mass / sp.damping }) : spring("v", {
-      from: sp.from,
-      to: sp.from,
-      stiffness: sp.stiffness,
-      damping: sp.damping,
-      mass: sp.mass
-    });
-    const handle = slot.lane.mix.cue({ patch, subjects: [slot.key] });
-    if (sp.to) patch.to(slot.key, sp.to, 0);
-    patch.push(slot.key, sp.velocity, 0);
-    return { handle, patch };
-  };
-  const get = (id) => {
-    const v = voices.get(id);
-    if (!v) throw new Error(`codec: no subject ${id}`);
-    return v;
-  };
-  const current = (v) => v.patch.read(v.slot.key) ?? { value: v.spring.from.slice(), velocity: v.spring.velocity.slice() };
-  const respring = (v, next) => {
-    const rate = v.handle.rate;
-    v.handle.fade({ over: 0 });
-    const { handle, patch } = springVoice(v.slot, next);
-    handle.rate = rate;
-    v.handle = handle;
-    v.patch = patch;
-    v.spring = next;
-  };
-  function stop(id) {
-    const v = voices.get(id);
-    if (!v) return;
-    if (v.held) holds.remove(v.held);
-    else if (v.queued) v.queued = void 0;
-    else v.handle.fade({ over: 0 });
-    lanes.leave(v.slot);
-    voices.delete(id);
-  }
-  return {
-    frame(dtMs) {
-      for (const v of queue) {
-        const q = v.queued;
-        if (!q) continue;
-        v.queued = void 0;
-        const key = v.slot.key;
-        const patch = tween("v", { from: q.from.slice(), to: q.from.slice(), ms: q.ms, ease: q.ease });
-        v.handle = v.slot.lane.mix.cue({ patch, subjects: [key] });
-        v.patch = patch;
-        patch.to(key, q.to.slice(), 0);
-        if (v.queuedRate !== void 0) v.handle.rate = v.queuedRate;
-      }
-      queue.length = 0;
-      holds.frame();
-      time += dtMs;
-      lanes.frame(time);
-    },
-    tween(s) {
-      if (s.to.length !== s.from.length) {
-        throw new Error(`codec: tween ${s.id} goes from ${s.from.length} axes to ${s.to.length}`);
-      }
-      const shared = s.on !== void 0;
-      const slot = lanes.join(s.from.length, shared ? s.on : s.id, shared ? new Array(s.from.length).fill(0) : s.from);
-      const v = { kind: "tween", slot, from: s.from, queued: s };
-      voices.set(s.id, v);
-      queue.push(v);
-      return slot;
-    },
-    spring(s) {
-      const sp = { ...s, from: s.from.slice(), to: s.to && s.to.slice(), velocity: s.velocity.slice() };
-      const shared = s.on !== void 0;
-      const slot = lanes.join(sp.axes, shared ? s.on : s.id, shared ? new Array(sp.axes).fill(0) : sp.from);
-      const { handle, patch } = springVoice(slot, sp);
-      const v = { kind: "spring", slot, handle, patch, from: sp.from, spring: sp };
-      voices.set(s.id, v);
-      const reader = slot;
-      if (!shared) reader.motion = () => current(v);
-      return reader;
-    },
-    path(s) {
-      const shared = s.on !== void 0;
-      const from = s.at(0);
-      const slot = lanes.join(s.axes, shared ? s.on : s.id, shared ? new Array(s.axes).fill(0) : from);
-      const v = { kind: "path", slot, from };
-      const patch$1 = patch(
-        s.ms,
-        (phase) => {
-          v.last = s.at(phase);
-          return { v: v.last };
-        },
-        { writes: ["v"] }
-      );
-      v.handle = slot.lane.mix.cue({ patch: patch$1, subjects: [slot.key], loop: false, freeze: "after" });
-      voices.set(s.id, v);
-      return slot;
-    },
-    hold(s) {
-      const zeros = new Array(s.axes).fill(0);
-      const slot = lanes.join(s.axes, s.on, zeros);
-      voices.set(s.id, { kind: "hold", slot, from: zeros, held: holds.add(slot, s) });
-      return slot;
-    },
-    still(id, still) {
-      const v = get(id);
-      if (!v.held) throw new Error(`codec: subject ${id} is a ${v.kind}, not a hold`);
-      holds.still(v.held, still);
-    },
-    touch(on) {
-      holds.touch(on);
-      lanes.touch(on);
-    },
-    refresh(reread) {
-      holds.settle();
-      lanes.refresh((slot) => {
-        const queued = new Array(slot.lane.axes).fill(0);
-        for (const v of queue) {
-          if (v.queued && v.slot === slot) v.queued.from.forEach((x, i) => {
-            queued[i] += x;
-          });
-        }
-        reread(slot.key, queued);
-      });
-    },
-    retarget(id, to) {
-      const v = get(id);
-      if (v.kind !== "spring") throw new Error(`codec: subject ${id} is a ${v.kind}; ${v.kind}s are not retargeted`);
-      const sp = v.spring;
-      if (to == null === (sp.to == null)) {
-        if (!to) return;
-        sp.to = to.slice();
-        v.patch.to(v.slot.key, sp.to);
-        return;
-      }
-      const now = current(v);
-      respring(v, { ...sp, to: to && to.slice(), from: now.value, velocity: now.velocity });
-    },
-    recue(id, from, velocity, to) {
-      const v = get(id);
-      if (v.kind !== "spring") throw new Error(`codec: subject ${id} is a ${v.kind}; only springs are re-cued`);
-      respring(v, { ...v.spring, from: from.slice(), velocity: velocity.slice(), to: to && to.slice() });
-    },
-    push(id, velocity) {
-      const v = get(id);
-      if (v.spring && !v.patch.read(v.slot.key)) v.spring.velocity = velocity.slice();
-      v.patch.push?.(v.slot.key, velocity);
-    },
-    rate(id, rate) {
-      const v = get(id);
-      if (v.kind === "hold") return;
-      if (v.queued) v.queuedRate = rate;
-      else v.handle.rate = rate;
-    },
-    stop,
-    has: (id) => voices.has(id),
-    own(id) {
-      const v = voices.get(id);
-      if (!v) return void 0;
-      if (v.kind === "spring") return current(v);
-      if (v.kind === "path" || v.kind === "hold") {
-        return { value: v.held?.last ?? v.last ?? v.from, velocity: new Array(v.from.length).fill(0) };
-      }
-      return !v.queued && v.patch.read(v.slot.key) || { value: v.from, velocity: new Array(v.from.length).fill(0) };
-    },
-    voiceCount: () => voices.size,
-    columns: (group) => lanes.columns(group)
-  };
-}
-
-// src/engine/frame.ts
-function createFrame(host) {
-  const { clock, table, hub } = host;
-  const { animations } = table;
-  let framing = false;
-  let tickDepth = 0;
-  const tickEach = () => {
-    const finished = [];
-    const threw = [];
-    const all = table.waiting > 0 && host.tripwire();
-    for (const anim of all ? [...animations.values()] : table.ticks()) {
-      if (animations.get(anim.id) !== anim) continue;
-      const scale = clock.paused ? 0 : clock.timeScale * (anim.paused ? 0 : anim.timeScale);
-      tickDepth += 1;
-      try {
-        if (anim.tick(table.clockOf(anim), scale)) finished.push(anim);
-      } catch (error) {
-        threw.push([anim, error]);
-      } finally {
-        tickDepth -= 1;
-      }
-    }
-    for (const [anim, error] of threw) {
-      console.error("useAnimator: animation tick threw; retiring it", error);
-      if (animations.get(anim.id) !== anim) continue;
-      if (anim.ended) table.drop(anim);
-      else table.retire(anim.id, void 0, true);
-      if (hub.watched) hub.emit({ type: "error", animation: table.infoOf(anim), error });
-    }
-    return finished;
-  };
-  return {
-    tick(t) {
-      const frameDt = clock.frameT == null ? 0 : Math.max(0, t - clock.frameT);
-      clock.frameT = t;
-      framing = true;
-      const dt = frameDt * (clock.paused ? 0 : clock.timeScale);
-      clock.elapsed += dt;
-      host.codec.frame(dt);
-      host.targets.settle();
-      for (const anim of tickEach()) {
-        if (animations.get(anim.id) === anim) table.finish(anim.id);
-      }
-      for (const cb of host.afterTicks.splice(0)) {
-        try {
-          cb();
-        } catch (err) {
-          console.error("useAnimator: a staggered start threw", err);
-        }
-      }
-      host.reread();
-      framing = false;
-      host.targets.show();
-      host.subscribers.emit();
-      if (table.awake) {
-        host.requestFrame();
-        return;
-      }
-      clock.frameT = null;
-    },
-    framing: () => framing,
-    ticking: () => tickDepth > 0
-  };
-}
-function createAnimatorCore(host) {
-  const clock = { frameT: null, elapsed: 0, timeScale: 1, paused: false };
-  const hub = new AnimatorEventHub();
-  const codec = createCodec((on) => {
-    const { row } = on;
-    return row ? { group: row.table, tag: row.index } : void 0;
-  });
-  const afterTicks = [];
-  const subscribers = createEmitter();
-  let nextId = 1;
-  const seedClock = () => {
-    if (clock.frameT == null) clock.frameT = host.now();
-  };
-  const reread = () => codec.refresh((on, queued) => targets.reread(on, queued));
-  const table = createTable({
-    codec,
-    hub,
-    elapsed: () => clock.elapsed,
-    seedClock,
-    showNow: (target) => targets.showNow(target),
-    resting: () => targets.resting,
-    framing: () => frame.framing(),
-    requestFrame: host.requestFrame
-  });
-  const targets = createTargetBook({
-    stop: (s) => {
-      for (const a of [...table.on(s)]) table.retire(a.id);
-    },
-    reread: (s) => {
-      codec.touch(s);
-      reread();
-    },
-    columns: (table2) => codec.columns(table2)
-  });
-  const frame = createFrame({
-    clock,
-    table,
-    codec,
-    targets,
-    hub,
-    afterTicks,
-    subscribers,
-    reread,
-    requestFrame: host.requestFrame,
-    tripwire: host.tripwire
-  });
-  const ctx = {
-    codec,
-    targets,
-    nextId: () => nextId++,
-    seedClock,
-    register: table.register,
-    has: (id) => table.animations.has(id),
-    defer: table.defer,
-    reportEnd: table.reportEnd,
-    finish: table.finish,
-    touch: (target, at) => {
-      codec.touch(target);
-      if (frame.framing() && !at) return;
-      reread();
-      if (!frame.framing()) host.requestFrame();
-    },
-    tripwire: host.tripwire,
-    interrupt: (key, by) => table.cancelByKey(key, by),
-    velocityUnder: (key, target) => {
-      let sum2 = null;
-      for (const a of table.under(key)) {
-        if (a.target !== target) continue;
-        const v = a.velocity?.() ?? codec.own(a.id)?.velocity;
-        if (v) sum2 = sum2 ? sum2.map((x, i) => x + v[i]) : v.slice();
-      }
-      return sum2;
-    }
-  };
-  const api = createAnimatorApi({
-    ctx,
-    table,
-    clock,
-    hub,
-    ticking: frame.ticking,
-    afterTicks: (cb) => {
-      afterTicks.push(cb);
-    },
-    subscribers,
-    colorOverrides: host.colorOverrides,
-    halt: host.cancelFrame
-  });
-  return {
-    api,
-    tick: frame.tick,
-    resumed() {
-      clock.frameT = null;
-    }
-  };
-}
-
-// src/useAnimator.ts
-function useAnimator(opts = {}) {
-  const optsRef = useLatest(opts);
-  const colorOverrides = useRef(new ColorOverrideRegistry());
-  const coreRef = useRef(null);
-  const frameLoop = useVisibleRaf(
-    useCallback((t) => {
-      coreRef.current?.tick(t);
-    }, []),
-    {
-      requestFrame: opts.requestFrame,
-      cancelFrame: opts.cancelFrame,
-      onResume: () => coreRef.current?.resumed()
-    }
-  );
-  const frameLoopRef = useLatest(frameLoop);
-  const mountedRef = useRef(true);
-  const trippedRef = useRef(false);
-  const core = useMemo(() => {
-    const tripwire = () => {
-      if (mountedRef.current) return false;
-      if (!trippedRef.current) {
-        trippedRef.current = true;
-        const isDev = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
-        if (isDev) {
-          console.error(
-            "weasel useAnimator: animation tick fired after the host component unmounted. This usually means cleanup logic was bypassed \u2014 check for refactors that removed the unmount effect or replaced cancelAll with a custom path."
-          );
-        }
-      }
-      return true;
-    };
-    const now = () => (optsRef.current.now ?? (typeof performance !== "undefined" ? performance.now.bind(performance) : Date.now))();
-    return createAnimatorCore({
-      now,
-      requestFrame: () => frameLoopRef.current.request(),
-      cancelFrame: () => frameLoopRef.current.cancel(),
-      tripwire,
-      colorOverrides: colorOverrides.current
-    });
-  }, [frameLoopRef, optsRef]);
-  useInsertionEffect(() => {
-    coreRef.current = core;
-  }, [core]);
-  const { api } = core;
-  useEffect(() => {
-    const overrides = colorOverrides.current;
-    mountedRef.current = true;
-    return () => {
-      mountedRef.current = false;
-      api.cancelAll();
-      overrides.clearAll();
-    };
-  }, [api]);
-  return api;
-}
-
 // src/slew.ts
 function checkRate(name, rate) {
   if (rate === void 0) return Infinity;
@@ -3682,13 +426,13 @@ function skeletonAxes(skeleton) {
     }
   };
 }
-var TAU2 = Math.PI * 2;
+var TAU = Math.PI * 2;
 function wrap(a) {
-  return a - TAU2 * Math.round(a / TAU2);
+  return a - TAU * Math.round(a / TAU);
 }
 function clampAngle(v, limit) {
   if (!limit) return v;
-  for (const c of [v, v - TAU2, v + TAU2]) if (c >= limit.min && c <= limit.max) return c;
+  for (const c of [v, v - TAU, v + TAU]) if (c >= limit.min && c <= limit.max) return c;
   return Math.abs(wrap(v - limit.min)) <= Math.abs(wrap(v - limit.max)) ? limit.min : limit.max;
 }
 var cross = (ax, ay, bx, by) => ax * by - ay * bx;
@@ -3821,7 +565,7 @@ function skinPath(path, skin, motions) {
   const rest = skinnable(path);
   const from = rest.coords;
   const count = from.length >> 1;
-  const sum2 = new Float64Array(from.length);
+  const sum = new Float64Array(from.length);
   const total = new Float64Array(count);
   for (const joint in skin) {
     const m = motions.get(joint);
@@ -3833,16 +577,16 @@ function skinPath(path, skin, motions) {
       if (!(w > 0)) continue;
       const x = from[2 * i];
       const y = from[2 * i + 1];
-      sum2[2 * i] += w * (m[0] * x + m[3] * y + m[6]);
-      sum2[2 * i + 1] += w * (m[1] * x + m[4] * y + m[7]);
+      sum[2 * i] += w * (m[0] * x + m[3] * y + m[6]);
+      sum[2 * i + 1] += w * (m[1] * x + m[4] * y + m[7]);
       total[i] += w;
     }
   }
   const coords = new Float32Array(from.length);
   for (let i = 0; i < count; i++) {
     const t = total[i];
-    coords[2 * i] = t > 0 ? sum2[2 * i] / t : from[2 * i];
-    coords[2 * i + 1] = t > 0 ? sum2[2 * i + 1] / t : from[2 * i + 1];
+    coords[2 * i] = t > 0 ? sum[2 * i] / t : from[2 * i];
+    coords[2 * i + 1] = t > 0 ? sum[2 * i + 1] / t : from[2 * i + 1];
   }
   return { ...rest, coords };
 }
@@ -4007,6 +751,6 @@ function brushWeights(coords, x, y, radius, current, mode) {
   return out;
 }
 
-export { ColorOverrideRegistry, IDENTITY_JOINT, addJoint, autoSkin, axesOf, bindClip, brushWeights, createSlew, createTarget, createTargetTable, cycleVertexColors, dropSkinJoints, jointAt, jointAxes, jointPositions, mirrorPose, motionsFromRest, moveJoint, rainbowVertexColors, removeJoint, resolveSkeleton, sampleTrack, setWeights, skeletonAxes, skinPath, skinnable, slewToward, solidVertexColors, solveIk, springVertexColors, staggerVertexColors, toClip, tweenVertexColors, useAnimator };
+export { IDENTITY_JOINT, addJoint, autoSkin, bindClip, brushWeights, createSlew, cycleVertexColors, dropSkinJoints, jointAt, jointAxes, jointPositions, mirrorPose, motionsFromRest, moveJoint, rainbowVertexColors, removeJoint, resolveSkeleton, setWeights, skeletonAxes, skinPath, skinnable, slewToward, solidVertexColors, solveIk, springVertexColors, staggerVertexColors, toClip, tweenVertexColors };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map