@weasel-js/animator 1.9.4 → 1.10.1

package/dist/index.js

@@ -1,11 +1,36 @@
 import { useRef, useCallback, useMemo, useInsertionEffect, useEffect } from 'react';
 import { useLatest, useVisibleRaf } from '@weasel-js/react';
-import { isPlainObject } from '@weasel-js/registry';
+import { isPlainObject, createEmitter } from '@weasel-js/registry';
 import { keys, patch, tween, glide, spring, mix, kit, vec, sum } from '@msb235/blits';
-import { EASINGS, resolveEasing, mat3, PATH_M, PATH_L, PATH_Z, easeOut, SPRING_PRESETS, linear } from '@weasel-js/geom';
+import { EASINGS, resolveEasing, mat3, PATH_M, PATH_L, PATH_Z, reviveTypedArrays, tagTypedArrays, easeOut, SPRING_PRESETS, linear } from '@weasel-js/geom';
 import { hslToSrgb, lerpColorArray } from '@weasel-js/paint';
 
 // src/useAnimator.ts
+
+// src/axisNames.ts
+var LISTED = 8;
+function axisIndexes(axes, wanted, what = "animator: `axes`") {
+  const { count, names } = axes;
+  const out = [];
+  for (const w of wanted) {
+    if (typeof w === "number") {
+      if (!Number.isInteger(w) || w < 0 || w >= count) throw new Error(`${what} names axis ${w} of a target with ${count}`);
+      out.push(w);
+      continue;
+    }
+    if (!names) throw new Error(`${what} names "${w}" on a target whose axes have no names`);
+    const before = out.length;
+    const under = `${w}.`;
+    for (let i = 0; i < names.length; i++) {
+      if (names[i] === w || names[i].startsWith(under)) out.push(i);
+    }
+    if (out.length === before) {
+      const some = names.slice(0, LISTED).map((n) => `"${n}"`).join(", ");
+      throw new Error(`${what} names "${w}", and the target's axes are ${some}${names.length > LISTED ? ", \u2026" : ""}`);
+    }
+  }
+  return out;
+}
 function fieldByField(keys) {
   const [a, b, c, e] = keys;
   switch (keys.length) {
@@ -87,6 +112,7 @@ function axesOf(sample) {
   return {
     count: keys.length,
     shape: `object:${JSON.stringify(keys)}`,
+    names: keys,
     to: (v) => keys.map((k) => v[k]),
     from: (a, at = 0) => {
       const out = {};
@@ -170,6 +196,9 @@ function readTargetInto(s, out, at) {
     out[at + i] = out[at + i] + (slot ? slot.cols[slot.at + i] : 0) + adjust[i] + (beside ? beside[i] : 0) - (hid ? hid[i] : 0);
   }
 }
+function isTarget(x) {
+  return typeof x === "object" && x !== null && states.has(x);
+}
 function stateOf(target) {
   const s = states.get(target);
   if (!s) throw new Error("animator: `target` was not made by createTarget");
@@ -206,6 +235,7 @@ function createTarget(opts) {
     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() {
@@ -231,11 +261,33 @@ function put(into, n, row, value) {
   if (value.length !== n) throw new Error(`target table: a row is ${n} numbers, and this value is ${value.length}`);
   for (let k = 0; k < n; k++) into[row * n + k] = value[k];
 }
+function rowTarget(n, row, rows, committed, commit) {
+  const target = createTarget({
+    get: () => {
+      const from = committed();
+      const value = new Array(n);
+      for (let k = 0; k < n; k++) value[k] = from[row * n + k];
+      return value;
+    },
+    set: (value) => {
+      committed();
+      commit(row, value);
+    }
+  });
+  const state = stateOf(target);
+  state.row = { table: rows, index: row };
+  state.write = (out, at) => {
+    const from = committed();
+    for (let k = 0; k < n; k++) out[at + k] = from[row * n + k];
+  };
+  return target;
+}
 function createTargetTable(opts) {
   const n = opts.axes;
+  const Shown = opts.shown ?? Float64Array;
   if (!Number.isInteger(n) || n < 1) throw new Error("createTargetTable: `axes` is a whole number of at least 1");
   let committed = new Float64Array(Math.max(opts.capacity ?? 64, 1) * n);
-  let shown = new Float64Array(committed.length);
+  let shown = new Shown(committed.length);
   let high = 0;
   let size = 0;
   const free = [];
@@ -297,7 +349,7 @@ function createTargetTable(opts) {
         const grown = new Float64Array(Math.max(committed.length * 2, (row + 1) * n));
         grown.set(committed);
         committed = grown;
-        const wider = new Float64Array(grown.length);
+        const wider = new Shown(grown.length);
         wider.set(shown);
         shown = wider;
       }
@@ -323,26 +375,12 @@ function createTargetTable(opts) {
       const mine = () => {
         if (removals[row] !== made) throw new Error(`target table: row ${row} was removed, and this is its old target`);
       };
-      const target = createTarget({
-        get: () => {
-          mine();
-          const value = new Array(n);
-          for (let k = 0; k < n; k++) value[k] = committed[row * n + k];
-          return value;
-        },
-        set: (value) => {
-          mine();
-          commit(row, value);
-        }
-      });
-      const state = stateOf(target);
-      state.row = { table: rows, index: row };
-      state.write = (out, at) => {
+      const target = rowTarget(n, row, rows, () => {
         mine();
-        for (let k = 0; k < n; k++) out[at + k] = committed[row * n + k];
-      };
+        return committed;
+      }, commit);
       targets[row] = target;
-      states2[row] = state;
+      states2[row] = stateOf(target);
       return target;
     }
   };
@@ -495,27 +533,16 @@ function shownOf(slot) {
   for (let i = 0; i < out.length; i++) out[i] = shown[at + i];
   return out;
 }
-
-// src/observe.ts
 var AnimatorEventHub = class {
-  listeners = /* @__PURE__ */ new Set();
+  events = createEmitter();
   get watched() {
-    return this.listeners.size > 0;
+    return this.events.size > 0;
   }
   add(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
+    return this.events.subscribe(listener);
   }
   emit(event) {
-    for (const listener of this.listeners) {
-      try {
-        listener(event);
-      } catch (err) {
-        console.error("useAnimator: watch listener threw", err);
-      }
-    }
+    this.events.emit(event);
   }
 };
 
@@ -713,25 +740,49 @@ function runStagger(createSupervisor, watchCompletion, items, delay, factory, op
 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) => runStagger(
-      createSupervisor,
-      watchCompletion,
-      items,
-      delay,
-      (item, i) => animator.tween({
-        from: resolvePerItem(opts.from, item, i),
-        to: resolvePerItem(opts.to, item, i),
+    tween: ((opts) => run("tween", opts, ({ target, ...own }, item, i) => {
+      const shared = {
+        ...own,
         ms: resolvePerItem(opts.ms, item, i),
         easing: opts.easing,
         interpolate: opts.interpolate,
-        onTick: (v) => opts.onTick(v, item, i),
-        onDone: opts.onDone ? () => opts.onDone(item, i) : void 0
-      }),
-      opts
-    )
+        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 });
+    }))
   };
 }
 
@@ -1027,7 +1078,7 @@ function createTargetBook(owner) {
   const token = { ...owner, adjusted: (s) => {
     adjusted.push(s);
   } };
-  const live = /* @__PURE__ */ new Set();
+  const showing = /* @__PURE__ */ new Set();
   const rested = /* @__PURE__ */ new Set();
   const publishes = /* @__PURE__ */ new Set();
   const tables = /* @__PURE__ */ new Map();
@@ -1046,7 +1097,7 @@ function createTargetBook(owner) {
       }
       s.owner = token;
       s.live += 1;
-      live.add(s);
+      if (s.show) showing.add(s);
       rested.delete(s);
       if (s.row) {
         tables.set(s.row.table, (tables.get(s.row.table) ?? 0) + 1);
@@ -1067,8 +1118,7 @@ function createTargetBook(owner) {
       s.dimmed = false;
       s.adjust.fill(0);
       s.stale = false;
-      live.delete(s);
-      if (s.show) rested.add(s);
+      if (s.show && showing.delete(s)) rested.add(s);
     },
     settle() {
       for (const s of adjusted) {
@@ -1085,7 +1135,7 @@ function createTargetBook(owner) {
       s.row?.table.mark(s.row.index);
     },
     show() {
-      for (const s of live) if (s.show) shown(s, readTarget(s));
+      for (const s of showing) shown(s, readTarget(s));
       for (const s of rested) shown(s, s.get());
       rested.clear();
       for (const [t, moving] of tables) {
@@ -1317,14 +1367,10 @@ function tracksEnd(tracks, explicit) {
   for (const t of tracks) max = Math.max(max, trackEnd(t));
   return max;
 }
-function notify(set) {
-  for (const cb of set) {
-    try {
-      cb();
-    } catch (err) {
-      console.error("timeline: subscriber threw", err);
-    }
-  }
+function crossLaps(playhead, duration, loopsLeft, take) {
+  if (duration <= 0 || playhead < duration) return;
+  const laps = Math.min(Math.floor(playhead / duration), loopsLeft);
+  if (laps > 0) take(laps);
 }
 function createTimeline(register, id, opts, report, hold) {
   let duration = tracksEnd(opts.tracks, opts.duration);
@@ -1339,9 +1385,9 @@ function createTimeline(register, id, opts, report, hold) {
   let cancelled = false;
   let wantPaused = opts.autoplay === false;
   let wantScale = 1;
-  const subscribers = /* @__PURE__ */ new Set();
-  const playbackSubscribers = /* @__PURE__ */ new Set();
-  const playbackChanged = () => notify(playbackSubscribers);
+  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;
@@ -1362,27 +1408,20 @@ function createTimeline(register, id, opts, report, hold) {
   };
   const tick = (virtualNow, scale) => {
     lastVirtual = virtualNow;
-    playhead = virtualNow + offset;
     const rate = scale ?? (base.isPaused() ? 0 : base.timeScale());
     held = rate === 0;
-    if (duration > 0 && playhead >= duration) {
-      if (loopsLeft === Infinity) {
-        const laps = Math.floor(playhead / duration);
+    const parked = held && duration > 0 && playhead === duration && loopsLeft > 0;
+    if (!parked) {
+      playhead = virtualNow + offset;
+      crossLaps(playhead, duration, loopsLeft, (laps) => {
+        loopsLeft -= laps;
         offset -= laps * duration;
         playhead -= laps * duration;
         lap += laps;
         onWrap();
-      } else {
-        while (playhead >= duration && loopsLeft > 0) {
-          loopsLeft -= 1;
-          offset -= duration;
-          playhead -= duration;
-          lap += 1;
-          onWrap();
-        }
-      }
+      });
     }
-    const finished = playhead >= duration;
+    const finished = playhead >= duration && !parked;
     playhead = Math.min(playhead, duration);
     sampler.apply(opts.tracks, playhead);
     if (!held) {
@@ -1396,7 +1435,7 @@ function createTimeline(register, id, opts, report, hold) {
       opts.onDone?.();
       playbackChanged();
     }
-    if (playhead < duration) return false;
+    if (playhead < duration || parked) return false;
     live = false;
     sampler.release();
     return true;
@@ -1482,20 +1521,10 @@ function createTimeline(register, id, opts, report, hold) {
       booker?.retract();
       rearm();
       sampleNow();
-      notify(subscribers);
-    },
-    subscribe(cb) {
-      subscribers.add(cb);
-      return () => {
-        subscribers.delete(cb);
-      };
+      edited.emit();
     },
-    subscribePlayback(cb) {
-      playbackSubscribers.add(cb);
-      return () => {
-        playbackSubscribers.delete(cb);
-      };
-    }
+    subscribe: edited.subscribe,
+    subscribePlayback: playback.subscribe
   };
 }
 
@@ -1591,15 +1620,10 @@ function dim(s, before, after) {
     }
   }
 }
-function coverOf(axes, count) {
-  if (!axes) return null;
-  const covers = new Uint8Array(count);
-  for (const a of axes) {
-    if (!Number.isInteger(a) || a < 0 || a >= count) {
-      throw new Error(`animator: \`axes\` names axis ${a} of a target with ${count}`);
-    }
-    covers[a] = 1;
-  }
+function coverOf(wanted, axes) {
+  if (!wanted) return null;
+  const covers = new Uint8Array(axes.count);
+  for (const a of axisIndexes(axes, wanted)) covers[a] = 1;
   return covers;
 }
 function openHold(ctx, o) {
@@ -1615,7 +1639,8 @@ function openHold(ctx, o) {
       return buffer;
     } : () => ax.to(o.value()),
     weight: () => gone ? 0 : share(o.weight()),
-    covers: coverOf(o.axes, ax.count),
+    covers: coverOf(o.axes, ax),
+    fixed: o.fixed === true,
     w: 0,
     v: buffer
   };
@@ -1633,6 +1658,7 @@ function openHold(ctx, o) {
       id: made.voice,
       on: s,
       axes: ax.count,
+      still: member.fixed,
       at: () => {
         const committed = s.heldAt ??= new Array(ax.count).fill(0);
         committedInto(s, committed, 0);
@@ -1646,6 +1672,8 @@ function openHold(ctx, o) {
   }
   const { members, voice } = group;
   members.push(member);
+  const still = () => ctx.codec.still(voice, members.every((m) => m.fixed));
+  still();
   ctx.touch(state, true);
   return {
     touch: () => {
@@ -1670,7 +1698,7 @@ function openHold(ctx, o) {
         const beside = s.beside;
         s.beside = null;
         if (beside) absorb(s, beside);
-      }
+      } else still();
       ctx.targets.detach(state);
       ctx.touch(state, true);
     }
@@ -1683,6 +1711,7 @@ 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",
@@ -1690,15 +1719,17 @@ function startHold(ctx, o) {
     label: o.label,
     target,
     keepExisting: o.interrupt === false,
-    // A hold of plain values changes only when told to, so it asks for no frames of its own.
-    idle: !isFn(value) && !isFn(weight)
+    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
+    axes: o.axes,
+    fixed
   });
   seed.onCancel = () => held.leave(true);
   seed.tick = () => {
@@ -1840,6 +1871,15 @@ function startPhysics(ctx, o, kind) {
   };
 }
 
+// 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;
@@ -1914,19 +1954,37 @@ function createSpringVoices(codec, s, o) {
 
 // src/engine/offsetPhysics.ts
 var any = (a) => a.some((x) => x !== 0);
+function constantsFor(o, kind, toward) {
+  const c = resolveSpringConstants(o);
+  if (!(c.damping > 0) || !(c.mass > 0) || toward && !(c.stiffness > 0)) {
+    throw new Error(`${kind}: an animation on a target needs positive damping and mass, and stiffness to reach \`to\``);
+  }
+  return c;
+}
+function restWaits(ctx, id, quiet, c, threshold) {
+  const until = (value, velocity, coast) => earliestRest(value, velocity, coast ? 0 : c.stiffness, c.damping, c.mass, threshold);
+  return {
+    /** The `due` it registers with. */
+    first: (value, velocity, coast) => quiet ? until(value, velocity, coast) : void 0,
+    /** Leaves it unticked until then. Answers false, as the tick of one still moving does. */
+    again(value, velocity, coast) {
+      if (quiet) ctx.defer(id, until(value, velocity, coast));
+      return false;
+    }
+  };
+}
 function startOffsetPhysics(ctx, o, kind) {
   const s = stateOf(o.target);
   const ax = s.axes;
-  const { stiffness, damping, mass } = resolveSpringConstants(o);
   let dest = o.to == null ? null : axesFor(ax, o.to, "to");
-  if (!(damping > 0) || !(mass > 0) || dest && !(stiffness > 0)) {
-    throw new Error(`${kind}: an animation on a target needs positive damping and mass, and stiffness to reach \`to\``);
-  }
+  const constants = constantsFor(o, kind, dest != null);
+  const { stiffness, damping, mass } = constants;
   const given = o.from === void 0 ? null : axesFor(ax, o.from, "from");
   let velocity = o.velocity === void 0 ? null : axesFor(ax, o.velocity, "velocity");
   const restThreshold = o.restThreshold ?? 0.01;
   const zeros = () => new Array(ax.count).fill(0);
   const id = ctx.nextId();
+  const waits = restWaits(ctx, id, !o.onTick, constants, restThreshold);
   const interrupts = o.interrupt !== false;
   const seed = {
     id,
@@ -1968,6 +2026,7 @@ function startOffsetPhysics(ctx, o, kind) {
     o.onDone?.();
   };
   let ticked = false;
+  seed.due = waits.first(start, velocity ?? zeros(), dest == null);
   seed.onCancel = () => leave(true);
   seed.onRate = (paused, timeScale) => voices.rate(paused ? 0 : timeScale);
   seed.velocity = () => voices.own().velocity;
@@ -1984,7 +2043,9 @@ function startOffsetPhysics(ctx, o, kind) {
     ticked = true;
     o.onTick?.(ax.from(plus(dest ?? ax.to(s.get()), own.value)));
     if (!ctx.has(id)) return true;
-    if (norm(own.velocity) >= restThreshold || dest && norm(own.value) >= restThreshold) return false;
+    if (norm(own.velocity) >= restThreshold || dest && norm(own.value) >= restThreshold) {
+      return waits.again(own.value, own.velocity, dest == null);
+    }
     if (dest) o.onTick?.(ax.from(dest));
     if (!ctx.has(id)) return true;
     finish();
@@ -2003,6 +2064,7 @@ function startOffsetPhysics(ctx, o, kind) {
         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");
@@ -2012,11 +2074,14 @@ function startOffsetPhysics(ctx, o, kind) {
       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;
-      voices.push(axesFor(ax, v, "setVelocity"));
+      const pushed = axesFor(ax, v, "setVelocity");
+      waits.again(voices.own().value, pushed, dest == null);
+      voices.push(pushed);
     }
   };
 }
@@ -2072,6 +2137,7 @@ function startOffsetTween(ctx, o) {
     ctx.targets.detach(s);
   };
   seed.progress = (virtualNow) => o.ms <= 0 ? 1 : Math.min(1, virtualNow / o.ms);
+  if (!o.onTick) seed.due = Math.max(o.ms, 0);
   seed.onCancel = () => leave(true);
   seed.tick = (nowMs) => {
     if (ctx.tripwire()) {
@@ -2120,6 +2186,199 @@ function createCompletions(has) {
   };
 }
 
+// src/engine/wakes.ts
+function createWakes() {
+  const heap = [];
+  const place = (w, i) => {
+    heap[i] = w;
+    w.heapAt = i;
+  };
+  const up = (w, i) => {
+    while (i > 0) {
+      const parent = i - 1 >> 1;
+      const p = heap[parent];
+      if (p.wakeAt <= w.wakeAt) break;
+      place(p, i);
+      i = parent;
+    }
+    place(w, i);
+  };
+  const down = (w, i) => {
+    const n = heap.length;
+    for (; ; ) {
+      let child = 2 * i + 1;
+      if (child >= n) break;
+      if (child + 1 < n && heap[child + 1].wakeAt < heap[child].wakeAt) child += 1;
+      const c = heap[child];
+      if (c.wakeAt >= w.wakeAt) break;
+      place(c, i);
+      i = child;
+    }
+    place(w, i);
+  };
+  const remove = (w) => {
+    const i = w.heapAt;
+    if (i < 0) return;
+    w.heapAt = -1;
+    const last = heap.pop();
+    if (last === w) return;
+    if (i > 0 && last.wakeAt < heap[i - 1 >> 1].wakeAt) up(last, i);
+    else down(last, i);
+  };
+  return {
+    set(w, at) {
+      remove(w);
+      w.wakeAt = at;
+      heap.push(w);
+      up(w, heap.length - 1);
+    },
+    remove,
+    due(now) {
+      const out = [];
+      while (heap.length > 0 && heap[0].wakeAt <= now) {
+        const w = heap[0];
+        remove(w);
+        out.push(w);
+      }
+      if (out.length > 1) out.sort((a, b) => a.seq - b.seq);
+      return out;
+    },
+    clear() {
+      for (const w of heap) w.heapAt = -1;
+      heap.length = 0;
+    },
+    get size() {
+      return heap.length;
+    }
+  };
+}
+
+// src/engine/schedule.ts
+function createSchedule(elapsed) {
+  const every = /* @__PURE__ */ new Set();
+  const wakes = createWakes();
+  let seq = 0;
+  let awake = 0;
+  let waiting = 0;
+  const rateOf = (a) => a.paused ? 0 : a.timeScale;
+  const clockOf = (a) => a.base + (elapsed() - a.anchor) * rateOf(a);
+  const wait = (a) => {
+    const rate = rateOf(a);
+    if (rate > 0 && a.due < Infinity) wakes.set(a, a.anchor + (a.due - a.base) / rate);
+    else wakes.remove(a);
+  };
+  return {
+    clockOf,
+    add(a) {
+      a.base = 0;
+      a.anchor = elapsed();
+      a.seq = seq++;
+      a.heapAt = -1;
+      a.wakeAt = Infinity;
+      if (!a.idle) awake += 1;
+      if (a.due === void 0) {
+        every.add(a);
+        return;
+      }
+      waiting += 1;
+      wait(a);
+    },
+    remove(a) {
+      if (!a.idle) awake -= 1;
+      if (every.delete(a)) return;
+      waiting -= 1;
+      wakes.remove(a);
+    },
+    pace(a, paused, timeScale) {
+      a.base = clockOf(a);
+      a.anchor = elapsed();
+      a.paused = paused;
+      a.timeScale = timeScale;
+      if (!every.has(a)) wait(a);
+    },
+    defer(a, ms) {
+      if (!a) return;
+      a.due = clockOf(a) + ms;
+      if (every.delete(a)) waiting += 1;
+      wait(a);
+    },
+    ticks() {
+      const steady = [...every];
+      const woke = wakes.due(elapsed());
+      if (woke.length === 0) return steady;
+      waiting -= woke.length;
+      const out = [];
+      let i = 0;
+      for (const a of woke) {
+        a.base = Math.max(clockOf(a), a.due);
+        a.anchor = elapsed();
+        every.add(a);
+        while (i < steady.length && steady[i].seq < a.seq) out.push(steady[i++]);
+        out.push(a);
+      }
+      while (i < steady.length) out.push(steady[i++]);
+      return out;
+    },
+    get awake() {
+      return awake > 0;
+    },
+    get waiting() {
+      return waiting;
+    },
+    clear() {
+      every.clear();
+      wakes.clear();
+      awake = 0;
+      waiting = 0;
+    }
+  };
+}
+
+// src/engine/roster.ts
+var NONE = [];
+function file(index, key, a, on) {
+  let set = index.get(key);
+  if (on) {
+    if (!set) index.set(key, set = /* @__PURE__ */ new Set());
+    set.add(a);
+  } else if (set?.delete(a) && set.size === 0) index.delete(key);
+}
+function createRoster(elapsed) {
+  const animations = /* @__PURE__ */ new Map();
+  const schedule = createSchedule(elapsed);
+  const byKey = /* @__PURE__ */ new Map();
+  const byTarget = /* @__PURE__ */ new Map();
+  const index = (a, on) => {
+    if (a.cancelKey != null) file(byKey, a.cancelKey, a, on);
+    if (a.target) file(byTarget, a.target, a, on);
+  };
+  const remove = (a) => {
+    animations.delete(a.id);
+    schedule.remove(a);
+    index(a, false);
+  };
+  return {
+    animations,
+    schedule,
+    under: (key) => byKey.get(key) ?? NONE,
+    on: (target) => byTarget.get(target) ?? NONE,
+    add(a) {
+      const had = animations.get(a.id);
+      if (had) remove(had);
+      animations.set(a.id, a);
+      schedule.add(a);
+      index(a, true);
+    },
+    remove,
+    clear() {
+      animations.clear();
+      schedule.clear();
+      byKey.clear();
+      byTarget.clear();
+    }
+  };
+}
+
 // src/engine/table.ts
 function timeScaleOf(scale) {
   if (!(scale >= 0)) {
@@ -2129,7 +2388,8 @@ function timeScaleOf(scale) {
 }
 function createTable(host) {
   const { codec, hub } = host;
-  const animations = /* @__PURE__ */ new Map();
+  const roster = createRoster(host.elapsed);
+  const { animations, schedule, remove } = roster;
   const { fire: fireCompletion, watch: watchCompletion } = createCompletions((id) => animations.has(id));
   const infoOf = (a) => {
     if (!a.info) {
@@ -2151,31 +2411,27 @@ function createTable(host) {
     if (!a) return;
     a.onCancel?.();
     codec.stop(id);
-    animations.delete(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) => {
-    const ids = [];
-    for (const anim of animations.values()) {
-      if (anim.cancelKey === key) ids.push(anim.id);
-    }
-    for (const id of ids) retire(id, by);
+    for (const a of [...roster.under(key)]) retire(a.id, by);
   };
-  const rateOf = (a) => {
-    if (codec.has(a.id)) codec.rate(a.id, a.paused ? 0 : a.timeScale);
-    a.onRate?.(a.paused, a.timeScale);
+  const pace = (a, paused, timeScale) => {
+    schedule.pace(a, paused, timeScale);
+    if (codec.has(a.id)) codec.rate(a.id, paused ? 0 : timeScale);
+    a.onRate?.(paused, timeScale);
   };
   const register = (seed) => {
     const anim = seed;
     if (seed.cancelKey != null && !seed.keepExisting) cancelByKey(seed.cancelKey, anim);
     anim.paused = false;
     anim.timeScale = 1;
-    anim.virtualNow = 0;
-    anim.lastRealNow = host.startTime();
-    animations.set(anim.id, anim);
+    host.seedClock();
+    roster.add(anim);
     if (anim.target) host.showNow(anim.target);
     if (hub.watched) hub.emit({ type: "start", animation: infoOf(anim) });
     if (animations.size > 0 && !host.framing()) host.requestFrame();
@@ -2185,24 +2441,15 @@ function createTable(host) {
       cancel: () => retire(anim.id),
       pause: () => {
         const a = live();
-        if (a) {
-          a.paused = true;
-          rateOf(a);
-        }
+        if (a) pace(a, true, a.timeScale);
       },
       resume: () => {
         const a = live();
-        if (a) {
-          a.paused = false;
-          rateOf(a);
-        }
+        if (a) pace(a, false, a.timeScale);
       },
       setTimeScale: (s) => {
         const a = live();
-        if (a) {
-          a.timeScale = timeScaleOf(s);
-          rateOf(a);
-        }
+        if (a) pace(a, a.paused, timeScaleOf(s));
       },
       timeScale: () => live()?.timeScale ?? 1,
       isPaused: () => live()?.paused ?? false
@@ -2214,16 +2461,28 @@ function createTable(host) {
     reportEnd,
     retire,
     cancelByKey,
-    rateOf,
+    under: roster.under,
+    on: roster.on,
+    pace,
+    clockOf: schedule.clockOf,
+    defer: (id, ms) => schedule.defer(animations.get(id), ms),
+    ticks: schedule.ticks,
+    get awake() {
+      return schedule.awake;
+    },
+    get waiting() {
+      return schedule.waiting;
+    },
     register,
     finish(id) {
-      if (!animations.has(id)) return;
+      const a = animations.get(id);
+      if (!a) return;
       reportEnd(id);
-      animations.delete(id);
+      remove(a);
       fireCompletion(id);
     },
     drop(a) {
-      animations.delete(a.id);
+      remove(a);
       fireCompletion(a.id);
     },
     cancelAll(cleared) {
@@ -2233,7 +2492,7 @@ function createTable(host) {
         codec.stop(a.id);
         retired.push(a);
       }
-      animations.clear();
+      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) });
@@ -2298,12 +2557,8 @@ function startTween(ctx, o) {
 }
 
 // src/engine/animatorApi.ts
-function eachUnder(table, key, set) {
-  for (const a of table.animations.values()) {
-    if (a.cancelKey !== key) continue;
-    set(a);
-    table.rateOf(a);
-  }
+function eachUnder(table, key, pace) {
+  for (const a of table.under(key)) table.pace(a, ...pace(a));
 }
 function liveRows(table) {
   const rows = [];
@@ -2312,8 +2567,8 @@ function liveRows(table) {
       ...table.infoOf(a),
       paused: a.paused,
       timeScale: a.timeScale,
-      elapsed: a.virtualNow,
-      ...a.progress ? { progress: a.progress(a.virtualNow) } : {}
+      elapsed: table.clockOf(a),
+      ...a.progress ? { progress: a.progress(table.clockOf(a)) } : {}
     });
   }
   return rows;
@@ -2367,9 +2622,7 @@ function createAnimatorApi(host) {
     },
     isActive: (key) => {
       if (key == null) return animations.size > 0;
-      for (const a of animations.values()) {
-        if (a.cancelKey === key) return true;
-      }
+      for (const _ of table.under(key)) return true;
       return false;
     },
     isTicking: host.ticking,
@@ -2384,17 +2637,11 @@ function createAnimatorApi(host) {
       clock.timeScale = timeScaleOf(s);
     },
     timeScale: () => clock.timeScale,
-    pauseKey: (key) => eachUnder(table, key, (a) => {
-      a.paused = true;
-    }),
-    resumeKey: (key) => eachUnder(table, key, (a) => {
-      a.paused = false;
-    }),
+    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.timeScale = scale;
-      });
+      eachUnder(table, key, (a) => [a.paused, scale]);
     },
     loop: (factory, loopOpts) => createLoop(createSupervisor, factory, loopOpts),
     tweenLoop: (tweenLoopOpts) => createTweenLoop(api, createSupervisor, tweenLoopOpts),
@@ -2409,12 +2656,7 @@ function createAnimatorApi(host) {
     )),
     timeline: (o) => startTimeline(host, o),
     colorOverrides: host.colorOverrides,
-    onTick: (cb) => {
-      host.subscribers.add(cb);
-      return () => {
-        host.subscribers.delete(cb);
-      };
-    },
+    onTick: (cb) => host.subscribers.subscribe(cb),
     keepAlive: () => {
       const sup = createSupervisor({ kind: "keepAlive" });
       return () => sup.cancel();
@@ -2424,6 +2666,75 @@ function createAnimatorApi(host) {
   };
   return api;
 }
+function createHoldVoices() {
+  const asked = /* @__PURE__ */ new Set();
+  const stills = /* @__PURE__ */ new Map();
+  const stale2 = /* @__PURE__ */ new Set();
+  const cue = (v) => {
+    const { start } = v;
+    const { lane, key } = v.slot;
+    v.handle?.fade({ over: 0 });
+    stale2.delete(v);
+    if (start.still) {
+      v.last = start.at();
+      const rest = tween("v", { from: v.last, to: v.last.slice(), ms: 1 });
+      v.handle = lane.mix.cue({ patch: rest, subjects: [key] });
+      return;
+    }
+    const each = patch(
+      1,
+      () => {
+        v.last = start.at();
+        return { v: v.last };
+      },
+      { writes: ["v"] }
+    );
+    v.handle = lane.mix.cue({ patch: each, subjects: [key], loop: true });
+  };
+  const settle2 = () => {
+    for (const v of stale2) cue(v);
+  };
+  return {
+    add(slot, start) {
+      const v = { slot, start: { ...start } };
+      if (start.still) {
+        stills.set(start.on, v);
+        stale2.add(v);
+      } else {
+        cue(v);
+        asked.add(v);
+      }
+      return v;
+    },
+    still(v, still) {
+      if (!v.start.still === !still) return;
+      v.start.still = still;
+      if (still) {
+        asked.delete(v);
+        stills.set(v.start.on, v);
+      } else {
+        stills.delete(v.start.on);
+        asked.add(v);
+      }
+      cue(v);
+    },
+    touch(on) {
+      const v = stills.get(on);
+      if (v) stale2.add(v);
+    },
+    settle: settle2,
+    frame() {
+      for (const v of asked) v.slot.lane.mix.touch(v.slot.key);
+      settle2();
+    },
+    remove(v) {
+      v.handle?.fade({ over: 0 });
+      asked.delete(v);
+      stale2.delete(v);
+      if (stills.get(v.start.on) === v) stills.delete(v.start.on);
+    }
+  };
+}
 function depart(s) {
   const l = s.lane;
   l.dirty = true;
@@ -2563,7 +2874,7 @@ function createCodec(placeOf) {
   const lanes = createLanes(placeOf);
   const voices = /* @__PURE__ */ new Map();
   const queue = [];
-  const holds = /* @__PURE__ */ new Set();
+  const holds = createHoldVoices();
   let time = 0;
   const springVoice = (slot, sp) => {
     const patch = sp.to == null ? glide("v", { from: sp.from, ms: 1e3 * sp.mass / sp.damping }) : spring("v", {
@@ -2596,9 +2907,9 @@ function createCodec(placeOf) {
   function stop(id) {
     const v = voices.get(id);
     if (!v) return;
-    if (v.queued) v.queued = void 0;
+    if (v.held) holds.remove(v.held);
+    else if (v.queued) v.queued = void 0;
     else v.handle.fade({ over: 0 });
-    holds.delete(v);
     lanes.leave(v.slot);
     voices.delete(id);
   }
@@ -2616,7 +2927,7 @@ function createCodec(placeOf) {
         if (v.queuedRate !== void 0) v.handle.rate = v.queuedRate;
       }
       queue.length = 0;
-      for (const v of holds) v.slot.lane.mix.touch(v.slot.key);
+      holds.frame();
       time += dtMs;
       lanes.frame(time);
     },
@@ -2662,22 +2973,20 @@ function createCodec(placeOf) {
     hold(s) {
       const zeros = new Array(s.axes).fill(0);
       const slot = lanes.join(s.axes, s.on, zeros);
-      const v = { kind: "hold", slot, from: zeros };
-      const patch$1 = patch(
-        1,
-        () => {
-          v.last = s.at();
-          return { v: v.last };
-        },
-        { writes: ["v"] }
-      );
-      v.handle = slot.lane.mix.cue({ patch: patch$1, subjects: [slot.key], loop: true });
-      voices.set(s.id, v);
-      holds.add(v);
+      voices.set(s.id, { kind: "hold", slot, from: zeros, held: holds.add(slot, s) });
       return slot;
     },
-    touch: (on) => lanes.touch(on),
+    still(id, still) {
+      const v = get(id);
+      if (!v.held) throw new Error(`codec: subject ${id} is a ${v.kind}, not a hold`);
+      holds.still(v.held, still);
+    },
+    touch(on) {
+      holds.touch(on);
+      lanes.touch(on);
+    },
     refresh(reread) {
+      holds.settle();
       lanes.refresh((slot) => {
         const queued = new Array(slot.lane.axes).fill(0);
         for (const v of queue) {
@@ -2723,7 +3032,9 @@ function createCodec(placeOf) {
       const v = voices.get(id);
       if (!v) return void 0;
       if (v.kind === "spring") return current(v);
-      if (v.kind === "path" || v.kind === "hold") return { value: v.last ?? v.from, velocity: new Array(v.from.length).fill(0) };
+      if (v.kind === "path" || v.kind === "hold") {
+        return { value: v.held?.last ?? v.last ?? v.from, velocity: new Array(v.from.length).fill(0) };
+      }
       return !v.queued && v.patch.read(v.slot.key) || { value: v.from, velocity: new Array(v.from.length).fill(0) };
     },
     voiceCount: () => voices.size,
@@ -2737,18 +3048,16 @@ function createFrame(host) {
   const { animations } = table;
   let framing = false;
   let tickDepth = 0;
-  const tickEach = (t) => {
+  const tickEach = () => {
     const finished = [];
     const threw = [];
-    for (const anim of [...animations.values()]) {
+    const all = table.waiting > 0 && host.tripwire();
+    for (const anim of all ? [...animations.values()] : table.ticks()) {
       if (animations.get(anim.id) !== anim) continue;
-      const realDt = anim.lastRealNow == null ? 0 : Math.max(0, t - anim.lastRealNow);
-      anim.lastRealNow = t;
       const scale = clock.paused ? 0 : clock.timeScale * (anim.paused ? 0 : anim.timeScale);
-      anim.virtualNow += realDt * scale;
       tickDepth += 1;
       try {
-        if (anim.tick(anim.virtualNow, scale)) finished.push(anim);
+        if (anim.tick(table.clockOf(anim), scale)) finished.push(anim);
       } catch (error) {
         threw.push([anim, error]);
       } finally {
@@ -2764,18 +3073,16 @@ function createFrame(host) {
     }
     return finished;
   };
-  const awake = () => {
-    for (const a of animations.values()) if (!a.idle) return true;
-    return false;
-  };
   return {
     tick(t) {
       const frameDt = clock.frameT == null ? 0 : Math.max(0, t - clock.frameT);
       clock.frameT = t;
       framing = true;
-      host.codec.frame(frameDt * (clock.paused ? 0 : clock.timeScale));
+      const dt = frameDt * (clock.paused ? 0 : clock.timeScale);
+      clock.elapsed += dt;
+      host.codec.frame(dt);
       host.targets.settle();
-      for (const anim of tickEach(t)) {
+      for (const anim of tickEach()) {
         if (animations.get(anim.id) === anim) table.finish(anim.id);
       }
       for (const cb of host.afterTicks.splice(0)) {
@@ -2788,41 +3095,36 @@ function createFrame(host) {
       host.reread();
       framing = false;
       host.targets.show();
-      for (const sub of host.subscribers) {
-        try {
-          sub();
-        } catch (err) {
-          console.error("useAnimator: onTick subscriber threw", err);
-        }
-      }
-      if (awake()) {
+      host.subscribers.emit();
+      if (table.awake) {
         host.requestFrame();
         return;
       }
       clock.frameT = null;
-      for (const anim of animations.values()) anim.lastRealNow = null;
     },
     framing: () => framing,
     ticking: () => tickDepth > 0
   };
 }
-
-// src/engine/core.ts
 function createAnimatorCore(host) {
-  const clock = { frameT: null, timeScale: 1, paused: false };
+  const clock = { frameT: null, elapsed: 0, timeScale: 1, paused: false };
   const hub = new AnimatorEventHub();
   const codec = createCodec((on) => {
     const { row } = on;
     return row ? { group: row.table, tag: row.index } : void 0;
   });
   const afterTicks = [];
-  const subscribers = /* @__PURE__ */ new Set();
+  const subscribers = createEmitter();
   let nextId = 1;
+  const seedClock = () => {
+    if (clock.frameT == null) clock.frameT = host.now();
+  };
   const reread = () => codec.refresh((on, queued) => targets.reread(on, queued));
   const table = createTable({
     codec,
     hub,
-    startTime: () => clock.frameT ?? host.now(),
+    elapsed: () => clock.elapsed,
+    seedClock,
     showNow: (target) => targets.showNow(target),
     resting: () => targets.resting,
     framing: () => frame.framing(),
@@ -2830,7 +3132,7 @@ function createAnimatorCore(host) {
   });
   const targets = createTargetBook({
     stop: (s) => {
-      for (const a of [...table.animations.values()]) if (a.target === s) table.retire(a.id);
+      for (const a of [...table.on(s)]) table.retire(a.id);
     },
     reread: (s) => {
       codec.touch(s);
@@ -2847,17 +3149,17 @@ function createAnimatorCore(host) {
     afterTicks,
     subscribers,
     reread,
-    requestFrame: host.requestFrame
+    requestFrame: host.requestFrame,
+    tripwire: host.tripwire
   });
   const ctx = {
     codec,
     targets,
     nextId: () => nextId++,
-    seedClock: () => {
-      if (clock.frameT == null) clock.frameT = host.now();
-    },
+    seedClock,
     register: table.register,
     has: (id) => table.animations.has(id),
+    defer: table.defer,
     reportEnd: table.reportEnd,
     finish: table.finish,
     touch: (target, at) => {
@@ -2870,8 +3172,8 @@ function createAnimatorCore(host) {
     interrupt: (key, by) => table.cancelByKey(key, by),
     velocityUnder: (key, target) => {
       let sum2 = null;
-      for (const a of table.animations.values()) {
-        if (a.cancelKey !== key || a.target !== target) continue;
+      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();
       }
@@ -2895,7 +3197,6 @@ function createAnimatorCore(host) {
     api,
     tick: frame.tick,
     resumed() {
-      for (const anim of table.animations.values()) anim.lastRealNow = null;
       clock.frameT = null;
     }
   };
@@ -3162,15 +3463,30 @@ function bindTrack(track, binder) {
   return defined({
     kind: "sampled",
     label: track.label,
-    keys: track.keys.map((k) => ({ ...k })),
+    keys: track.keys.map((k) => ({ ...k, value: reviveTypedArrays(k.value) })),
     target,
     targetName: track.target,
     interpolate,
     interpolateName: track.interpolate,
-    weight: track.weight,
-    axes: track.axes && [...track.axes]
+    ...bindWeight(track, binder),
+    axes: bindAxes(track, target)
   });
 }
+function bindWeight(track, binder) {
+  const { weight } = track;
+  if (typeof weight !== "string") return { weight };
+  const read = binder.weight?.(weight);
+  if (!read) throw new Error(`bindClip: the binder has no weight named "${weight}".`);
+  return { weight: read, weightName: weight };
+}
+function bindAxes(track, target) {
+  const { axes } = track;
+  if (!axes) return void 0;
+  const where = `bindClip: track "${track.label ?? ""}"`;
+  if (!target) throw new Error(`${where} names axes and no target.`);
+  axisIndexes(target.axes, axes, `${where} on the target "${track.target}"`);
+  return [...axes];
+}
 function bindTimeline(timeline, binder) {
   return defined({ tracks: timeline.tracks.map((t) => bindTrack(t, binder)), duration: timeline.duration });
 }
@@ -3200,17 +3516,20 @@ function sampledToClip(track, where) {
   if (track.target && track.targetName === void 0) throw new Error(`toClip: ${where} has a target and no targetName.`);
   if (track.interpolator) throw new Error(`toClip: ${where} has an interpolator, which a clip cannot hold.`);
   if (track.interpolate && track.interpolateName === void 0) throw new Error(`toClip: ${where} has an interpolate and no interpolateName.`);
-  if (typeof track.weight === "function") throw new Error(`toClip: ${where} has a function for its weight.`);
+  if (typeof track.weight === "function" && track.weightName === void 0) {
+    throw new Error(`toClip: ${where} has a function for its weight and no weightName.`);
+  }
   return defined({
     kind: "sampled",
     label: track.label,
     target: track.targetName,
     keys: track.keys.map((k) => {
-      if (!isClipValue(k.value)) throw new Error(`toClip: ${where} holds a value JSON cannot round-trip, at t = ${k.t}.`);
-      return defined({ t: k.t, value: k.value, easing: easingOf(k.easing, where) });
+      const value = tagTypedArrays(k.value);
+      if (!isClipValue(value)) throw new Error(`toClip: ${where} holds a value JSON cannot round-trip, at t = ${k.t}.`);
+      return defined({ t: k.t, value, easing: easingOf(k.easing, where) });
     }),
     interpolate: track.interpolateName,
-    weight: track.weight,
+    weight: typeof track.weight === "function" ? track.weightName : track.weight,
     axes: track.axes && [...track.axes]
   });
 }
@@ -3310,13 +3629,12 @@ var IDENTITY_JOINT = {
 // src/rig/skeletonAxes.ts
 var FIELDS = ["x", "y", "rotation", "scaleX", "scaleY"];
 var ROTATION = FIELDS.indexOf("rotation");
+function axisNames(skeleton) {
+  return skeleton.joints.flatMap((joint) => FIELDS.map((field) => `${joint.name}.${field}`));
+}
 function jointAxes(skeleton, joints) {
-  const n = FIELDS.length;
-  return joints.flatMap((name) => {
-    const j = skeleton.joints.findIndex((joint) => joint.name === name);
-    if (j < 0) throw new Error(`jointAxes: the skeleton has no joint "${name}"`);
-    return FIELDS.map((_, f) => j * n + f);
-  });
+  const names = axisNames(skeleton);
+  return axisIndexes({ count: names.length, names }, joints, "jointAxes: `joints`");
 }
 function skeletonAxes(skeleton) {
   const names = skeleton.joints.map((j) => j.name);
@@ -3324,6 +3642,7 @@ function skeletonAxes(skeleton) {
   return {
     count: names.length * n,
     angles: names.map((_, j) => j * n + ROTATION),
+    names: axisNames(skeleton),
     to(pose) {
       const out = new Array(names.length * n);
       for (let j = 0; j < names.length; j++) {
@@ -3525,7 +3844,7 @@ function skinPath(path, skin, motions) {
     coords[2 * i] = t > 0 ? sum2[2 * i] / t : from[2 * i];
     coords[2 * i + 1] = t > 0 ? sum2[2 * i + 1] / t : from[2 * i + 1];
   }
-  return { kind: "polygon", commands: rest.commands, coords, fillRule: rest.fillRule };
+  return { ...rest, coords };
 }
 function distanceToSegment(px, py, ax, ay, bx, by) {
   const dx = bx - ax;