@weasel-js/animator 1.10.1 → 1.11.0

package/dist/chunk-H7WENFPC.js

@@ -0,0 +1,1625 @@
+import { isPlainObject, createEmitter } from '@weasel-js/registry';
+import { keys } from '@msb235/blits';
+import { resolveEasing } from '@weasel-js/geom';
+
+// src/engine/axes.ts
+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/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;
+}
+
+// src/target.ts
+var states = /* @__PURE__ */ new WeakMap();
+var scratch = new Float64Array(16);
+var showing = (share2, cover, kept) => 1 - share2 * (1 - (1 - cover) * kept);
+function addMoves(s, out, at, cover, base) {
+  const n = s.axes.count;
+  const { behind } = s;
+  for (let j = 0; j < behind.length; j++) {
+    const b = behind[j];
+    const { slot, adjust, kept, share: share2 } = b;
+    if (slot) {
+      for (let i = 0; i < n; i++) {
+        const m = slot.cols[slot.at + i] + (adjust ? adjust[i] : 0);
+        out[at + i] = out[at + i] + (cover || kept ? m * showing(share2[i], cover ? cover[base + i] : 0, kept ? kept[i] : 1) : m);
+      }
+    } else if (cover || kept) {
+      const own = b.own();
+      for (let i = 0; i < n; i++) {
+        out[at + i] = out[at + i] - own[i] * (1 - showing(share2[i], cover ? cover[base + i] : 0, kept ? kept[i] : 1));
+      }
+    }
+  }
+}
+function addMoving(s, out, at) {
+  const n = s.axes.count;
+  const { slot, adjust, beside } = s;
+  for (let i = 0; i < n; i++) {
+    out[at + i] = out[at + i] + (slot ? slot.cols[slot.at + i] : 0) + adjust[i] + (beside ? beside[i] : 0);
+  }
+  const h = s.holds;
+  if (s.behind.length > 0 && (s.row || h || s.dimmed)) addMoves(s, out, at, h ? h.store.cover : null, h ? h.row * n : 0);
+}
+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);
+  const h = s.holds;
+  if (!h) return a;
+  const at = h.row * a.length;
+  const { store } = h;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] === store.at[at + i]) continue;
+    store.refold(h.row);
+    break;
+  }
+  for (let i = 0; i < a.length; i++) a[i] = a[i] + store.delta[at + i];
+  return a;
+}
+function readTarget(s) {
+  const committed = s.get();
+  if (s.live === 0) return committed;
+  const { axes } = s;
+  if (!axes.add || s.holds || s.dimmed) {
+    const a = heldAxes(s, committed);
+    addMoving(s, a, 0);
+    return axes.from(a);
+  }
+  const n = axes.count;
+  if (scratch.length < n) scratch = new Float64Array(n);
+  const d = scratch;
+  d.fill(0, 0, n);
+  addMoving(s, d, 0);
+  return axes.add(committed, d);
+}
+function readTargetInto(s, out, at) {
+  const committed = s.get();
+  const { axes } = s;
+  const moving = s.live > 0;
+  if (axes.write && !(moving && s.holds)) 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) addMoving(s, out, at);
+}
+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,
+    held: 0,
+    holds: null,
+    behind: [],
+    dimmed: false,
+    beside: null,
+    parts: /* @__PURE__ */ new Set(),
+    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/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 bumpBehind(s, b, delta, sign) {
+  const adjust = b.adjust ??= new Array(delta.length).fill(0);
+  for (let i = 0; i < delta.length; i++) adjust[i] = adjust[i] + sign * delta[i];
+  stale(s);
+  s.row?.table.mark(s.row.index);
+}
+function seat(s, holder, slot) {
+  const was = holder.slot;
+  if (was && was !== slot && was.refs === 0) {
+    const n = s.axes.count;
+    const adjust = holder.adjust ??= new Array(n).fill(0);
+    for (let i = 0; i < n; i++) adjust[i] = adjust[i] + was.cols[was.at + i];
+    stale(s);
+  }
+  holder.slot = slot;
+}
+function setBeside(s, beside) {
+  s.beside = beside;
+  s.row?.table.beside(s.row.index, beside);
+}
+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, own, left, share2) {
+  const b = {
+    own,
+    left,
+    share: share2,
+    kept: null,
+    slot: null,
+    adjust: null,
+    move: s.row ? s.row.table.move(s.row.index, share2) : null
+  };
+  s.behind.push(b);
+  return b;
+}
+var runsOn = (s, b) => b.move ? b : s;
+function bumpOn(s, b, delta, sign) {
+  if (b.move) bumpBehind(s, b, delta, sign);
+  else bump(s, delta, sign);
+}
+function comeOut(s, b, left) {
+  const at = s.behind.indexOf(b);
+  if (at >= 0) s.behind.splice(at, 1);
+  b.move?.leave();
+  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 setBeside(s, 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;
+  if (beside) setBeside(s, null);
+  return beside ? plus(committed, beside) : committed;
+}
+function createTargetBook(owner) {
+  const adjusted = [];
+  const token = { ...owner, adjusted: (s) => {
+    adjusted.push(s);
+  } };
+  const showing2 = /* @__PURE__ */ new Set();
+  const rested = /* @__PURE__ */ new Set();
+  const publishes = /* @__PURE__ */ new Set();
+  const tables2 = /* @__PURE__ */ new Map();
+  const stores = /* @__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) showing2.add(s);
+      rested.delete(s);
+      if (s.row) {
+        tables2.set(s.row.table, (tables2.get(s.row.table) ?? 0) + 1);
+        s.row.table.mark(s.row.index);
+      }
+    },
+    detach(s) {
+      s.live -= 1;
+      if (s.row) {
+        tables2.set(s.row.table, tables2.get(s.row.table) - 1);
+        s.row.table.mark(s.row.index);
+      }
+      if (s.live > 0) return;
+      s.owner = null;
+      s.slot = null;
+      if (s.beside) setBeside(s, null);
+      for (const b of s.behind) b.move?.leave();
+      s.behind.length = 0;
+      s.dimmed = false;
+      s.adjust.fill(0);
+      s.stale = false;
+      if (s.show && showing2.delete(s)) rested.add(s);
+    },
+    settle() {
+      for (const s of adjusted) {
+        if (!s.stale || s.owner !== token) continue;
+        s.adjust.fill(0);
+        for (const b of s.behind) b.adjust = null;
+        s.stale = false;
+      }
+      adjusted.length = 0;
+      for (const store of stores.keys()) store.frame();
+      for (const t of tables2.keys()) t.settle();
+    },
+    holding(store, by) {
+      const count = (stores.get(store) ?? 0) + by;
+      if (count > 0) stores.set(store, count);
+      else stores.delete(store);
+    },
+    show() {
+      for (const s of showing2) shown(s, readTarget(s));
+      for (const s of rested) shown(s, s.get());
+      rested.clear();
+      for (const [t, moving] of tables2) {
+        t.fill(owner.columns);
+        if (moving === 0) tables2.delete(t);
+      }
+      publish();
+    },
+    showNow(s) {
+      if (!s.show) return;
+      shown(s, readTarget(s));
+      publish();
+    },
+    get resting() {
+      return rested.size > 0;
+    }
+  };
+}
+
+// src/engine/holdStore.ts
+var share = (w) => w > 0 ? Math.min(w, 1) : 0;
+function wider(a, length, fill = 0) {
+  const b = new a.constructor(length);
+  if (fill !== 0) b.fill(fill);
+  b.set(a);
+  return b;
+}
+function makeLayer(rows, n, pooled) {
+  return {
+    values: new Float64Array(rows * n),
+    weights: new Float64Array(rows),
+    has: new Uint8Array(rows),
+    covers: null,
+    sources: [],
+    pooled,
+    asked: /* @__PURE__ */ new Set()
+  };
+}
+function widenLayer(l, rows, n) {
+  l.values = wider(l.values, rows * n);
+  l.weights = wider(l.weights, rows);
+  l.has = wider(l.has, rows);
+  if (l.covers) l.covers = wider(l.covers, rows * n);
+}
+function ask(l, row, n) {
+  const src = l.sources[row];
+  if (!src) return;
+  if (src.weight) l.weights[row] = src.weight();
+  if (src.value && share(l.weights[row]) > 0) src.value(l.values, row * n);
+}
+function foldRow(layers, angle, n, row, committed, at, skip, delta, total) {
+  const base = row * n;
+  const holds = (l, a) => l === skip || !l.has[row] || l.covers && !l.covers[base + a] ? 0 : share(l.weights[row]);
+  for (let a = 0; a < n; a++) {
+    const c = committed[at + a];
+    let weight = 0;
+    let sum = 0;
+    let sin = 0;
+    let cos = 0;
+    for (let h = 0; h < layers.length; h++) {
+      const l = layers[h];
+      const w = holds(l, a);
+      if (!(w > 0)) continue;
+      const v = l.values[base + a];
+      weight += w;
+      if (!angle[a]) sum += w * (v - c);
+      else {
+        sin += w * Math.sin(v);
+        cos += w * Math.cos(v);
+      }
+    }
+    if (weight > 0 && angle[a]) {
+      const mean = Math.hypot(sin, cos) < 1e-9 ? null : Math.atan2(sin, cos);
+      for (let h = 0; h < layers.length; h++) {
+        const l = layers[h];
+        const w = holds(l, a);
+        if (!(w > 0)) continue;
+        const v = l.values[base + a];
+        sum += w * (mean === null ? shortWay(v - c) : shortWay(mean - c) + shortWay(v - mean));
+      }
+    }
+    total[a] = weight;
+    delta[a] = weight > 0 ? sum / Math.max(1, weight) : 0;
+  }
+}
+function createHoldStore(axes, rows, read, angles) {
+  const n = axes;
+  const angle = new Uint8Array(n);
+  for (const a of angles ?? []) angle[a] = 1;
+  let cap = Math.max(rows, 1);
+  const layers = [];
+  let size = 0;
+  const store = {
+    delta: new Float64Array(cap * n),
+    cover: new Float64Array(cap * n),
+    at: new Float64Array(cap * n),
+    count: new Int32Array(cap),
+    held: new Int32Array(cap),
+    /** Each row's place in `held`; -1 for one not held. */
+    place: new Int32Array(cap).fill(-1),
+    /** The frame each row was last folded on. */
+    folded: new Int32Array(cap)
+  };
+  let pass2 = 0;
+  const fold = (row, committed, at, skip, delta, total) => foldRow(layers, angle, n, row, committed, at, skip, delta, total);
+  const scratchDelta = new Array(n);
+  const scratchTotal = new Array(n);
+  const settle = (row) => {
+    const base = row * n;
+    read(row, store.at, base);
+    fold(row, store.at, base, null, scratchDelta, scratchTotal);
+    for (let a = 0; a < n; a++) {
+      store.delta[base + a] = scratchDelta[a];
+      store.cover[base + a] = Math.min(scratchTotal[a], 1);
+    }
+  };
+  const made = (pooled) => {
+    const l = makeLayer(cap, n, pooled);
+    layers.push(l);
+    return l;
+  };
+  return {
+    axes: n,
+    get delta() {
+      return store.delta;
+    },
+    get cover() {
+      return store.cover;
+    },
+    get at() {
+      return store.at;
+    },
+    get count() {
+      return store.count;
+    },
+    get held() {
+      return store.held;
+    },
+    get size() {
+      return size;
+    },
+    grow(want) {
+      if (want <= cap) return;
+      cap = Math.max(want, cap * 2);
+      for (const k of ["delta", "cover", "at"]) store[k] = wider(store[k], cap * n);
+      for (const k of ["count", "held", "folded"]) store[k] = wider(store[k], cap);
+      store.place = wider(store.place, cap, -1);
+      for (const l of layers) widenLayer(l, cap, n);
+    },
+    layer: () => made(false),
+    free(row) {
+      for (const l of layers) if (l.pooled && !l.has[row]) return l;
+      return made(true);
+    },
+    join(layer, row, sources) {
+      const l = layer;
+      if (l.has[row]) throw new Error(`holds: row ${row} is held by this layer already`);
+      l.has[row] = 1;
+      if (sources) {
+        l.sources[row] = sources;
+        if (!sources.fixed) l.asked.add(row);
+        if (sources.covers) (l.covers ??= new Uint8Array(cap * n).fill(1)).set(sources.covers, row * n);
+      }
+      if (store.count[row]++ > 0) return;
+      store.place[row] = size;
+      store.held[size++] = row;
+    },
+    part(layer, row) {
+      const l = layer;
+      if (!l.has[row]) return;
+      l.has[row] = 0;
+      l.sources[row] = void 0;
+      l.asked.delete(row);
+      l.covers?.fill(1, row * n, (row + 1) * n);
+      if (--store.count[row] > 0) return;
+      const at = store.place[row];
+      const last = store.held[--size];
+      store.held[at] = last;
+      store.place[last] = at;
+      store.place[row] = -1;
+      store.delta.fill(0, row * n, (row + 1) * n);
+      store.cover.fill(0, row * n, (row + 1) * n);
+    },
+    drop(layer) {
+      const i = layers.indexOf(layer);
+      if (i >= 0) layers.splice(i, 1);
+    },
+    frame() {
+      for (const l of layers) for (const row of l.asked) ask(l, row, n);
+      pass2 += 1;
+      for (const l of layers) {
+        for (const row of l.asked) {
+          if (store.folded[row] === pass2) continue;
+          store.folded[row] = pass2;
+          settle(row);
+        }
+      }
+    },
+    refold(row) {
+      for (const l of layers) if (l.has[row]) ask(l, row, n);
+      settle(row);
+    },
+    fold,
+    valueOf: (layer, row) => Array.from(layer.values.subarray(row * n, (row + 1) * n))
+  };
+}
+
+// src/tableMoves.ts
+function createTableMoves(n) {
+  const group = {};
+  let cap = 16;
+  let rowOf = new Int32Array(cap);
+  let share2 = new Float64Array(cap * n);
+  let kept = new Float64Array(cap * n);
+  const free = [];
+  let high = 0;
+  const besides = /* @__PURE__ */ new Map();
+  let dimmed = 0;
+  let dims = new Uint8Array(cap);
+  const grow = () => {
+    cap *= 2;
+    const r = new Int32Array(cap);
+    r.set(rowOf);
+    rowOf = r;
+    const s = new Float64Array(cap * n);
+    s.set(share2);
+    share2 = s;
+    const k = new Float64Array(cap * n);
+    k.set(kept);
+    kept = k;
+    const d = new Uint8Array(cap);
+    d.set(dims);
+    dims = d;
+  };
+  return {
+    group,
+    move(row, of) {
+      const id = free.pop() ?? high++;
+      if (id >= cap) grow();
+      rowOf[id] = row;
+      share2.set(of, id * n);
+      kept.fill(1, id * n, (id + 1) * n);
+      let gone = false;
+      return {
+        place: { group, tag: id },
+        kept: (k) => {
+          kept.set(k, id * n);
+          if (!dims[id]) {
+            dims[id] = 1;
+            dimmed += 1;
+          }
+        },
+        leave() {
+          if (gone) return;
+          gone = true;
+          if (dims[id]) {
+            dims[id] = 0;
+            dimmed -= 1;
+          }
+          free.push(id);
+        }
+      };
+    },
+    beside(row, value) {
+      if (value) besides.set(row, value);
+      else besides.delete(row);
+    },
+    add(shown, committed, delta, cover, columns, stamp, pass2) {
+      if (columns) {
+        const { cols, tags, count } = columns;
+        const whole = !cover && dimmed === 0;
+        for (let j = 0; j < count; j++) {
+          const id = tags[j];
+          const row = rowOf[id];
+          const at = row * n;
+          const fresh = stamp[row] !== pass2;
+          stamp[row] = pass2;
+          if (whole && fresh && !delta) {
+            for (let k = 0; k < n; k++) shown[at + k] = committed[at + k] + cols[j * n + k];
+            continue;
+          }
+          for (let k = 0; k < n; k++) {
+            const f = whole ? 1 : showing(share2[id * n + k], cover ? cover[at + k] : 0, kept[id * n + k]);
+            const from = fresh ? committed[at + k] + (delta ? delta[at + k] : 0) : shown[at + k];
+            shown[at + k] = from + cols[j * n + k] * f;
+          }
+        }
+      }
+      for (const [row, value] of besides) {
+        for (let k = 0; k < n; k++) shown[row * n + k] = shown[row * n + k] + value[k];
+      }
+    }
+  };
+}
+
+// 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 pass(shown, committed, n, holds, moves, columns, moved, stamp, at) {
+  const h = holds && holds.size > 0 ? holds : null;
+  const delta = h ? h.delta : null;
+  if (h) {
+    const { held, size } = h;
+    for (let j = 0; j < size; j++) {
+      const row = held[j];
+      stamp[row] = at;
+      for (let k = 0; k < n; k++) shown[row * n + k] = committed[row * n + k] + delta[row * n + k];
+    }
+  }
+  if (columns) {
+    const { cols, tags, count } = columns;
+    for (let j = 0; j < count; j++) {
+      const row = tags[j];
+      const base = row * n;
+      stamp[row] = at;
+      if (delta) for (let k = 0; k < n; k++) shown[base + k] = committed[base + k] + cols[j * n + k] + delta[base + k];
+      else for (let k = 0; k < n; k++) shown[base + k] = committed[base + k] + cols[j * n + k];
+    }
+  }
+  moves.add(shown, committed, delta, h ? h.cover : null, moved, stamp, at);
+}
+function inUse(high, free) {
+  const gone = new Set(free);
+  return Array.from({ length: high }, (_, r) => r).filter((r) => !gone.has(r));
+}
+var tables = /* @__PURE__ */ new WeakMap();
+function rowTableOf(table) {
+  const rows = tables.get(table);
+  if (!rows) throw new Error("animator: `table` was not made by createTargetTable");
+  return rows;
+}
+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();
+  let holds = null;
+  const moves = createTableMoves(n);
+  let stamp = new Int32Array(committed.length / n);
+  let passes = 0;
+  let last = () => null;
+  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();
+      marks.clear();
+    },
+    fill(columns) {
+      last = columns;
+      pass(shown, committed, n, holds, moves, columns(rows), columns(moves.group), stamp, ++passes);
+      flush();
+      opts.show?.();
+    },
+    move: moves.move,
+    beside: moves.beside,
+    refill() {
+      const { show } = opts;
+      opts.show = void 0;
+      try {
+        rows.fill(last);
+      } finally {
+        opts.show = show;
+      }
+    },
+    rows: () => inUse(high, free),
+    holds: () => holds ??= createHoldStore(n, committed.length / n, (row, out, at) => {
+      for (let k = 0; k < n; k++) out[at + k] = committed[row * n + k];
+    })
+  };
+  const table = {
+    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 wider2 = new Shown(grown.length);
+        wider2.set(shown);
+        shown = wider2;
+        holds?.grow(grown.length / n);
+        stamp = Int32Array.from({ length: grown.length / n }, (_, r) => stamp[r] ?? 0);
+      }
+      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;
+    }
+  };
+  tables.set(table, rows);
+  return table;
+}
+
+// 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;
+}
+
+// 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/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 createEventCursor(fire) {
+  let at = -Infinity;
+  let open = false;
+  return {
+    to(tracks, to) {
+      fire(tracks, at, to, open);
+      at = to;
+      open = false;
+    },
+    place(t, o) {
+      at = t;
+      open = o;
+    }
+  };
+}
+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/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 pass2 = 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 typeof w === "function" ? open(st.target, () => h.value, w, st.axes) : open(st.target, () => h.value, () => w, st.axes, true);
+  };
+  const place = (st, value, t) => {
+    let h = held.get(st);
+    if (!h) held.set(st, h = { hold: null, value, where: null, t, edit, pass: pass2 });
+    const moved = h.t !== t || h.edit !== edit;
+    h.value = value;
+    h.t = t;
+    h.edit = edit;
+    h.pass = pass2;
+    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) {
+      pass2 += 1;
+      visit(tracks, t);
+      for (const [st, h] of held) {
+        if (h.pass === pass2) 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, lap, take) {
+  if (duration <= 0) return;
+  const laps = playhead >= duration ? Math.min(Math.floor(playhead / duration), loopsLeft) : playhead < 0 ? -Math.min(Math.ceil(-playhead / duration), lap) : 0;
+  if (laps !== 0) take(laps);
+}
+function createTimeline(register, id, opts, report, hold) {
+  let duration = tracksEnd(opts.tracks, opts.duration);
+  let offset = 0;
+  let lastVirtual = 0;
+  let playhead = 0;
+  let held = false;
+  let done = false;
+  let live = true;
+  let canceled = 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 events = createEventCursor(createEventFirer(report, booker !== null));
+  const onWrap = (laps) => {
+    if (!held && laps > 0) events.to(opts.tracks, duration);
+    events.place(laps > 0 ? -Infinity : playhead, 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, lap, (laps) => {
+        loopsLeft -= laps;
+        offset -= laps * duration;
+        playhead -= laps * duration;
+        lap += laps;
+        onWrap(laps);
+      });
+    }
+    const finished = playhead >= duration && !parked;
+    const rewound = rate < 0 && playhead <= 0;
+    playhead = Math.min(Math.max(playhead, 0), duration);
+    sampler.apply(opts.tracks, playhead);
+    if (!held) events.to(opts.tracks, playhead);
+    booker?.tick(virtualNow, rate);
+    if ((finished || rewound) && !done) {
+      done = true;
+      opts.onDone?.();
+      playbackChanged();
+    }
+    if ((rewound ? playhead > 0 : playhead < duration) || parked) return false;
+    live = false;
+    sampler.release();
+    return true;
+  };
+  const onCancel = () => {
+    const first = !canceled;
+    canceled = 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 (canceled || 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;
+      events.place(t, 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
+  };
+}
+
+export { ColorOverrideRegistry, absorb, axesFor, axesOf, axisIndexes, bump, bumpOn, comeOut, commitOffset, committedInto, createHoldStore, createTarget, createTargetBook, createTargetTable, createTimeline, goBehind, isTarget, minus, norm, plus, rowTableOf, runsOn, sampleTrack, seat, setBeside, shareBehind, shortWay, stateOf, takeUp, times, travel };
+//# sourceMappingURL=chunk-H7WENFPC.js.map
+//# sourceMappingURL=chunk-H7WENFPC.js.map