animl 0.0.0-stage → 0.1.1

package/modules/motion/core/api.js

@@ -0,0 +1,455 @@
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import {
+  occurrence,
+  capturing,
+  stampEntryEvent
+} from "../../../packages/core/src/event-capture.js";
+import { resolveAddress } from "../../../packages/core/src/load.js";
+import { sampleTrack, mixValues } from "../../../packages/core/src/player.js";
+import { StateClocks } from "./control.js";
+import { reached, timeFloor } from "../../../packages/core/src/time.js";
+import { bounds, crossings, position, timing } from "./clock.js";
+const finite = (x) => {
+  if (!Number.isFinite(x)) throw Error("anima: expected a finite number");
+  return x;
+};
+let sample = sampleTrack, blend = mixValues, resolve = resolveAddress;
+const mixValue = (a, b, w, discrete) => discrete ? b : blend(a, b, w);
+function metadata(t) {
+  return {
+    name: t.name,
+    duration: t.duration,
+    speed: timing.get(t)?.speed ?? 1,
+    quantize: timing.get(t)?.quantize ?? null,
+    work: [...bounds(t)],
+    loop: t.loop
+  };
+}
+class TimelineInstance {
+  animation;
+  name;
+  #owner;
+  #mix = 1;
+  #speed;
+  #loop;
+  #clock;
+  #active = true;
+  #playing = true;
+  #entered = true;
+  #frozen = false;
+  didLoop = false;
+  constructor(owner, t, options = {}) {
+    this.#owner = owner;
+    this.animation = t;
+    this.name = options.name ?? t.name;
+    if (!/^[a-z][a-zA-Z0-9-]*$/.test(this.name)) throw Error("anima: invalid instance name");
+    this.#speed = finite(options.speed ?? timing.get(t)?.speed ?? 1);
+    this.#loop = options.loop ?? t.loop;
+    this.#clock = bounds(t)[this.#speed < 0 ? 1 : 0];
+    this.mix = options.mix ?? 1;
+    this.loop = this.#loop;
+  }
+  get info() {
+    return metadata(this.animation);
+  }
+  get time() {
+    return position(this.animation, this.#clock, this.#loop, false);
+  }
+  set time(value) {
+    this.seek(value);
+  }
+  get playing() {
+    return this.#active && this.#playing && !this.finished;
+  }
+  get finished() {
+    const [a, b] = bounds(this.animation);
+    return this.#loop === "once" && (this.#speed < 0 ? reached(a, this.#clock) : reached(this.#clock, b));
+  }
+  get mix() {
+    return this.#mix;
+  }
+  set mix(value) {
+    this.#mix = Math.max(0, Math.min(1, finite(value)));
+    this.#owner.wake();
+  }
+  get speed() {
+    return this.#speed;
+  }
+  set speed(value) {
+    this.#speed = finite(value);
+    this.#owner.wake();
+  }
+  get loop() {
+    return this.#loop;
+  }
+  set loop(value) {
+    if (value !== null && !["once", "loop", "pingpong"].includes(value))
+      throw Error("anima: invalid loop");
+    this.#loop = value ?? this.animation.loop;
+    this.#owner.wake();
+  }
+  seek(seconds) {
+    const [a, b] = bounds(this.animation);
+    this.#clock = Math.max(a, Math.min(b, finite(seconds)));
+    this.#frozen = false;
+    this.#entered = false;
+    this.didLoop = false;
+    this.#active = true;
+    this.#owner.wake();
+    return this;
+  }
+  scrub(progress) {
+    const [a, b] = bounds(this.animation);
+    this.pause();
+    return this.seek(a + (b - a) * Math.max(0, Math.min(1, finite(progress))));
+  }
+  play() {
+    this.#active = true;
+    this.#playing = true;
+    this.#owner.wake();
+    return this;
+  }
+  pause() {
+    this.#playing = false;
+    this.#owner.wake();
+    return this;
+  }
+  stop() {
+    this.#active = false;
+    this.#playing = false;
+    this.#clock = bounds(this.animation)[this.#speed < 0 ? 1 : 0];
+    this.#frozen = false;
+    this.#entered = true;
+    this.#owner.wake();
+    return this;
+  }
+  advance(dt) {
+    finite(dt);
+    if (dt < 0) throw Error("anima: advance needs dt \u2265 0");
+    const events = [];
+    this.didLoop = false;
+    if (!this.#active || !this.#playing) return events;
+    if (this.#entered && this.#owner.player.reducedMotion && this.animation.reduced !== "play") {
+      const end = this.animation.reduced === "end";
+      this.#clock = this.#owner.reduce(
+        this.animation,
+        this.#speed,
+        end,
+        this.name,
+        events,
+        this.#speed
+      );
+      this.#frozen = true;
+      this.#entered = false;
+      this.#playing = false;
+      return events;
+    }
+    const a = this.#clock, b = a + dt * this.#speed;
+    const [lo, hi] = bounds(this.animation), d = hi - lo;
+    this.didLoop = this.#loop === "once" ? !reached(lo, a) && reached(lo, b) || !reached(a, hi) && reached(b, hi) : timeFloor(a - lo, d) !== timeFloor(b - lo, d);
+    crossings(this.animation, a, b, this.#entered, this.name, events, this.#loop);
+    this.#entered = false;
+    this.#clock = this.#loop === "once" ? Math.max(lo, Math.min(hi, b)) : b;
+    return events;
+  }
+  apply(mix = this.mix) {
+    this.mix = mix;
+    this.#active = true;
+    this.#owner.wake();
+    return this;
+  }
+  sampleInto(values) {
+    if (!this.#active || !this.#mix) return;
+    const time = position(this.animation, this.#clock, this.#frozen ? "once" : this.#loop);
+    for (const track of this.animation.tracks) {
+      const index = this.#owner.slots.get(track.addr);
+      const prop = this.#owner.player.model.addrs.get(track.addr).prop;
+      const discrete = ["int", "uint", "string", "reference", "bool"].includes(prop.type);
+      values[index] = mixValue(
+        values[index],
+        sample(track, time, this.#owner.player),
+        this.#mix,
+        discrete
+      );
+    }
+  }
+}
+class MachineInstance {
+  name;
+  player;
+  #owner;
+  #active = true;
+  #playing = true;
+  #mix = 1;
+  constructor(owner, name, player) {
+    this.#owner = owner;
+    this.name = name;
+    this.player = player;
+  }
+  get mix() {
+    return this.#mix;
+  }
+  set mix(v) {
+    this.#mix = Math.max(0, Math.min(1, finite(v)));
+    this.#owner.wake();
+  }
+  set(name, value) {
+    this.player.set(name, value);
+    this.#owner.wake();
+  }
+  fire(name) {
+    this.player.fire(name);
+    this.#owner.wake();
+  }
+  get(name) {
+    return this.player.get(name);
+  }
+  states() {
+    return this.player.states();
+  }
+  play() {
+    this.#active = true;
+    this.#playing = true;
+    this.#owner.wake();
+  }
+  pause() {
+    this.#playing = false;
+    this.#owner.wake();
+  }
+  stop() {
+    this.#active = false;
+    this.#playing = false;
+    this.#owner.wake();
+  }
+  compose(dt, values, events) {
+    if (!this.#active) return true;
+    let settled = true;
+    if (this.#playing) {
+      this.player.reducedMotion = this.#owner.player.reducedMotion;
+      const r = this.player.step(dt, (a) => values[this.#owner.slots.get(a)]);
+      settled = r.settled;
+      events.push(...r.events.map((e) => ({ ...e, layer: this.name + "/" + e.layer })));
+    }
+    if (this.#mix)
+      for (const address of this.player.writes()) {
+        const prop = this.player.model.addrs.get(address);
+        const value = this.player.prop(prop.node, prop.key);
+        const i = this.#owner.slots.get(address);
+        values[i] = mixValue(
+          values[i],
+          value,
+          this.#mix,
+          ["int", "uint", "string", "reference", "bool"].includes(prop.prop.type)
+        );
+      }
+    return settled;
+  }
+}
+const runtimes = /* @__PURE__ */ new WeakMap();
+const exits = /* @__PURE__ */ new WeakMap();
+class MotionRuntime {
+  player;
+  slots;
+  instances = [];
+  timelines = /* @__PURE__ */ new Map();
+  machines = /* @__PURE__ */ new Map();
+  definitions;
+  PlayerClass;
+  #changed = false;
+  clocks;
+  constructor(player, definitions, PlayerClass) {
+    this.player = player;
+    this.clocks = new StateClocks(player);
+    this.definitions = definitions;
+    this.PlayerClass = PlayerClass;
+    this.slots = new Map(player.addrs.map((a, i) => [a, i]));
+    runtimes.set(player, this);
+  }
+  get busy() {
+    return this.#changed;
+  }
+  states() {
+    return Object.fromEntries(
+      [...this.machines].flatMap(
+        ([name, m]) => Object.entries(m.states()).map(([layer, state]) => [name + "/" + layer, state])
+      )
+    );
+  }
+  inspect() {
+    return [...this.machines].flatMap(
+      ([name, m]) => m.player.inspect().map((l) => ({ ...l, layer: name + "/" + l.layer }))
+    );
+  }
+  wake() {
+    this.#changed = true;
+    this.player.onChange?.();
+  }
+  enter = (run, from, to, tr, carry) => this.clocks.enter(run, from, to, tr, carry);
+  prepare = (run, s, dt, eligible) => this.clocks.prepare(run, s, dt, eligible);
+  rest = (_run, s) => this.clocks.controlled(s);
+  local(t, elapsed, _speed, run) {
+    return position(t, this.clocks.raw(run, elapsed));
+  }
+  duration = (t, speed, run) => this.clocks.duration(t, speed, run);
+  finished = (t, elapsed, run) => this.clocks.finished(t, elapsed, run);
+  resume = (run, time) => this.clocks.resume(run, time);
+  reduce(t, speed, end, layer, events, effective = speed * (timing.get(t)?.speed ?? 1)) {
+    const [a, b] = bounds(t), reverse = effective < 0;
+    const start = reverse ? b : a, finish = reverse ? a : b;
+    if (end) crossings(t, start, finish, true, layer, events, "once");
+    return end ? finish : start;
+  }
+  events(t, a, b, closed, layer, out, _speed, run, source) {
+    if (this.clocks.isControlled(run)) return;
+    const before = V ? out.length : 0;
+    crossings(
+      t,
+      this.clocks.raw(run, a),
+      this.clocks.raw(run, b),
+      closed && !this.clocks.synced(run),
+      layer,
+      out,
+      t.loop,
+      source
+    );
+    if (V && capturing) {
+      const span = (b - a) * _speed * (timing.get(t)?.speed ?? 1);
+      const fraction = !span ? 0 : (this.clocks.raw(run, b) - this.clocks.raw(run, a)) / span;
+      for (const e of out.slice(before)) {
+        e[occurrence] = (e[occurrence] ?? 0) * fraction;
+        if (closed) stampEntryEvent(e, ((e[occurrence] ?? 0) - 1) * (b - a));
+      }
+    }
+  }
+  gate(t, st, elapsed, run) {
+    const threshold = exits.get(t);
+    return this.clocks.gate(run, st, t, elapsed) && (threshold === void 0 || reached(
+      elapsed * Math.abs(st.speed * (timing.get(this.player.model.timelines[st.play])?.speed ?? 1)),
+      threshold
+    ));
+  }
+  carry(t, st, elapsed, run) {
+    const threshold = exits.get(t);
+    return threshold === void 0 ? this.clocks.carry(run, st, t, elapsed) : Math.max(
+      0,
+      elapsed - (threshold && threshold / Math.abs(
+        st.speed * (timing.get(this.player.model.timelines[st.play])?.speed ?? 1)
+      ))
+    );
+  }
+  pivot(p, node) {
+    const rest = p.model.nodes[node].raw.pivot ?? [0, 0];
+    return [p.num(node, "pivotX", rest[0]), p.num(node, "pivotY", rest[1])];
+  }
+  compose(dt, values, events) {
+    this.#changed = false;
+    let settled = true;
+    for (const i of this.instances) {
+      if (i instanceof TimelineInstance) {
+        events.push(...i.advance(dt));
+        i.sampleInto(values);
+        if (i.playing && i.speed !== 0) settled = false;
+      } else if (!i.compose(dt, values, events)) settled = false;
+    }
+    return settled && !this.#changed;
+  }
+}
+function install(PlayerClass, sampler, mixer, resolver) {
+  sample = sampler;
+  blend = mixer;
+  resolve = resolver;
+  const runtime = (p) => {
+    const r = runtimes.get(p);
+    if (!r) throw Error("anima: requires motion");
+    return r;
+  };
+  const methods = {
+    timeline(name) {
+      const r = runtime(this);
+      let t = r.timelines.get(name);
+      if (!t) {
+        t = this.createTimeline(name);
+        r.timelines.set(name, t);
+      }
+      return t;
+    },
+    createTimeline(name, options = {}) {
+      const r = runtime(this), t = this.model.timelines.find((t2) => t2.name === name);
+      if (!t) throw Error("anima: unknown timeline " + name);
+      const instance = new TimelineInstance(r, t, options);
+      if (r.instances.some((i) => i.name === instance.name))
+        throw Error("anima: duplicate instance " + instance.name);
+      r.instances.push(instance);
+      r.wake();
+      return instance;
+    },
+    machine(name) {
+      const r = runtime(this);
+      let instance = r.machines.get(name);
+      if (!instance) {
+        const m = r.definitions.get(name);
+        if (!m) throw Error("anima: unknown machine " + name);
+        if (r.instances.some((i) => i.name === name))
+          throw Error("anima: duplicate instance " + name);
+        instance = new MachineInstance(
+          r,
+          name,
+          new r.PlayerClass(m, { reducedMotion: this.reducedMotion })
+        );
+        r.instances.push(instance);
+        r.machines.set(name, instance);
+        r.wake();
+      }
+      return instance;
+    },
+    node(id, type) {
+      runtime(this);
+      const index = this.model.ids.get(id);
+      if (index === void 0) return;
+      const n = this.model.nodes[index];
+      if (type && n.type !== type) return;
+      const local = () => [...this.local(index)], world = () => [...this.world(index)];
+      return {
+        id: n.id,
+        type: n.type,
+        get: (key) => {
+          const a = resolve(id + "." + key, this.model.nodes, this.model.ids);
+          const v = Array.isArray(a) ? this.prop(index, key) : this.model.addrs.has(id + "." + key) ? this.prop(index, key) : a.rest;
+          return Array.isArray(v) ? [...v] : typeof v === "object" ? void 0 : v;
+        },
+        get local() {
+          return local();
+        },
+        get world() {
+          return world();
+        }
+      };
+    },
+    seek(name, seconds) {
+      return this.timeline(name).seek(seconds);
+    },
+    scrub(name, progress) {
+      return this.timeline(name).scrub(progress);
+    },
+    applyTimeline(name, seconds, options = {}) {
+      const i = this.timeline(name).pause().seek(seconds);
+      i.mix = options.mix ?? 1;
+      return i;
+    }
+  };
+  Object.defineProperties(PlayerClass.prototype, Object.getOwnPropertyDescriptors(methods));
+  Object.defineProperty(PlayerClass.prototype, "animations", {
+    configurable: true,
+    get: function() {
+      return this.model.timelines.map(metadata);
+    }
+  });
+}
+export {
+  MachineInstance,
+  MotionRuntime,
+  TimelineInstance,
+  exits,
+  install,
+  metadata
+};

package/modules/motion/core/clock.d.ts

@@ -0,0 +1,16 @@
+import type { TimelineM } from '../../../packages/core/src/load.js';
+import type { AnimaEvent } from '../../../packages/core/src/player.js';
+export type Loop = TimelineM['loop'];
+export interface Timing {
+    speed?: number;
+    quantize?: number;
+    work?: [number, number];
+}
+export declare const timing: WeakMap<TimelineM, Timing>;
+export declare const bounds: (t: TimelineM) => [number, number];
+export declare function position(t: TimelineM, clock: number, loop?: Loop, quantize?: boolean): number;
+/** Source clock, before work-area folding and sample quantization. */
+export declare function clock(t: TimelineM, elapsed: number, stateSpeed?: number): number;
+export declare const duration: (t: TimelineM, speed: number) => number;
+/** Half-open crossings, stable by authored event order for coincident events. */
+export declare function crossings(t: TimelineM, a: number, b: number, closed: boolean, layer: string, out: AnimaEvent[], loop?: Loop, source?: [number, string][]): void;

package/modules/motion/core/clock.js

@@ -0,0 +1,62 @@
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { stampEvent } from "../../../packages/core/src/event-capture.js";
+import { reached, snapTime, foldTime } from "../../../packages/core/src/time.js";
+const timing = /* @__PURE__ */ new WeakMap();
+const bounds = (t) => timing.get(t)?.work ?? [0, t.duration];
+function position(t, clock2, loop = t.loop, quantize = true) {
+  const [start, end] = bounds(t), d = end - start;
+  const relative = clock2 - start;
+  const x = loop === "once" ? Math.max(0, Math.min(d, snapTime(snapTime(relative, 0), d))) : foldTime(relative, d, loop === "pingpong");
+  let at = x === d ? end : start + x;
+  const q = timing.get(t)?.quantize;
+  if (quantize && q && at !== end) {
+    const tick = Math.round(at * q) / q;
+    at = Math.max(start, snapTime(at, tick) === tick ? tick : Math.floor(at * q) / q);
+  }
+  return at;
+}
+function clock(t, elapsed, stateSpeed = 1) {
+  const speed = stateSpeed * (timing.get(t)?.speed ?? 1);
+  const [a, b] = bounds(t);
+  return (speed < 0 ? b : a) + elapsed * speed;
+}
+const duration = (t, speed) => {
+  const [a, b] = bounds(t);
+  return (b - a) / Math.abs(speed * (timing.get(t)?.speed ?? 1));
+};
+function crossings(t, a, b, closed, layer, out, loop = t.loop, source = t.events) {
+  const [start, end] = bounds(t), d = end - start;
+  const reverse = b < a;
+  const lo = Math.min(a, b), hi = Math.max(a, b);
+  const period = loop === "pingpong" ? 2 * d : d;
+  const found = [];
+  for (const [at, name] of source) {
+    if (at < start || at > end) continue;
+    const first = loop === "once" ? 0 : Math.floor((lo - start) / period) - 1;
+    const last = loop === "once" ? 0 : Math.min(first + 1e4, Math.ceil((hi - start) / period) + 1);
+    const seen = /* @__PURE__ */ new Set();
+    for (let k = first; k <= last; k++) {
+      for (const x of loop === "pingpong" && at !== start && at !== end ? [at + k * period, 2 * end - at + k * period] : [at + k * period]) {
+        const hit = reverse ? reached(x, b) && (closed ? reached(a, x) : !reached(x, a)) : reached(b, x) && (closed ? reached(x, a) : !reached(a, x));
+        if (hit && !seen.has(x)) {
+          seen.add(x);
+          found.push([x, at, name]);
+        }
+      }
+    }
+  }
+  found.sort((x, y) => reverse ? y[0] - x[0] : x[0] - y[0]);
+  for (const [at, time, name] of found) {
+    const event = { name, layer, time };
+    if (V) stampEvent(event, (at - a) / (b - a));
+    out.push(event);
+  }
+}
+export {
+  bounds,
+  clock,
+  crossings,
+  duration,
+  position,
+  timing
+};

package/modules/motion/core/control.d.ts

@@ -0,0 +1,26 @@
+import type { StateM, TransitionM, TimelineM } from '../../../packages/core/src/load.js';
+import type { Player } from '../../../packages/core/src/player.js';
+export declare const stateControls: WeakMap<StateM, {
+    hold?: boolean;
+}>;
+export declare const syncs: WeakSet<TransitionM>;
+export declare const nextExits: WeakMap<TransitionM, "step" | "loop">;
+export declare class StateClocks {
+    #private;
+    readonly player: Player;
+    constructor(player: Player);
+    resume(run: object, time: number): void;
+    rate(s: StateM): number;
+    controlled(s: StateM): boolean;
+    synced(run: object): boolean;
+    isControlled(run: object): boolean;
+    input(s: StateM): number | undefined;
+    raw(run: object, elapsed: number): number;
+    enter(run: object, from: StateM | undefined, to: StateM, tr: TransitionM | undefined, carry: number): void;
+    arm(run: object, s: StateM, tr: TransitionM): number;
+    prepare(run: object, s: StateM, _dt: number, eligible: (t: TransitionM) => boolean): void;
+    gate(run: object, s: StateM, tr: TransitionM, elapsed: number): boolean;
+    carry(run: object, s: StateM, tr: TransitionM, elapsed: number): number | undefined;
+    finished(t: TimelineM, elapsed: number, run: object): boolean;
+    duration(t: TimelineM, speed: number, run: object): number;
+}

package/modules/motion/core/control.js

@@ -0,0 +1,130 @@
+import { bounds, clock, position, timing } from "./clock.js";
+import { reached, snapTime, timeFloor } from "../../../packages/core/src/time.js";
+const stateControls = /* @__PURE__ */ new WeakMap();
+const syncs = /* @__PURE__ */ new WeakSet();
+const nextExits = /* @__PURE__ */ new WeakMap();
+class StateClocks {
+  #runs = /* @__PURE__ */ new WeakMap();
+  player;
+  constructor(player) {
+    this.player = player;
+  }
+  resume(run, time) {
+    const c = this.#runs.get(run);
+    if (!this.controlled(c.state)) c.start = time - run.time * this.rate(c.state);
+    c.limit = Infinity;
+    c.armed.clear();
+  }
+  rate(s) {
+    return s.speed * (timing.get(this.player.model.timelines[s.play])?.speed ?? 1);
+  }
+  controlled(s) {
+    return !!stateControls.get(s)?.hold || !!this.player.model.timeBindings?.has(s);
+  }
+  synced(run) {
+    return this.#runs.get(run).synced;
+  }
+  isControlled(run) {
+    return this.controlled(this.#runs.get(run).state);
+  }
+  input(s) {
+    const expression = this.player.model.timeBindings?.get(s);
+    if (!expression) return;
+    const inputs = new Map(
+      [...this.player.model.inputs.keys()].map((n) => [n, this.player.get(n)])
+    );
+    const [a, b] = bounds(this.player.model.timelines[s.play]);
+    return Math.max(a, Math.min(b, expression(inputs)));
+  }
+  raw(run, elapsed) {
+    const c = this.#runs.get(run);
+    if (Number.isFinite(c.limit) && reached(elapsed, c.limit)) elapsed = c.limit;
+    return c.start + (this.controlled(c.state) ? 0 : Math.min(elapsed, c.limit) * this.rate(c.state));
+  }
+  enter(run, from, to, tr, carry) {
+    if (to.play === void 0) {
+      this.#runs.delete(run);
+      return;
+    }
+    const t = this.player.model.timelines[to.play];
+    const old = run;
+    const value = this.input(to);
+    const start = tr && syncs.has(tr) && from?.play !== void 0 ? old.frozen >= 0 ? old.frozen : position(t, this.raw(run, old.time - carry), t.loop, false) : value ?? clock(t, 0, to.speed);
+    this.#runs.set(run, {
+      start,
+      state: to,
+      limit: Infinity,
+      armed: /* @__PURE__ */ new Map(),
+      value,
+      synced: !!tr && syncs.has(tr)
+    });
+  }
+  // Inclusive boundary: a request observed exactly at a tick need not wait another tick.
+  arm(run, s, tr) {
+    const c = this.#runs.get(run);
+    let at = c.armed.get(tr);
+    if (at !== void 0) return at;
+    const r = run, t = this.player.model.timelines[s.play];
+    const [a, b] = bounds(t), rate = this.rate(s);
+    if (r.frozen >= 0 || this.controlled(s) || !rate) at = r.time;
+    else {
+      const raw = this.raw(run, r.time), local = position(t, raw, t.loop, false);
+      const segment = timeFloor(raw - a, b - a);
+      const forward = rate > 0 !== (t.loop === "pingpong" && Math.abs(segment % 2) === 1);
+      const q = nextExits.get(tr) === "step" ? timing.get(t)?.quantize : void 0;
+      const rounded = q ? Math.round(local * q) / q : forward ? a : b;
+      const exact = snapTime(local, rounded) === rounded || snapTime(local, a) === a || snapTime(local, b) === b;
+      const boundary = exact ? local : q ? Math.max(a, Math.min(b, (forward ? Math.ceil(local * q) : Math.floor(local * q)) / q)) : forward ? b : a;
+      at = r.time + Math.abs(boundary - local) / Math.abs(rate);
+    }
+    c.armed.set(tr, at);
+    return at;
+  }
+  prepare(run, s, _dt, eligible) {
+    if (s.play === void 0) return;
+    const c = this.#runs.get(run);
+    const value = this.input(s);
+    if (value !== void 0 && value !== c.value) {
+      c.start = value;
+      c.value = value;
+    }
+    c.limit = Infinity;
+    for (const tr of s.on) {
+      if (!nextExits.has(tr)) continue;
+      if (!eligible(tr)) {
+        c.armed.delete(tr);
+        continue;
+      }
+      this.arm(run, s, tr);
+    }
+  }
+  gate(run, s, tr, elapsed) {
+    if (!nextExits.has(tr)) return true;
+    const at = this.arm(run, s, tr);
+    if (!reached(elapsed, at)) return false;
+    this.#runs.get(run).limit = at;
+    return true;
+  }
+  carry(run, s, tr, elapsed) {
+    return nextExits.has(tr) ? Math.max(0, elapsed - this.arm(run, s, tr)) : void 0;
+  }
+  finished(t, elapsed, run) {
+    const c = this.#runs.get(run);
+    if (this.controlled(c.state)) return false;
+    const rate = this.rate(c.state), [a, b] = bounds(t);
+    const raw = this.raw(run, elapsed);
+    return rate < 0 ? reached(a, raw) : rate > 0 && reached(raw, b);
+  }
+  duration(t, speed, run) {
+    const c = this.#runs.get(run);
+    if (this.controlled(c.state)) return Infinity;
+    const [a, b] = bounds(t), rate = speed * (timing.get(t)?.speed ?? 1);
+    return rate ? Math.max(0, (rate < 0 ? c.start - a : b - c.start) / Math.abs(rate)) : Infinity;
+  }
+}
+export {
+  StateClocks,
+  nextExits,
+  stateControls,
+  syncs
+};

package/modules/motion/core/curves.d.ts

@@ -0,0 +1,3 @@
+import { type EaseFn } from '../../../packages/core/src/ease.js';
+export declare function motionEase(src: string): EaseFn | string | undefined;
+export declare function valueCurve(src: string, a: number, b: number): EaseFn | string | undefined;