@weasel-js/animator 1.10.0 → 1.11.0

package/dist/react.js

@@ -0,0 +1,2111 @@
+import { ColorOverrideRegistry, createTargetBook, createTimeline, rowTableOf, stateOf, axesFor, takeUp, travel, shareBehind, goBehind, times, runsOn, seat, bumpOn, plus, axesOf, norm, absorb, minus, axisIndexes, comeOut, commitOffset, bump, isTarget, createHoldStore, committedInto, setBeside, shortWay } from './chunk-H7WENFPC.js';
+import { useRef, useCallback, useMemo, useInsertionEffect, useEffect } from 'react';
+import { useLatest, useVisibleRaf, isDev } from '@weasel-js/react';
+import { createEmitter } from '@weasel-js/registry';
+import { resolveEasing, easeOut, SPRING_PRESETS } from '@weasel-js/geom';
+import { patch, tween, glide, spring, mix, kit, vec, sum } from '@msb235/blits';
+
+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 canceled = false;
+  let current = null;
+  const supervisor = createSupervisor({ kind: "loop", cancelKey: opts.cancelKey, label: opts.label });
+  supervisor.setOnCancel(() => {
+    canceled = 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 fromEnd = supervisor.atEnd && max < Infinity;
+  let pass = fromEnd ? max : -1;
+  let first = true;
+  const next = () => {
+    if (canceled) return;
+    const back = first ? fromEnd : supervisor.rate() < 0;
+    first = false;
+    const i = back ? pass - 1 : pass + 1;
+    if (i < 0 || i >= max) {
+      current = null;
+      canceled = true;
+      supervisor.finish();
+      opts.onDone?.();
+      return;
+    }
+    pass = i;
+    current = supervisor.starting(back, () => 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;
+  canceled = false;
+  paused_ = false;
+  timeScale_ = 1;
+  children = [];
+  pending = [];
+  outstanding;
+  /** Children started and not yet done. */
+  running = 0;
+  finished = false;
+  /** Invoked when the supervisor is canceled externally (animator.cancel /
+   *  cancelKey) OR via this composite's own `cancel`. */
+  handleSupervisorCancel() {
+    if (this.canceled) return;
+    this.canceled = true;
+    this.pending = [];
+    const kids = this.children.slice();
+    this.children = [];
+    for (const c of kids) c.cancel();
+  }
+  noteChildDone() {
+    if (this.canceled || this.finished) return;
+    this.outstanding -= 1;
+    this.running -= 1;
+    if (this.outstanding <= 0) this.finish();
+    else this.rewound();
+  }
+  finish() {
+    this.finished = true;
+    this.children = [];
+    this.pending = [];
+    this.supervisor.finish();
+  }
+  /** Played backward, it ends once every item running has run back to its start: the items
+   *  still waiting are not reached going that way. */
+  rewound() {
+    if (this.running <= 0 && this.supervisor.rate() < 0) this.finish();
+  }
+  addChild(h) {
+    if (this.canceled) {
+      h.cancel();
+      return;
+    }
+    this.running += 1;
+    this.children.push(h);
+    if (this.paused_) h.pause();
+    if (this.timeScale_ !== 1) h.setTimeScale(this.timeScale_);
+  }
+  schedule(delayMs, fire) {
+    if (this.canceled) return;
+    this.pending.push({ at: delayMs, fire });
+  }
+  fireDue(virtualNow) {
+    if (this.canceled || this.finished) return;
+    this.rewound();
+    if (this.finished || 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.canceled) 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;
+  }
+  supervisor.starting(false, () => 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();
+    const atEnd = host.atEnd();
+    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,
+      rate: () => host.rateOf(id),
+      atEnd,
+      starting: host.starting,
+      setOnCancel: (cb) => {
+        onCancelCb = cb;
+      },
+      setOnRate: (cb) => {
+        onRateCb = cb;
+      },
+      setOnFrame: (cb) => {
+        onFrameCb = cb;
+      },
+      finish: () => host.finish(id),
+      cancelKey
+    };
+  };
+}
+
+// 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
+function holdsOf(s) {
+  if (s.holds) return s.holds;
+  if (s.row) return s.holds = { store: s.row.table.holds(), row: s.row.index };
+  const store = createHoldStore(s.axes.count, 1, (_, out, at) => committedInto(s, out, at), s.axes.angles);
+  return s.holds = { store, row: 0 };
+}
+function both(s, skip, committed) {
+  const { store, row } = s.holds;
+  const n = committed.length;
+  const all = { delta: new Array(n), total: new Array(n) };
+  const rest = { delta: new Array(n), total: new Array(n) };
+  store.fold(row, committed, 0, null, all.delta, all.total);
+  store.fold(row, committed, 0, skip, rest.delta, rest.total);
+  return { all, rest, own: store.valueOf(skip, row) };
+}
+function settle(s, f, covers, committed) {
+  const { all, rest, own } = f;
+  const angles = s.axes.angles ?? [];
+  return committed.map((c, a) => {
+    if (covers && !covers[a]) return 0;
+    if (rest.total[a] >= 1 - 1e-9) return angles.includes(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;
+    }
+    if (b.kept) b.move?.kept(b.kept);
+  }
+}
+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 enterHold(ctx, s, layer, sources) {
+  ctx.targets.attach(s);
+  s.held += 1;
+  const { store, row } = holdsOf(s);
+  const l = layer(store, row);
+  store.join(l, row, sources);
+  ctx.targets.holding(store, 1);
+  return { store, row, layer: l };
+}
+function leaveHold(ctx, s, layer, covers, commit) {
+  const { store, row } = s.holds;
+  if (commit && !s.discard) {
+    store.refold(row);
+    const committed = s.axes.to(s.get());
+    const f = both(s, layer, committed);
+    absorb(s, settle(s, f, covers, committed));
+    dim(s, f.all.total, f.rest.total);
+  }
+  store.part(layer, row);
+  ctx.targets.holding(store, -1);
+  s.held -= 1;
+  if (s.held === 0) {
+    s.holds = null;
+    const beside = s.beside;
+    if (beside) {
+      setBeside(s, null);
+      absorb(s, beside);
+    }
+  }
+  ctx.targets.detach(s);
+}
+function openHold(ctx, o) {
+  const s = o.target;
+  const ax = s.axes;
+  const state = s;
+  axesFor(ax, o.value(), "value");
+  let gone = false;
+  const covers = coverOf(o.axes, ax);
+  const { layer } = enterHold(ctx, state, (store, row) => store.free(row), {
+    value: ax.write ? (out, at) => ax.write(o.value(), out, at) : (out, at) => out.set(ax.to(o.value()), at),
+    weight: o.weight,
+    covers,
+    fixed: o.fixed === true
+  });
+  ctx.touch(state, true);
+  return {
+    touch: () => {
+      if (!gone) ctx.touch(state);
+    },
+    leave(commit) {
+      if (gone) return;
+      gone = true;
+      leaveHold(ctx, state, layer, covers, commit);
+      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/holdRows.ts
+function startHoldRows(ctx, o) {
+  const { table } = o;
+  const rows = rowTableOf(table);
+  const n = table.axes;
+  const store = rows.holds();
+  const id = ctx.nextId();
+  const seed = {
+    id,
+    kind: "hold",
+    cancelKey: o.cancelKey,
+    label: o.label,
+    keepExisting: o.interrupt === false,
+    idle: true,
+    due: Infinity
+  };
+  if (o.cancelKey != null && o.interrupt !== false) ctx.interrupt(o.cancelKey, seed);
+  let layer;
+  const held = /* @__PURE__ */ new Map();
+  const weight = o.weight ?? 1;
+  let covers = null;
+  const letGo = (row, commit) => {
+    const h = held.get(row);
+    if (!h) return;
+    held.delete(row);
+    h.s.parts.delete(h.part);
+    leaveHold(ctx, h.s, layer, covers, commit);
+    rows.mark(row);
+  };
+  for (const row of o.rows ? Array.from(o.rows) : rows.rows()) {
+    if (held.has(row)) continue;
+    const s = stateOf(table.target(row));
+    covers ??= coverOf(o.axes, s.axes);
+    enterHold(ctx, s, (st) => layer ??= st.layer(), { covers, fixed: true });
+    layer.values.set(table.committed.subarray(row * n, (row + 1) * n), row * n);
+    layer.weights[row] = weight;
+    const part = () => letGo(row, true);
+    s.parts.add(part);
+    held.set(row, { s, part });
+  }
+  layer ??= store.layer();
+  const touch = () => {
+    for (const row of held.keys()) store.refold(row);
+    rows.refill();
+    ctx.wake();
+  };
+  const leave = (commit) => {
+    for (const row of [...held.keys()]) letGo(row, commit);
+    store.drop(layer);
+    rows.refill();
+    ctx.wake();
+  };
+  touch();
+  seed.onCancel = () => leave(true);
+  seed.tick = () => {
+    if (!ctx.tripwire()) return false;
+    leave(true);
+    return true;
+  };
+  const base = ctx.register(seed);
+  return {
+    ...base,
+    get values() {
+      return layer.values;
+    },
+    get weights() {
+      return layer.weights;
+    },
+    touch,
+    release(r) {
+      if (!ctx.has(id)) return;
+      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 end = () => {
+    codec.stop(id);
+    if (ctx.has(id)) {
+      ctx.reportEnd(id);
+      o.onDone?.();
+    }
+    return true;
+  };
+  const baseHandle = ctx.register({
+    id,
+    kind,
+    cancelKey: o.cancelKey,
+    label: o.label,
+    tick(nowMs, rate) {
+      if (ctx.tripwire()) {
+        codec.stop(id);
+        return true;
+      }
+      if (rate < 0 && (nowMs <= 0 || axes && codec.rewound(id))) {
+        o.onTick(axes ? axes.from(reader.motion().value) : o.from);
+        return end();
+      }
+      if (lastTime == null) {
+        lastTime = nowMs;
+        if (target == null && magnitude(velocity) < restThreshold) return end();
+        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.max(-0.064, 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) return false;
+      if (target != null) o.onTick(target);
+      return end();
+    }
+  });
+  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 zeros2 = () => 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: zeros2(), velocity: zeros2() };
+  const adjust = (v, delta, sign) => {
+    if (v === moving) bumpOn(s, o.behind, delta, sign);
+    else bump(s, delta, sign);
+  };
+  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);
+      adjust(v, minus(from, was), 1);
+      return;
+    }
+    v.id = first ? o.id : o.nextId();
+    first = false;
+    const on = v === moving ? runsOn(s, o.behind) : s;
+    seat(s, on, codec.spring({
+      id: v.id,
+      on,
+      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);
+    adjust(v, from, 1);
+  };
+  const drop = (v) => {
+    if (v.id < 0) return;
+    const own = codec.own(v.id);
+    if (own) adjust(v, 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, zeros2());
+    },
+    settleMove: () => drop(moving),
+    rest(from, velocity, coast) {
+      coasting = coast;
+      cue(resting, from, velocity, coast ? null : zeros2());
+    },
+    push(velocity) {
+      const v = minus(velocity, of(moving).velocity);
+      if (resting.id < 0) cue(resting, zeros2(), v, coasting ? null : zeros2());
+      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);
+    },
+    rewound: () => (moving.id >= 0 || resting.id >= 0) && [moving, resting].every((v) => v.id < 0 || codec.rewound(v.id)),
+    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 startVoices(ctx, s, o, move, start, velocity, coast) {
+  const behind = goBehind(s, () => voices.moved(), () => voices.moved(), new Array(move.length).fill(1));
+  const voices = createSpringVoices(ctx.codec, s, { ...o, behind });
+  if (any(move)) voices.move(move);
+  const top = minus(start, move);
+  if (!any(move) || any(top) || any(velocity)) voices.rest(top, velocity, coast);
+  return { voices, behind };
+}
+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 } = 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 zeros2 = () => 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) : zeros2();
+  ctx.targets.attach(s);
+  if (o.to != null) s.set(o.to);
+  ctx.seedClock();
+  const { voices, behind } = startVoices(
+    ctx,
+    s,
+    { id, nextId: ctx.nextId, ...constants },
+    move,
+    start,
+    velocity ?? zeros2(),
+    dest == null
+  );
+  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 = (commit = dest == null) => {
+    leave(commit);
+    ctx.reportEnd(id);
+    o.onDone?.();
+    return true;
+  };
+  const shows = (own) => ax.from(plus(dest ?? ax.to(s.get()), own));
+  let ticked = false;
+  seed.due = waits.first(start, velocity ?? zeros2(), dest == null);
+  seed.onCancel = () => leave(true);
+  seed.onRate = (_paused, _timeScale, rate) => voices.rate(rate);
+  seed.velocity = () => voices.own().velocity;
+  seed.tick = (nowMs, scale) => {
+    if (ctx.tripwire()) {
+      leave(true);
+      return true;
+    }
+    const own = voices.own();
+    if (scale < 0 && (nowMs <= 0 || voices.rewound())) {
+      o.onTick?.(shows(own.value));
+      return ctx.has(id) ? finish(true) : true;
+    }
+    if (!ticked && dest == null && norm(own.velocity) < restThreshold) return finish();
+    ticked = true;
+    o.onTick?.(shows(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));
+    return ctx.has(id) ? finish() : 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);
+  const atEnd = ctx.atEnd();
+  ctx.seedClock();
+  const offsetAt = (u) => minus(ax.to(path(easing(u))), to);
+  const first = path ? offsetAt(0) : travel(ax, given ?? base, to);
+  const share = shareBehind(ax, committed, to, travel(ax, given ?? base, to));
+  const own = () => codec.own(id).value;
+  const behind = goBehind(s, own, () => times(own(), share), share);
+  const on = runsOn(s, behind);
+  seat(s, on, path ? codec.path({ id, on, ms, axes: ax.count, at: offsetAt, atEnd }) : codec.tween({ id, on, ms, ease: easing, from: first, to: new Array(ax.count).fill(0), atEnd }));
+  bumpOn(s, behind, own(), 1);
+  let left = false;
+  const leave = (commit, at) => {
+    if (left) return;
+    left = true;
+    const own2 = codec.own(id);
+    const value = at ?? own2?.value;
+    const moved = value ? times(value, share) : [];
+    const shown = comeOut(s, behind, moved);
+    if (own2) {
+      if (commit) commitOffset(s, value, moved, shown);
+      if (!behind.move) bump(s, own2.value, -1);
+    }
+    codec.stop(id);
+    ctx.targets.detach(s);
+  };
+  const end = (atStart) => {
+    o.onTick?.(atStart ? from : o.to);
+    if (!ctx.has(id)) return true;
+    leave(atStart, atStart ? first : void 0);
+    ctx.reportEnd(id);
+    o.onDone?.();
+    return true;
+  };
+  if (atEnd) seed.startAt = Math.max(o.ms, 0);
+  seed.progress = (virtualNow) => o.ms <= 0 ? 1 : Math.min(1, Math.max(0, virtualNow / o.ms));
+  if (!o.onTick) seed.due = Math.max(o.ms, 0);
+  seed.onCancel = () => leave(true);
+  seed.tick = (nowMs, scale) => {
+    if (ctx.tripwire()) {
+      leave(true);
+      return true;
+    }
+    if (scale < 0 && (nowMs <= 0 || codec.rewound(id))) return end(true);
+    if (o.ms <= 0 || nowMs >= o.ms) return end(false);
+    o.onTick?.(ax.from(plus(to, codec.own(id).value)));
+    return false;
+  };
+  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, direction = () => 1) {
+  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 * direction();
+  const clockOf = (a) => a.base + (elapsed() - a.anchor) * rateOf(a);
+  const rebase = (a) => {
+    a.base = clockOf(a);
+    a.anchor = elapsed();
+  };
+  const wait = (a) => {
+    const rate = rateOf(a);
+    if (rate < 0 && a.due < Infinity) {
+      if (every.has(a)) return;
+      wakes.remove(a);
+      waiting -= 1;
+      every.add(a);
+      a.rewinding = true;
+      return;
+    }
+    if (a.rewinding) {
+      a.rewinding = false;
+      every.delete(a);
+      waiting += 1;
+    }
+    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 = a.startAt ?? 0;
+      a.anchor = elapsed();
+      a.seq = seq++;
+      a.heapAt = -1;
+      a.wakeAt = Infinity;
+      a.rewinding = false;
+      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) {
+      rebase(a);
+      a.paused = paused;
+      a.timeScale = timeScale;
+      if (!every.has(a) || a.rewinding) wait(a);
+    },
+    rateOf,
+    turn(all, flip) {
+      const each = [...all];
+      for (const a of each) rebase(a);
+      flip();
+      for (const a of each) if (!every.has(a) || a.rewinding) wait(a);
+    },
+    defer(a, ms) {
+      if (!a) return;
+      a.due = clockOf(a) + ms;
+      if (every.delete(a)) waiting += 1;
+      a.rewinding = false;
+      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, direction) {
+  const animations = /* @__PURE__ */ new Map();
+  const schedule = createSchedule(elapsed, direction);
+  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 (!Number.isFinite(scale)) throw new Error(`animator: a time scale is a finite number, and ${scale} was given`);
+  return scale;
+}
+function 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;
+}
+function createTable(host) {
+  const { codec, hub } = host;
+  const roster = createRoster(host.elapsed, host.direction);
+  const { animations, schedule, remove } = roster;
+  const { fire: fireCompletion, watch: watchCompletion } = createCompletions((id) => animations.has(id));
+  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 rerate = (a) => {
+    const rate = schedule.rateOf(a);
+    if (codec.has(a.id)) codec.rate(a.id, rate);
+    a.onRate?.(a.paused, a.timeScale, rate);
+  };
+  const pace = (a, paused, timeScale) => {
+    schedule.pace(a, paused, timeScale);
+    rerate(a);
+  };
+  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 (host.direction() < 0) rerate(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,
+    turn(flip) {
+      schedule.turn(animations.values(), flip);
+      for (const a of [...animations.values()]) if (animations.get(a.id) === a) rerate(a);
+    },
+    clockOf: schedule.clockOf,
+    rateOf: schedule.rateOf,
+    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;
+  const atEnd = ctx.atEnd();
+  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],
+    atEnd
+  });
+  return ctx.register({
+    id,
+    kind: "tween",
+    cancelKey: o.cancelKey,
+    label: o.label,
+    startAt: atEnd ? Math.max(o.ms, 0) : 0,
+    progress: (virtualNow) => o.ms <= 0 ? 1 : Math.min(1, Math.max(0, 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, scale) {
+      if (ctx.tripwire()) {
+        codec.stop(id);
+        return true;
+      }
+      const atStart = scale < 0 && (nowMs <= 0 || codec.rewound(id));
+      const t = atStart ? 0 : o.ms <= 0 ? 1 : Math.min(1, nowMs / o.ms);
+      const ends = atStart || t >= 1;
+      let value;
+      if (axes) {
+        value = ends ? atStart ? o.from : o.to : axes.from(reader.cols, reader.at);
+      } else {
+        const eased = ends ? easing(t) : reader.cols[reader.at];
+        value = factoryFn ? factoryFn(eased) : o.interpolate(o.from, o.to, eased);
+      }
+      o.onTick(value);
+      if (ends && !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, fixed) => openHold(ctx, { target: stateOf(target), value, weight, axes, fixed });
+  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,
+    atEnd: ctx.atEnd,
+    starting: ctx.starting,
+    register: table.register,
+    finish: table.finish,
+    afterTicks: host.afterTicks,
+    rateOf: (id) => {
+      const a = animations.get(id);
+      return a ? table.rateOf(a) : 0;
+    }
+  });
+  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),
+    holdRows: (o) => startHoldRows(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) => {
+      const scale = timeScaleOf(s);
+      if (scale < 0 === clock.timeScale < 0) clock.timeScale = scale;
+      else table.turn(() => {
+        clock.timeScale = scale;
+      });
+    },
+    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 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 gone = [];
+  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;
+      const n = s.lane.axes;
+      s.held.set(s.cols.subarray(s.at, s.at + n));
+      s.lane.mix.drop(s.key);
+      depart(s);
+      s.cols = s.held;
+      s.at = 0;
+      gone.push(s);
+      slots.delete(s.key);
+    },
+    frame(time) {
+      now = time;
+      for (const s of gone) s.held.fill(0);
+      gone.length = 0;
+      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);
+      }
+    },
+    columns(group) {
+      const l = lanes.get(group);
+      return l ? { cols: l.cols.v, tags: l.tags, count: l.keys.length } : null;
+    }
+  };
+}
+
+// src/engine/rewinds.ts
+var firstOf = (v) => v.spring?.from ?? v.from;
+function createRewinds() {
+  const backward = /* @__PURE__ */ new Set();
+  const back = /* @__PURE__ */ new Set();
+  return {
+    rate(v, rate) {
+      if (rate < 0) backward.add(v);
+      else backward.delete(v);
+    },
+    frame() {
+      for (const v of backward) if (v.handle?.state === "done") back.add(v);
+      for (const v of back) {
+        const { cols, at } = v.slot;
+        const first = firstOf(v);
+        for (let i = 0; i < first.length; i++) cols[at + i] = cols[at + i] + first[i];
+      }
+    },
+    has: (v) => back.has(v),
+    recued: (v) => {
+      back.delete(v);
+    },
+    remove(v) {
+      backward.delete(v);
+      back.delete(v);
+    }
+  };
+}
+
+// src/engine/codec.ts
+function 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 };
+}
+var zeros = (n) => new Array(n).fill(0);
+function createCodec(placeOf) {
+  const lanes = createLanes(placeOf);
+  const voices = /* @__PURE__ */ new Map();
+  const queue = [];
+  const rewinds = createRewinds();
+  let time = 0;
+  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;
+    rewinds.recued(v);
+  };
+  function stop(id) {
+    const v = voices.get(id);
+    if (!v) return;
+    if (v.queued) v.queued = void 0;
+    else v.handle.fade({ over: 0 });
+    rewinds.remove(v);
+    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], seek: q.atEnd ? q.ms : 0 });
+        v.patch = patch;
+        patch.to(key, q.to.slice(), 0);
+        if (v.queuedRate !== void 0) v.handle.rate = v.queuedRate;
+      }
+      queue.length = 0;
+      time += dtMs;
+      lanes.frame(time);
+      rewinds.frame();
+    },
+    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 ? zeros(s.from.length) : s.atEnd ? s.to : 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 last = s.atEnd ? s.at(1) : void 0;
+      const slot = lanes.join(s.axes, shared ? s.on : s.id, shared ? zeros(s.axes) : last ?? from);
+      const v = { kind: "path", slot, from, last };
+      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", seek: s.atEnd ? s.ms : 0 });
+      voices.set(s.id, v);
+      return slot;
+    },
+    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);
+      rewinds.rate(v, rate);
+      if (v.queued) v.queuedRate = rate;
+      else v.handle.rate = rate;
+    },
+    rewound: (id) => {
+      const v = voices.get(id);
+      return v !== void 0 && rewinds.has(v);
+    },
+    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") {
+        return { value: v.last ?? v.from, velocity: new Array(v.from.length).fill(0) };
+      }
+      return !v.queued && v.patch.read(v.slot.key) || { value: v.queued?.atEnd ? v.queued.to : v.from, velocity: zeros(v.from.length) };
+    },
+    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 : Math.abs(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.refold();
+      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) => {
+    if ("move" in on) return on.move?.place;
+    const { row } = on;
+    return row ? { group: row.table, tag: row.index } : void 0;
+  });
+  const afterTicks = [];
+  const subscribers = createEmitter();
+  let nextId = 1;
+  let atEnd = false;
+  const seedClock = () => {
+    if (clock.frameT == null) clock.frameT = host.now();
+  };
+  const touched = /* @__PURE__ */ new Set();
+  const refold = (s) => {
+    if (s.holds) s.holds.store.refold(s.holds.row);
+    if (s.row && !frame.framing()) s.row.table.mark(s.row.index);
+  };
+  const refoldTouched = () => {
+    for (const s of touched) refold(s);
+    touched.clear();
+  };
+  const table = createTable({
+    codec,
+    hub,
+    elapsed: () => clock.elapsed,
+    direction: () => clock.timeScale < 0 ? -1 : 1,
+    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);
+      for (const part of [...s.parts]) part();
+    },
+    columns: (table2) => codec.columns(table2)
+  });
+  const frame = createFrame({
+    clock,
+    table,
+    codec,
+    targets,
+    hub,
+    afterTicks,
+    subscribers,
+    refold: refoldTouched,
+    requestFrame: host.requestFrame,
+    tripwire: host.tripwire
+  });
+  const ctx = {
+    codec,
+    targets,
+    nextId: () => nextId++,
+    atEnd: () => atEnd,
+    starting: (end, start) => {
+      const was = atEnd;
+      atEnd = end;
+      try {
+        return start();
+      } finally {
+        atEnd = was;
+      }
+    },
+    seedClock,
+    register: table.register,
+    has: (id) => table.animations.has(id),
+    defer: table.defer,
+    reportEnd: table.reportEnd,
+    finish: table.finish,
+    touch: (target, at) => {
+      if (frame.framing() && !at) {
+        touched.add(target);
+        return;
+      }
+      touched.delete(target);
+      refold(target);
+      if (!frame.framing()) host.requestFrame();
+    },
+    wake: () => {
+      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;
+        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;
+}
+
+export { useAnimator };
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map