@weasel-js/animator 0.0.0-stage → 1.10.0

package/dist/index.js

@@ -0,0 +1,4015 @@
+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 { 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;
+  if (loopsLeft === Infinity) {
+    take(Math.floor(playhead / duration));
+    return;
+  }
+  for (let at = playhead, left = loopsLeft; at >= duration && left > 0; at -= duration, left -= 1) take(1);
+}
+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;
+  if (!(rate >= 0)) throw new RangeError(`slew: ${name} must be a rate >= 0, got ${rate}`);
+  return rate;
+}
+function slewToward(value, target, dt, rates) {
+  const rise = checkRate("rise", rates.rise);
+  const fall = checkRate("fall", rates.fall);
+  if (target > value) return Math.min(target, value + rise * dt);
+  if (target < value) return Math.max(target, value - fall * dt);
+  return value;
+}
+function createSlew(options = {}) {
+  const rates = { rise: checkRate("rise", options.rise), fall: checkRate("fall", options.fall) };
+  const value = options.value ?? 0;
+  const slew = {
+    value,
+    target: options.target ?? value,
+    step(dt) {
+      slew.value = slewToward(slew.value, slew.target, dt, rates);
+      return slew.value;
+    }
+  };
+  return slew;
+}
+function resolveInterpolator(opts) {
+  if (opts.interpolate) return opts.interpolate;
+  const space = opts.interpolation ?? "rgb";
+  return (a, b, t) => lerpColorArray(a, b, t, space);
+}
+
+// src/colorHelpers.ts
+function validateLengths(from, to) {
+  if (from.length !== to.length) {
+    throw new Error(
+      `vertex colors: length mismatch (from=${from.length}, to=${to.length})`
+    );
+  }
+  if (from.length === 0 || from.length % 4 !== 0) {
+    throw new Error(
+      `vertex colors: length ${from.length} must be a positive multiple of 4`
+    );
+  }
+}
+var cancelKeyFor = (id, channel) => `colors:${id}:${channel}`;
+var COLOR_REST = 1e-3;
+function tweenColors(animator, opts, ms, easing, colorsAt) {
+  const { id, channel } = opts;
+  const registry = animator.colorOverrides;
+  return animator.tween({
+    target: registry.target(id, channel, opts.from.length),
+    from: opts.from.slice(),
+    to: opts.to.slice(),
+    ms,
+    easing,
+    cancelKey: cancelKeyFor(id, channel),
+    interrupt: false,
+    interpolate: (_from, _to, t) => colorsAt(t),
+    onDone: () => {
+      registry.release(id, channel);
+      opts.onDone?.();
+    }
+  });
+}
+function tweenVertexColors(animator, opts) {
+  validateLengths(opts.from, opts.to);
+  const interp = resolveInterpolator(opts);
+  return tweenColors(animator, opts, opts.ms, opts.easing, (t) => interp(opts.from, opts.to, t));
+}
+function springVertexColors(animator, opts) {
+  validateLengths(opts.from, opts.to);
+  const { id, channel } = opts;
+  const registry = animator.colorOverrides;
+  return animator.spring({
+    target: registry.target(id, channel, opts.from.length),
+    from: opts.from.slice(),
+    to: opts.to.slice(),
+    preset: opts.preset,
+    stiffness: opts.stiffness,
+    damping: opts.damping,
+    mass: opts.mass,
+    restThreshold: COLOR_REST,
+    cancelKey: cancelKeyFor(id, channel),
+    onDone: () => {
+      registry.release(id, channel);
+      opts.onDone?.();
+    }
+  });
+}
+function staggerVertexColors(animator, opts) {
+  validateLengths(opts.from, opts.to);
+  const interp = resolveInterpolator(opts);
+  const { from, to, anchorMs, perAnchorDelay } = opts;
+  const n = from.length / 4;
+  const easing = resolveEasing(opts.easing);
+  const originIndex = opts.origin === "last" ? n - 1 : typeof opts.origin === "number" ? Math.max(0, Math.min(n - 1, opts.origin)) : 0;
+  const maxDistance = Math.max(originIndex, n - 1 - originIndex);
+  const totalMs = maxDistance * perAnchorDelay + anchorMs;
+  const colorsAt = (elapsedMs) => {
+    const out = new Array(from.length);
+    for (let i = 0; i < n; i++) {
+      const distance = Math.abs(i - originIndex);
+      const startMs = distance * perAnchorDelay;
+      const localT = Math.max(0, Math.min(1, (elapsedMs - startMs) / anchorMs));
+      const eased = easing(localT);
+      const k = i * 4;
+      const fSlice = [from[k], from[k + 1], from[k + 2], from[k + 3]];
+      const tSlice = [to[k], to[k + 1], to[k + 2], to[k + 3]];
+      const blended = interp(fSlice, tSlice, eased);
+      out[k] = blended[0];
+      out[k + 1] = blended[1];
+      out[k + 2] = blended[2];
+      out[k + 3] = blended[3];
+    }
+    return out;
+  };
+  return tweenColors(animator, opts, totalMs, linear, (t) => colorsAt(t * totalMs));
+}
+function cycleVertexColors(animator, opts) {
+  const interp = resolveInterpolator(opts);
+  const { id, channel } = opts;
+  const direction = opts.direction ?? 1;
+  const easing = resolveEasing(opts.easing);
+  const override = (base, tMs) => {
+    const n = base.length / 4;
+    if (n === 0) return base.slice();
+    const raw = tMs / opts.msPerCycle * n * direction;
+    const cycles = raw / n;
+    const cycleFrac = cycles - Math.floor(cycles);
+    const easedFrac = easing(cycleFrac);
+    const easedRaw = (Math.floor(cycles) + easedFrac) * n;
+    const phase = (easedRaw % n + n) % n;
+    const phaseInt = Math.floor(phase);
+    const phaseFrac = phase - phaseInt;
+    const out = new Array(base.length);
+    for (let i = 0; i < n; i++) {
+      const aIdx = (i + phaseInt) % n * 4;
+      const bIdx = (i + phaseInt + 1) % n * 4;
+      const a = [base[aIdx], base[aIdx + 1], base[aIdx + 2], base[aIdx + 3]];
+      const b = [base[bIdx], base[bIdx + 1], base[bIdx + 2], base[bIdx + 3]];
+      const blended = interp(a, b, phaseFrac);
+      const k = i * 4;
+      out[k] = blended[0];
+      out[k + 1] = blended[1];
+      out[k + 2] = blended[2];
+      out[k + 3] = blended[3];
+    }
+    return out;
+  };
+  animator.colorOverrides.set(id, channel, override);
+  const releaseKeepAlive = animator.keepAlive();
+  return {
+    cancel() {
+      animator.colorOverrides.clear(id, channel);
+      releaseKeepAlive();
+    }
+  };
+}
+function rainbowVertexColors(n, opts = {}) {
+  const saturation = opts.saturation ?? 0.8;
+  const lightness = opts.lightness ?? 0.6;
+  const alpha = opts.alpha ?? 1;
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const h = i * 360 / Math.max(1, n);
+    const [r, g, b] = hslToSrgb(h, saturation, lightness);
+    out.push(r, g, b, alpha);
+  }
+  return out;
+}
+function solidVertexColors(n, r, g, b, a = 1) {
+  const out = [];
+  for (let i = 0; i < n; i++) out.push(r, g, b, a);
+  return out;
+}
+var defined = (o) => {
+  for (const k in o) if (o[k] === void 0) delete o[k];
+  return o;
+};
+function bindTrack(track, binder) {
+  if (track.kind === "timeline") {
+    return defined({ kind: "timeline", label: track.label, at: track.at, timeline: bindTimeline(track.timeline, binder) });
+  }
+  if (track.kind === "event") {
+    return defined({
+      kind: "event",
+      label: track.label,
+      events: track.events.map((e) => {
+        const does = binder.event?.(e.name, e.data);
+        if (!does) throw new Error(`bindClip: the binder has no event named "${e.name}".`);
+        return defined({ t: e.t, name: e.name, data: e.data, fire: does.fire, book: does.book });
+      })
+    });
+  }
+  const target = track.target === void 0 ? void 0 : binder.target?.(track.target);
+  if (track.target !== void 0 && !target) throw new Error(`bindClip: the binder has no target named "${track.target}".`);
+  const interpolate = track.interpolate === void 0 ? void 0 : binder.interpolate?.[track.interpolate];
+  if (track.interpolate !== void 0 && !interpolate) {
+    throw new Error(`bindClip: the binder has no interpolation named "${track.interpolate}".`);
+  }
+  return defined({
+    kind: "sampled",
+    label: track.label,
+    keys: track.keys.map((k) => ({ ...k, value: reviveTypedArrays(k.value) })),
+    target,
+    targetName: track.target,
+    interpolate,
+    interpolateName: track.interpolate,
+    ...bindWeight(track, binder),
+    axes: bindAxes(track, target)
+  });
+}
+function bindWeight(track, binder) {
+  const { weight } = track;
+  if (typeof weight !== "string") return { weight };
+  const read = binder.weight?.(weight);
+  if (!read) throw new Error(`bindClip: the binder has no weight named "${weight}".`);
+  return { weight: read, weightName: weight };
+}
+function bindAxes(track, target) {
+  const { axes } = track;
+  if (!axes) return void 0;
+  const where = `bindClip: track "${track.label ?? ""}"`;
+  if (!target) throw new Error(`${where} names axes and no target.`);
+  axisIndexes(target.axes, axes, `${where} on the target "${track.target}"`);
+  return [...axes];
+}
+function bindTimeline(timeline, binder) {
+  return defined({ tracks: timeline.tracks.map((t) => bindTrack(t, binder)), duration: timeline.duration });
+}
+function bindClip(clip, binder) {
+  if (clip.version !== 1) throw new Error(`bindClip: this clip is version ${String(clip.version)}, and version 1 is the one understood.`);
+  return bindTimeline(clip, binder);
+}
+var EASING_NAMES = new Map(
+  Object.keys(EASINGS).map((name) => [EASINGS[name], name])
+);
+function isClipValue(v) {
+  if (v === null || typeof v === "string" || typeof v === "boolean") return true;
+  if (typeof v === "number") return Number.isFinite(v);
+  if (Array.isArray(v)) return v.every(isClipValue);
+  if (typeof v !== "object" || Object.prototype.toString.call(v) !== "[object Object]") return false;
+  return Object.values(v).every((member) => member === void 0 || isClipValue(member));
+}
+function easingOf(spec, where) {
+  if (spec === void 0 || typeof spec === "string") return spec;
+  if (typeof spec !== "function") return { bezier: [...spec.bezier] };
+  const name = EASING_NAMES.get(spec);
+  if (!name) throw new Error(`toClip: ${where} eases a key by a function that is not a built-in; name it or use bezier points.`);
+  return name;
+}
+function sampledToClip(track, where) {
+  if (track.onTick) throw new Error(`toClip: ${where} has an onTick, which a clip cannot hold; move the value with a target.`);
+  if (track.target && track.targetName === void 0) throw new Error(`toClip: ${where} has a target and no targetName.`);
+  if (track.interpolator) throw new Error(`toClip: ${where} has an interpolator, which a clip cannot hold.`);
+  if (track.interpolate && track.interpolateName === void 0) throw new Error(`toClip: ${where} has an interpolate and no interpolateName.`);
+  if (typeof track.weight === "function" && track.weightName === void 0) {
+    throw new Error(`toClip: ${where} has a function for its weight and no weightName.`);
+  }
+  return defined({
+    kind: "sampled",
+    label: track.label,
+    target: track.targetName,
+    keys: track.keys.map((k) => {
+      const value = tagTypedArrays(k.value);
+      if (!isClipValue(value)) throw new Error(`toClip: ${where} holds a value JSON cannot round-trip, at t = ${k.t}.`);
+      return defined({ t: k.t, value, easing: easingOf(k.easing, where) });
+    }),
+    interpolate: track.interpolateName,
+    weight: typeof track.weight === "function" ? track.weightName : track.weight,
+    axes: track.axes && [...track.axes]
+  });
+}
+function trackToClip(track, index) {
+  const where = `track "${track.label ?? index}"`;
+  if (track.kind === "timeline") {
+    return defined({ kind: "timeline", label: track.label, at: track.at, timeline: timelineToClip(track.timeline) });
+  }
+  if (track.kind === "sampled") return sampledToClip(track, where);
+  return defined({
+    kind: "event",
+    label: track.label,
+    events: track.events.map((e) => {
+      if (e.name === void 0) throw new Error(`toClip: ${where} has an event with no name, at t = ${e.t}.`);
+      if (e.data !== void 0 && !isClipValue(e.data)) throw new Error(`toClip: ${where} carries data JSON cannot round-trip, at t = ${e.t}.`);
+      return defined({ t: e.t, name: e.name, data: e.data });
+    })
+  });
+}
+function timelineToClip(timeline) {
+  return defined({ tracks: timeline.tracks.map(trackToClip), duration: timeline.duration });
+}
+function toClip(timeline) {
+  return { version: 1, ...timelineToClip(timeline) };
+}
+
+// src/rig/mirrorPose.ts
+function mirrorPose(skeleton, pose) {
+  const out = {};
+  const binds = /* @__PURE__ */ new Map();
+  for (const joint of skeleton.joints) binds.set(joint.name, joint.bind);
+  const names = /* @__PURE__ */ new Set([...binds.keys(), ...Object.keys(pose)]);
+  for (const name of names) {
+    const bind = binds.get(name);
+    const d = pose[name];
+    out[name] = {
+      ...d,
+      x: -2 * (bind?.x ?? 0) - (d?.x ?? 0),
+      rotation: -2 * (bind?.rotation ?? 0) - (d?.rotation ?? 0)
+    };
+  }
+  return out;
+}
+function compose(bind, delta) {
+  if (!delta) return bind;
+  return {
+    x: bind.x + (delta.x ?? 0),
+    y: bind.y + (delta.y ?? 0),
+    rotation: bind.rotation + (delta.rotation ?? 0),
+    scaleX: bind.scaleX * (delta.scaleX ?? 1),
+    scaleY: bind.scaleY * (delta.scaleY ?? 1)
+  };
+}
+function toMat3(t) {
+  const c = Math.cos(t.rotation);
+  const s = Math.sin(t.rotation);
+  const m = new Float32Array(9);
+  m[0] = c * t.scaleX;
+  m[1] = s * t.scaleX;
+  m[2] = 0;
+  m[3] = -s * t.scaleY;
+  m[4] = c * t.scaleY;
+  m[5] = 0;
+  m[6] = t.x;
+  m[7] = t.y;
+  m[8] = 1;
+  return m;
+}
+function resolveSkeleton(skeleton, pose) {
+  const out = /* @__PURE__ */ new Map();
+  for (const joint of skeleton.joints) {
+    const local = toMat3(compose(joint.bind, pose[joint.name]));
+    if (joint.parent == null) {
+      out.set(joint.name, local);
+      continue;
+    }
+    const parent = out.get(joint.parent);
+    if (!parent) {
+      throw new Error(
+        `resolveSkeleton: joint "${joint.name}" names parent "${joint.parent}", which has not been resolved. Skeleton.joints must be in topological order.`
+      );
+    }
+    out.set(joint.name, mat3.multiply(parent, local));
+  }
+  return out;
+}
+
+// src/rig/types.ts
+var IDENTITY_JOINT = {
+  x: 0,
+  y: 0,
+  rotation: 0,
+  scaleX: 1,
+  scaleY: 1
+};
+
+// src/rig/skeletonAxes.ts
+var FIELDS = ["x", "y", "rotation", "scaleX", "scaleY"];
+var ROTATION = FIELDS.indexOf("rotation");
+function axisNames(skeleton) {
+  return skeleton.joints.flatMap((joint) => FIELDS.map((field) => `${joint.name}.${field}`));
+}
+function jointAxes(skeleton, joints) {
+  const names = axisNames(skeleton);
+  return axisIndexes({ count: names.length, names }, joints, "jointAxes: `joints`");
+}
+function skeletonAxes(skeleton) {
+  const names = skeleton.joints.map((j) => j.name);
+  const n = FIELDS.length;
+  return {
+    count: names.length * n,
+    angles: names.map((_, j) => j * n + ROTATION),
+    names: axisNames(skeleton),
+    to(pose) {
+      const out = new Array(names.length * n);
+      for (let j = 0; j < names.length; j++) {
+        const joint = pose[names[j]];
+        for (let f = 0; f < n; f++) out[j * n + f] = joint?.[FIELDS[f]] ?? IDENTITY_JOINT[FIELDS[f]];
+      }
+      return out;
+    },
+    add(pose, delta) {
+      const out = {};
+      for (let j = 0; j < names.length; j++) {
+        const joint = pose[names[j]];
+        const at = j * n;
+        out[names[j]] = {
+          x: (joint?.x ?? IDENTITY_JOINT.x) + delta[at],
+          y: (joint?.y ?? IDENTITY_JOINT.y) + delta[at + 1],
+          rotation: (joint?.rotation ?? IDENTITY_JOINT.rotation) + delta[at + 2],
+          scaleX: (joint?.scaleX ?? IDENTITY_JOINT.scaleX) + delta[at + 3],
+          scaleY: (joint?.scaleY ?? IDENTITY_JOINT.scaleY) + delta[at + 4]
+        };
+      }
+      return out;
+    },
+    write(pose, out, at) {
+      for (let j = 0; j < names.length; j++) {
+        const joint = pose[names[j]];
+        for (let f = 0; f < n; f++) out[at + j * n + f] = joint?.[FIELDS[f]] ?? IDENTITY_JOINT[FIELDS[f]];
+      }
+    },
+    from(axes) {
+      const pose = {};
+      for (let j = 0; j < names.length; j++) {
+        const at = j * n;
+        pose[names[j]] = { x: axes[at], y: axes[at + 1], rotation: axes[at + 2], scaleX: axes[at + 3], scaleY: axes[at + 4] };
+      }
+      return pose;
+    }
+  };
+}
+var TAU2 = Math.PI * 2;
+function wrap(a) {
+  return a - TAU2 * Math.round(a / TAU2);
+}
+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;
+  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;
+function solveIk(skeleton, pose, options) {
+  const { tip, target, limits } = options;
+  const maxIterations = options.iterations ?? 32;
+  const tolerance = options.tolerance ?? 0.01;
+  const byName = /* @__PURE__ */ new Map();
+  for (const joint of skeleton.joints) byName.set(joint.name, joint);
+  const chain = options.joints.map((name, i) => {
+    const joint = byName.get(name);
+    if (!joint) throw new Error(`solveIk: the skeleton has no joint "${name}".`);
+    if (i > 0 && joint.parent !== options.joints[i - 1]) {
+      throw new Error(
+        `solveIk: chain joint "${name}" names parent "${joint.parent}", not "${options.joints[i - 1]}". Each chain joint must be the parent of the next.`
+      );
+    }
+    return joint;
+  });
+  const n = chain.length;
+  if (n === 0) return { pose: { ...pose }, distance: Infinity, reached: false, iterations: 0 };
+  const rootParent = chain[0].parent;
+  const base = rootParent == null ? mat3.identity() : resolveSkeleton(skeleton, pose).get(rootParent);
+  const rot = chain.map((joint) => clampAngle(wrap(pose[joint.name]?.rotation ?? 0), limits?.[joint.name]));
+  let worlds = [];
+  const resolve = () => {
+    worlds = [];
+    let parent = base;
+    for (let i = 0; i < n; i += 1) {
+      const joint = chain[i];
+      parent = mat3.multiply(parent, toMat3(compose(joint.bind, { ...pose[joint.name], rotation: rot[i] })));
+      worlds.push(parent);
+    }
+  };
+  const pivot = (i) => mat3.apply(worlds[i], 0, 0);
+  const tipWorld = () => mat3.apply(worlds[n - 1], tip.x, tip.y);
+  const next = (i) => i + 1 < n ? pivot(i + 1) : tipWorld();
+  const aim = (i, effector, goal) => {
+    const inv = mat3.invert(i === 0 ? base : worlds[i - 1]);
+    if (!inv) return false;
+    const [ox, oy] = mat3.apply(inv, ...pivot(i));
+    const [ex, ey] = mat3.apply(inv, ...effector);
+    const [gx, gy] = mat3.apply(inv, goal.x, goal.y);
+    if (Math.hypot(ex - ox, ey - oy) < 1e-9 || Math.hypot(gx - ox, gy - oy) < 1e-9) return false;
+    const want = wrap(rot[i] + Math.atan2(gy - oy, gx - ox) - Math.atan2(ey - oy, ex - ox));
+    rot[i] = clampAngle(want, limits?.[chain[i].name]);
+    resolve();
+    return Math.abs(wrap(rot[i] - want)) > 1e-9;
+  };
+  const distance = () => {
+    const [x, y] = tipWorld();
+    return Math.hypot(x - target.x, y - target.y);
+  };
+  const result = (iterations2) => {
+    const out = { ...pose };
+    chain.forEach((joint, i) => {
+      out[joint.name] = { ...pose[joint.name], rotation: rot[i] };
+    });
+    const d = distance();
+    return { pose: out, distance: d, reached: d <= tolerance, iterations: iterations2 };
+  };
+  resolve();
+  const [rx, ry] = pivot(0);
+  let reach = 0;
+  for (let i = 0; i < n; i += 1) {
+    const [ax, ay] = pivot(i);
+    const [bx, by] = next(i);
+    reach += Math.hypot(bx - ax, by - ay);
+  }
+  const toTarget = Math.hypot(target.x - rx, target.y - ry);
+  if (toTarget >= reach) {
+    for (let i = 0; i < n; i += 1) aim(i, next(i), target);
+    return result(0);
+  }
+  if (n === 2 && toTarget > 1e-9) {
+    const start = rot.slice();
+    const [mx, my] = pivot(1);
+    const [tx, ty] = tipWorld();
+    const a = Math.hypot(mx - rx, my - ry);
+    const b = Math.hypot(tx - mx, ty - my);
+    const dx = target.x - rx;
+    const dy = target.y - ry;
+    const bendSide = options.pole ? cross(dx, dy, options.pole.x - rx, options.pole.y - ry) : cross(dx, dy, mx - rx, my - ry);
+    const side = bendSide < 0 ? -1 : 1;
+    const inner = Math.acos(Math.max(-1, Math.min(1, (a * a + toTarget * toTarget - b * b) / (2 * a * toTarget))));
+    const heading = Math.atan2(dy, dx);
+    const bend = (s) => {
+      rot.splice(0, 2, ...start);
+      resolve();
+      const elbow = { x: rx + a * Math.cos(heading + s * inner), y: ry + a * Math.sin(heading + s * inner) };
+      const cut = aim(0, pivot(1), elbow);
+      return aim(1, tipWorld(), target) || cut;
+    };
+    if (!bend(side) || !bend(-side)) {
+      if (distance() <= tolerance) return result(0);
+    } else {
+      bend(side);
+    }
+  }
+  let iterations = 0;
+  while (iterations < maxIterations && distance() > tolerance) {
+    for (let i = n - 1; i >= 0; i -= 1) aim(i, tipWorld(), target);
+    iterations += 1;
+  }
+  return result(iterations);
+}
+function motionsFromRest(skeleton, world) {
+  const rest = resolveSkeleton(skeleton, {});
+  const out = /* @__PURE__ */ new Map();
+  for (const [name, r] of rest) {
+    const inverse = mat3.invert(r);
+    if (!inverse) throw new Error(`motionsFromRest: joint "${name}" is singular at the bind pose.`);
+    const w = world.get(name);
+    if (w) out.set(name, mat3.multiply(w, inverse));
+  }
+  return out;
+}
+var RECT_COMMANDS = new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]);
+function skinnable(path) {
+  if (path.kind === "polygon") return path;
+  const { x, y, width, height } = path;
+  return {
+    kind: "polygon",
+    commands: RECT_COMMANDS,
+    coords: new Float32Array([x, y, x + width, y, x + width, y + height, x, y + height]),
+    fillRule: "nonzero"
+  };
+}
+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 total = new Float64Array(count);
+  for (const joint in skin) {
+    const m = motions.get(joint);
+    if (!m) throw new Error(`skinPath: the skin weighs joint "${joint}", which has no motion.`);
+    const weights = skin[joint];
+    const n = Math.min(count, weights.length);
+    for (let i = 0; i < n; i++) {
+      const w = weights[i];
+      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]);
+      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];
+  }
+  return { ...rest, coords };
+}
+function distanceToSegment(px, py, ax, ay, bx, by) {
+  const dx = bx - ax;
+  const dy = by - ay;
+  const len2 = dx * dx + dy * dy;
+  const t = len2 > 0 ? Math.min(1, Math.max(0, ((px - ax) * dx + (py - ay) * dy) / len2)) : 0;
+  return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));
+}
+function bonesOf(skeleton) {
+  const world = resolveSkeleton(skeleton, {});
+  const at = /* @__PURE__ */ new Map();
+  for (const [name, m] of world) at.set(name, mat3.apply(m, 0, 0));
+  const bones = /* @__PURE__ */ new Map();
+  for (const joint of skeleton.joints) {
+    if (joint.parent == null) continue;
+    let bone = bones.get(joint.parent);
+    if (!bone) {
+      bone = { joint: joint.parent, segments: [] };
+      bones.set(joint.parent, bone);
+    }
+    bone.segments.push(...at.get(joint.parent), ...at.get(joint.name));
+  }
+  for (const joint of skeleton.joints) {
+    if (joint.parent != null || bones.has(joint.name)) continue;
+    const [x, y] = at.get(joint.name);
+    bones.set(joint.name, { joint: joint.name, segments: [x, y, x, y] });
+  }
+  return skeleton.joints.flatMap((joint) => bones.get(joint.name) ?? []);
+}
+function autoSkin(path, skeleton, options = {}) {
+  const power = options.power ?? 4;
+  const max = Math.max(1, options.max ?? 2);
+  const bones = bonesOf(skeleton);
+  const coords = skinnable(path).coords;
+  const count = coords.length >> 1;
+  const out = /* @__PURE__ */ new Map();
+  const distance = new Float64Array(bones.length);
+  const order = bones.map((_, b) => b);
+  for (let i = 0; i < count; i++) {
+    const px = coords[2 * i];
+    const py = coords[2 * i + 1];
+    for (let b = 0; b < bones.length; b++) {
+      const s = bones[b].segments;
+      let d = Infinity;
+      for (let k = 0; k < s.length; k += 4) d = Math.min(d, distanceToSegment(px, py, s[k], s[k + 1], s[k + 2], s[k + 3]));
+      distance[b] = d;
+    }
+    order.sort((a, b) => distance[a] - distance[b] || a - b);
+    const kept = order.slice(0, max);
+    const nearest = distance[kept[0]];
+    let total = 0;
+    const raw = kept.map((b) => {
+      const w = nearest === 0 ? distance[b] === 0 ? 1 : 0 : (nearest / distance[b]) ** power;
+      total += w;
+      return w;
+    });
+    kept.forEach((b, k) => {
+      if (raw[k] === 0) return;
+      let weights = out.get(bones[b].joint);
+      if (!weights) {
+        weights = new Array(count).fill(0);
+        out.set(bones[b].joint, weights);
+      }
+      weights[i] = raw[k] / total;
+    });
+  }
+  return Object.fromEntries(out);
+}
+function jointPositions(skeleton) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [name, m] of resolveSkeleton(skeleton, {})) {
+    const [x, y] = mat3.apply(m, 0, 0);
+    out.set(name, { x, y });
+  }
+  return out;
+}
+function jointAt(skeleton, x, y, reach) {
+  let best = null;
+  let bestD = reach;
+  for (const [name, p] of jointPositions(skeleton)) {
+    const d = Math.hypot(p.x - x, p.y - y);
+    if (d <= bestD) {
+      best = name;
+      bestD = d;
+    }
+  }
+  return best;
+}
+function inParent(skeleton, parent, x, y) {
+  if (parent == null) return [x, y];
+  const world = resolveSkeleton(skeleton, {}).get(parent);
+  if (!world) throw new Error(`The skeleton has no joint "${parent}".`);
+  const inverse = mat3.invert(world);
+  if (!inverse) throw new Error(`Joint "${parent}" is singular at the bind pose.`);
+  return mat3.apply(inverse, x, y);
+}
+function moveJoint(skeleton, name, x, y) {
+  const joint = skeleton.joints.find((j) => j.name === name);
+  if (!joint) throw new Error(`moveJoint: the skeleton has no joint "${name}".`);
+  const [lx, ly] = inParent(skeleton, joint.parent, x, y);
+  return {
+    joints: skeleton.joints.map((j) => j === joint ? { ...j, bind: { ...j.bind, x: lx, y: ly } } : j)
+  };
+}
+function addJoint(skeleton, parent, x, y, name) {
+  const taken = new Set(skeleton.joints.map((j) => j.name));
+  let picked = name;
+  if (picked === void 0) {
+    picked = "joint";
+    for (let n = 2; taken.has(picked); n++) picked = `joint${n}`;
+  } else if (taken.has(picked)) {
+    throw new Error(`addJoint: the skeleton already has a joint "${picked}".`);
+  }
+  const [lx, ly] = inParent(skeleton, parent, x, y);
+  const joint = { name: picked, parent, bind: { ...IDENTITY_JOINT, x: lx, y: ly } };
+  return { skeleton: { joints: [...skeleton.joints, joint] }, name: picked };
+}
+function removeJoint(skeleton, name) {
+  const gone = /* @__PURE__ */ new Set([name]);
+  for (const j of skeleton.joints) if (j.parent != null && gone.has(j.parent)) gone.add(j.name);
+  const removed = skeleton.joints.filter((j) => gone.has(j.name)).map((j) => j.name);
+  return { skeleton: { joints: skeleton.joints.filter((j) => !gone.has(j.name)) }, removed };
+}
+function dropSkinJoints(skin, joints) {
+  if (!joints.some((j) => j in skin)) return skin;
+  const out = {};
+  for (const j in skin) if (!joints.includes(j)) out[j] = skin[j];
+  return out;
+}
+
+// src/rig/weightEdits.ts
+function setWeights(skin, count, joint, weights) {
+  const next = {};
+  for (const name in skin) next[name] = Array.from({ length: count }, (_, i) => skin[name][i] ?? 0);
+  const own = next[joint] ??= new Array(count).fill(0);
+  for (const [i, raw] of weights) {
+    if (i < 0 || i >= count) continue;
+    const w = Math.min(1, Math.max(0, raw));
+    let others = 0;
+    for (const name in next) if (name !== joint) others += next[name][i];
+    if (others > 0) {
+      for (const name in next) if (name !== joint) next[name][i] *= (1 - w) / others;
+      own[i] = w;
+    } else {
+      own[i] = w > 0 ? 1 : 0;
+    }
+  }
+  for (const name in next) if (!next[name].some((w) => w > 0)) delete next[name];
+  return next;
+}
+function brushWeights(coords, x, y, radius, current, mode) {
+  const out = /* @__PURE__ */ new Map();
+  for (let i = 0; 2 * i + 1 < coords.length; i++) {
+    const d = Math.hypot(coords[2 * i] - x, coords[2 * i + 1] - y);
+    if (d >= radius) continue;
+    const had = current?.[i] ?? 0;
+    const want = mode === "add" ? Math.max(had, 1 - d / radius) : Math.min(had, d / radius);
+    if (want !== had) out.set(i, want);
+  }
+  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 };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map