@weasel-js/clock 0.0.0-stage → 1.13.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 orochi235
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,53 @@
-# Temporary Holding Version
+# @weasel-js/clock
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A clock for a run of time: a position (`elapsed`) moved by a signed `rate`,
+across one pass or many, with ramps, seeking and an optional mix that follows it.
+
+Part of [weasel](https://github.com/orochi235/weasel), a domain-agnostic 2D
+scene-graph canvas kit for React. See the
+[API reference](https://orochi235.github.io/weasel/#pkg/clock).
+
+```sh
+npm install @weasel-js/clock
+```
+
+`createClock` and `createClockRegistry` are the root entry and need no React or
+DOM. `useClockLoop`, the one frame loop that syncs a registry's clocks, is in
+`@weasel-js/clock/react`.
+
+## Shown time
+
+A clock's shown time is `origin` plus how far it stands into its pass.
+`origin` (in `ClockSpec`) is where a pass starts on the timeline. On a looping
+clock the shown time is per pass: `shownInPass` reads it, and a time on a pass
+boundary reads as the end of the pass before.
+
+`ClockHandle.declare(spec)` takes up a new `duration`, `origin` and `speed`,
+and `loop` when the declared `loop` changed since the last declaration, so a
+loop toggled since survives an edit that only moves the span. It keeps the pass
+and the shown time within it, clamped to the new pass and run.
+`ClockHandle.override(span)` replaces the declared `duration` and `origin` until
+called with `null`, keeping the shown time the same way; a `declare` under it
+changes what lies beneath.
+
+`holdAt(handle, shown)` pauses a clock at a time shown within a pass, placed in
+the first pass, and keeps placing it there as the span moves; a time past the
+pass's end waits at the end until the span reaches it. Its limit: a foreign
+seek to exactly the held, clamped value looks the same as the hold's own, so it
+does not release it. `holdElapsed(handle, position)` holds the same way at a
+recorded `elapsed` across the whole run, so a clock of several passes comes back
+in the pass it stood in; a position recorded under another `duration` or
+`origin` keeps its pass and the time it showed within it.
+
+## Visibility
+
+A registry runs one frame loop for all its clocks. `register(id, handle,
+target)` may name a target, which resolves the element showing the clock, and
+`targets(handle)` lists them. A clock is gated, meaning not advanced, only when
+all three hold:
+
+- it is not the registry's shared clock;
+- every registration of it gave a visibility target;
+- none of those targets is in view.
+
+A gated clock is rebased when it comes back, so it resumes without a jump.

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+import { C as Clock, a as ClockPosition, b as ClockSpec, c as ClockHandle } from './registry-C2h_prHD.js';
+export { d as ClockRegistry, e as ClockTarget, f as ClockedMix, g as createClockRegistry } from './registry-C2h_prHD.js';
+
+/** Where `clock` stands, for a record to reopen it at; `declared` is the
+ *  duration its spec gave, and `declaredOrigin` the origin. */
+declare function clockPosition(clock: Clock, declared: number | undefined, declaredOrigin?: number): ClockPosition;
+/** A clock, opened from its declaration and, for a run reopened, where it
+ *  stood. */
+declare function createClock(spec: ClockSpec, at?: ClockPosition): ClockHandle;
+
+/** The time a clock standing `elapsed` into a run of `loop` passes shows
+ *  within its pass: a time on a pass boundary past the start shows as the end
+ *  of the pass before, and one past the run's end runs on in its last pass. */
+declare function shownInPass(origin: number, elapsed: number, duration: number, loop?: boolean | number): number;
+/** A clock held at a time its span may not reach yet. */
+interface PlayheadHold {
+    /** The held time while the clock stands elsewhere (clamped), else null. */
+    pending(): number | null;
+    /** Stop holding. Idempotent. */
+    release(): void;
+}
+/**
+ * Pauses `handle`'s clock at `shown`, a time shown within a pass (`null`: the
+ * span's start), placed in the first pass, and keeps seeking there as `declare`
+ * or a `duration` write moves the span. A time past the pass's end waits at it.
+ * Any other change (a rate, a seek of someone else's) releases the hold. A
+ * clock that is not seekable is never held.
+ */
+declare function holdAt(handle: ClockHandle, shown: number | null): PlayheadHold;
+/** A recorded position `holdElapsed` holds at. */
+type HeldPosition = Pick<ClockPosition, 'elapsed' | 'passEnd' | 'duration' | 'origin'>;
+/**
+ * As {@link holdAt}, but at a recorded position across the whole run, so a
+ * clock of several passes comes back in the pass it stood in. A position
+ * recorded under another `duration` or `origin` keeps its pass and the time it
+ * showed within it. `pending` reports the `elapsed` it holds for, on the
+ * clock's current span.
+ */
+declare function holdElapsed(handle: ClockHandle, at: HeldPosition): PlayheadHold;
+
+/** The speeds a transport offers by default, unsigned. */
+declare const CLOCK_RATES: readonly [0.25, 0.5, 1, 2, 4];
+
+export { CLOCK_RATES, Clock, ClockHandle, ClockPosition, ClockSpec, type HeldPosition, type PlayheadHold, clockPosition, createClock, holdAt, holdElapsed, shownInPass };

package/dist/index.js

@@ -0,0 +1,458 @@
+import { createEmitter } from '@weasel-js/registry';
+
+// src/clock.ts
+
+// src/mixFollow.ts
+function followMix(mix) {
+  let host = 0;
+  mix?.sync(host);
+  return (elapsed) => {
+    if (!mix) return;
+    const ahead = elapsed - mix.now;
+    if (ahead > 0) {
+      host += ahead;
+      mix.sync(host);
+    } else if (ahead < 0) mix.seek(elapsed);
+  };
+}
+
+// src/place.ts
+function placeOf(elapsed, duration, passes, edge) {
+  if (!(duration > 0) || !Number.isFinite(duration)) return { pass: 0, phase: 0 };
+  if (elapsed >= duration * passes) return { pass: passes - 1, phase: 1 };
+  const pass = Math.floor(elapsed / duration);
+  if (edge && pass > 0 && elapsed === pass * duration) return { pass: pass - 1, phase: 1 };
+  return { pass, phase: elapsed % duration / duration };
+}
+var passesOf = (loop) => loop === true ? Number.POSITIVE_INFINITY : loop === false ? 1 : Math.max(1, loop);
+
+// src/ramp.ts
+function stepRamp(rate, ramp, dt) {
+  if (!ramp) return { area: rate * dt, rate, ramp: null, settled: false };
+  if (dt >= ramp.left) {
+    const area = (rate + ramp.to) / 2 * ramp.left + ramp.to * (dt - ramp.left);
+    return { area, rate: ramp.to, ramp: null, settled: true };
+  }
+  const next = rate + (ramp.to - rate) * dt / ramp.left;
+  return {
+    area: (rate + next) / 2 * dt,
+    rate: next,
+    ramp: { to: ramp.to, left: ramp.left - dt },
+    settled: false
+  };
+}
+
+// src/rates.ts
+var CLOCK_RATES = [0.25, 0.5, 1, 2, 4];
+
+// src/validate.ts
+var checkDuration = (duration) => {
+  if (!(duration > 0)) throw new RangeError(`a clock's duration is positive, not ${duration}`);
+};
+var ratesOf = (spec) => {
+  const rates = [...spec.rates ?? CLOCK_RATES].sort((a, b) => a - b);
+  if (rates.length === 0 || rates.some((r) => !(r > 0) || !Number.isFinite(r)))
+    throw new RangeError("a clock offers at least one rate, each finite and positive");
+  return rates;
+};
+var checkRate = (rate, seekable) => {
+  if (!Number.isFinite(rate)) throw new RangeError(`a clock's rate is finite, not ${rate}`);
+  if (rate < 0 && !seekable)
+    throw new RangeError("a clock that is not seekable cannot run backward");
+};
+var checkSpeed = (speed) => {
+  if (!(speed > 0) || !Number.isFinite(speed))
+    throw new RangeError(`a clock's speed is finite and positive, not ${speed}`);
+};
+var checkOrigin = (origin) => {
+  if (!Number.isFinite(origin)) throw new RangeError(`a clock's origin is finite, not ${origin}`);
+};
+
+// src/clock.ts
+function clockPosition(clock, declared, declaredOrigin = 0) {
+  const duration = declared ?? Number.POSITIVE_INFINITY;
+  return {
+    elapsed: clock.elapsed,
+    rate: clock.rate,
+    ...clock.duration !== duration ? { duration: clock.duration } : {},
+    ...clock.origin !== declaredOrigin ? { origin: clock.origin } : {},
+    ...clock.phase === 1 && !clock.ended ? { passEnd: true } : {}
+  };
+}
+var clamp = (run, ms) => Math.min(Math.max(0, ms), run.span);
+var isInert = (run) => run.rate === 0 && run.ramp === null && !run.changed;
+var passAt = (run) => placeOf(run.elapsed, run.duration, passesOf(run.loop), run.edge).pass;
+var phaseAt = (run) => placeOf(run.elapsed, run.duration, passesOf(run.loop), run.edge).phase;
+var restingSpeed = (rate) => Math.abs(rate) || 1;
+function passOf(run) {
+  const { pass } = placeOf(run.elapsed, run.duration, passesOf(run.loop), run.edge);
+  return { pass, into: pass === 0 ? run.elapsed : run.elapsed - pass * run.duration };
+}
+function placeIn(run, pass, into) {
+  const last = passesOf(run.loop) - 1;
+  const within = Math.min(Math.max(0, into), run.duration);
+  run.elapsed = clamp(run, Math.min(pass, last) * run.duration + within);
+  run.edge = run.elapsed > 0 && run.elapsed % run.duration === 0;
+}
+function change(run, hub) {
+  run.changed = true;
+  if (run.wakeFired) return;
+  run.wakeFired = true;
+  hub.wakes.emit();
+}
+function setDuration(run, hub, next) {
+  checkDuration(next);
+  if (next === run.duration) return;
+  if (Number.isFinite(run.duration) && Number.isFinite(next)) {
+    const ended = run.elapsed >= run.span;
+    const at = passAt(run) + phaseAt(run);
+    run.duration = next;
+    run.span = run.duration * passesOf(run.loop);
+    run.elapsed = ended ? run.span : clamp(run, at * run.duration);
+  } else {
+    run.duration = next;
+    run.span = run.duration * passesOf(run.loop);
+    run.elapsed = clamp(run, run.elapsed);
+  }
+  change(run, hub);
+  hub.subs.emit();
+}
+function declaredOf(run, spec) {
+  return {
+    duration: spec.duration ?? Number.POSITIVE_INFINITY,
+    origin: spec.origin ?? 0,
+    loop: spec.loop ?? false,
+    speed: spec.speed ?? restingSpeed(run.rate)
+  };
+}
+function applyRun(run, hub, declared, override) {
+  const duration = override?.duration ?? declared.duration;
+  const origin = override?.origin ?? declared.origin;
+  checkDuration(duration);
+  checkOrigin(origin);
+  checkSpeed(declared.speed);
+  const finite = Number.isFinite(run.duration) && Number.isFinite(duration);
+  const { pass, into } = finite ? passOf(run) : { pass: 0, into: run.elapsed };
+  const shown = run.origin + into;
+  run.duration = duration;
+  run.loop = declared.loop;
+  run.span = duration * passesOf(run.loop);
+  run.origin = origin;
+  run.speed = declared.speed;
+  if (Number.isFinite(duration)) placeIn(run, pass, shown - origin);
+  else {
+    run.elapsed = clamp(run, shown - origin);
+    run.edge = false;
+  }
+  change(run, hub);
+  hub.subs.emit();
+}
+function advance(run, hub, dt) {
+  const step = stepRamp(run.rate, run.ramp, dt);
+  run.rate = step.rate;
+  run.ramp = step.ramp;
+  if (step.settled) hub.subs.emit();
+  return step.area;
+}
+function syncTo(run, hub, timestamp) {
+  const wasChanged = run.changed;
+  const before = run.elapsed;
+  if (!Number.isNaN(run.last) && !run.slept) {
+    run.elapsed += advance(run, hub, Math.max(0, timestamp - run.last));
+    if (run.elapsed >= run.span && run.rate > 0) {
+      run.elapsed = run.span;
+      run.rate = 0;
+      run.ramp = null;
+      hub.subs.emit();
+    } else if (run.elapsed <= 0 && run.rate < 0) {
+      run.elapsed = 0;
+      run.rate = 0;
+      run.ramp = null;
+      hub.subs.emit();
+    }
+  }
+  run.last = timestamp;
+  run.changed = false;
+  run.wakeFired = false;
+  run.slept = isInert(run);
+  if (run.elapsed !== before) run.edge = false;
+  if (run.elapsed !== before || wasChanged) {
+    hub.follow(run.elapsed);
+    hub.frames.emit(run.elapsed, passAt(run));
+  }
+}
+function clockOf(run, hub, seekable, rates) {
+  const clock = {
+    get elapsed() {
+      return run.elapsed;
+    },
+    get pass() {
+      return passAt(run);
+    },
+    get phase() {
+      return phaseAt(run);
+    },
+    get duration() {
+      return run.duration;
+    },
+    set duration(next) {
+      setDuration(run, hub, next);
+    },
+    get origin() {
+      return run.origin;
+    },
+    get speed() {
+      return run.speed;
+    },
+    rates,
+    seekable,
+    get ended() {
+      return Number.isFinite(run.span) && run.elapsed >= run.span;
+    },
+    get rate() {
+      return run.rate;
+    },
+    set rate(next) {
+      checkRate(next, seekable);
+      run.rate = next;
+      run.ramp = null;
+      change(run, hub);
+      hub.subs.emit();
+    },
+    get loop() {
+      return run.loop;
+    },
+    set loop(next) {
+      const { pass, into } = passOf(run);
+      run.loop = next;
+      run.span = run.duration * passesOf(run.loop);
+      if (run.elapsed > run.span) placeIn(run, pass, into);
+      change(run, hub);
+      hub.subs.emit();
+    },
+    ramp(to, over) {
+      checkRate(to, seekable);
+      if (!(over > 0)) {
+        clock.rate = to;
+        return;
+      }
+      run.ramp = { to, left: over };
+      change(run, hub);
+      hub.subs.emit();
+    },
+    seek(target, line = "start") {
+      if (!seekable) throw new Error("this clock is not seekable");
+      run.elapsed = clamp(run, target);
+      run.edge = line === "end";
+      change(run, hub);
+      hub.subs.emit();
+    },
+    sync: (timestamp) => syncTo(run, hub, timestamp),
+    rebase() {
+      run.last = Number.NaN;
+    },
+    get inert() {
+      return isInert(run);
+    },
+    onWake: hub.wakes.subscribe,
+    subscribe: hub.subs.subscribe
+  };
+  return clock;
+}
+function createClock(spec, at) {
+  const duration = at?.duration ?? spec.duration ?? Number.POSITIVE_INFINITY;
+  checkDuration(duration);
+  const seekable = spec.seekable ?? true;
+  const openRate = spec.rate ?? 0;
+  checkRate(openRate, seekable);
+  const rates = ratesOf(spec);
+  const origin = at?.origin ?? spec.origin ?? 0;
+  checkOrigin(origin);
+  if (spec.speed !== void 0) checkSpeed(spec.speed);
+  const loop = spec.loop ?? false;
+  const run = {
+    duration,
+    loop,
+    span: duration * passesOf(loop),
+    origin,
+    speed: spec.speed ?? restingSpeed(openRate),
+    rate: at ? at.rate : openRate,
+    elapsed: 0,
+    edge: at?.passEnd ?? false,
+    ramp: null,
+    last: Number.NaN,
+    changed: false,
+    slept: false,
+    wakeFired: false
+  };
+  const opening = () => {
+    if (spec.start !== "end") return clamp(run, spec.start ?? 0);
+    if (!Number.isFinite(run.span))
+      throw new RangeError("a run that never ends has no 'end' to start at");
+    return run.span;
+  };
+  run.elapsed = at ? clamp(run, at.elapsed) : opening();
+  const mix = spec.mix?.() ?? null;
+  const hub = {
+    wakes: createEmitter(),
+    subs: createEmitter(),
+    frames: createEmitter(),
+    follow: followMix(mix),
+    opening
+  };
+  const clock = clockOf(run, hub, seekable, rates);
+  hub.follow(run.elapsed);
+  let declared = {
+    duration: spec.duration ?? Number.POSITIVE_INFINITY,
+    origin: spec.origin ?? 0,
+    loop: run.loop,
+    speed: run.speed
+  };
+  let override = null;
+  return {
+    clock,
+    mix,
+    step: spec.step,
+    reset() {
+      run.elapsed = hub.opening();
+      run.edge = false;
+      run.rate = openRate;
+      run.ramp = null;
+      change(run, hub);
+      hub.subs.emit();
+    },
+    declare(next) {
+      const was = declared.loop;
+      declared = declaredOf(run, next);
+      applyRun(run, hub, { ...declared, loop: declared.loop !== was ? declared.loop : run.loop }, override);
+    },
+    override(next) {
+      override = next ? { ...next } : null;
+      applyRun(run, hub, { ...declared, loop: run.loop }, override);
+    },
+    onFrame: hub.frames.subscribe
+  };
+}
+
+// src/hold.ts
+function shownInPass(origin, elapsed, duration, loop = true) {
+  if (!Number.isFinite(duration)) return origin + elapsed;
+  const last = (passesOf(loop) - 1) * duration;
+  if (elapsed > last + duration) return origin + elapsed - last;
+  const into = elapsed % duration;
+  return origin + (into === 0 && elapsed > 0 ? duration : into);
+}
+function holdAt(handle, shown) {
+  return holdWhere(
+    handle,
+    (clock) => {
+      const within = Math.min(shown === null ? 0 : shown - clock.origin, clock.duration);
+      return [within, within > 0 && within === clock.duration ? "end" : "start"];
+    },
+    (clock) => shown === null || clock.origin + clock.elapsed === shown ? null : shown
+  );
+}
+function holdElapsed(handle, at) {
+  return holdWhere(
+    handle,
+    (clock) => elapsedOn(clock, at),
+    (clock) => {
+      const [target] = elapsedOn(clock, at);
+      return clock.elapsed === target ? null : target;
+    }
+  );
+}
+function elapsedOn(clock, at) {
+  const line = at.passEnd ? "end" : "start";
+  const from = at.duration ?? clock.duration;
+  const origin = at.origin ?? clock.origin;
+  if (from === clock.duration && origin === clock.origin) return [at.elapsed, line];
+  if (!Number.isFinite(from) || !Number.isFinite(clock.duration))
+    return [at.elapsed + origin - clock.origin, line];
+  let pass = Math.floor(at.elapsed / from);
+  let into = at.elapsed - pass * from;
+  if (at.passEnd && into === 0 && pass > 0) {
+    pass -= 1;
+    into = from;
+  }
+  const within = Math.min(Math.max(0, origin + into - clock.origin), clock.duration);
+  const end = within > 0 && within === clock.duration;
+  return [pass * clock.duration + within, end ? "end" : "start"];
+}
+function holdWhere(handle, where, wanted) {
+  const { clock } = handle;
+  let released = false;
+  let busy = false;
+  let unsub = null;
+  let duration = clock.duration;
+  let origin = clock.origin;
+  let loop = clock.loop;
+  let set = clock.elapsed;
+  const release = () => {
+    released = true;
+    unsub?.();
+    unsub = null;
+  };
+  const place = () => {
+    busy = true;
+    try {
+      clock.seek(...where(clock));
+    } finally {
+      busy = false;
+    }
+    duration = clock.duration;
+    origin = clock.origin;
+    loop = clock.loop;
+    set = clock.elapsed;
+  };
+  if (!clock.seekable) {
+    released = true;
+  } else {
+    clock.rate = 0;
+    place();
+    unsub = clock.subscribe(() => {
+      if (busy || released) return;
+      if (clock.rate !== 0) release();
+      else if (clock.duration !== duration || clock.origin !== origin || clock.loop !== loop) place();
+      else if (clock.elapsed !== set) release();
+    });
+  }
+  return {
+    pending: () => released ? null : wanted(clock),
+    release
+  };
+}
+function createClockRegistry(shared = null) {
+  const entries = /* @__PURE__ */ new Map();
+  const changed = createEmitter();
+  const notify = changed.emit;
+  return {
+    register(id, handle, target) {
+      const entry = { handle, target };
+      entries.set(id, entry);
+      notify();
+      return () => {
+        if (entries.get(id) !== entry) return;
+        entries.delete(id);
+        notify();
+      };
+    },
+    get: (id) => entries.get(id)?.handle ?? null,
+    targets(handle) {
+      const found = [];
+      for (const entry of entries.values()) {
+        if (entry.handle !== handle) continue;
+        if (!entry.target) return [];
+        found.push(entry.target);
+      }
+      return found;
+    },
+    shared,
+    all: () => /* @__PURE__ */ new Set([...shared ? [shared] : [], ...[...entries.values()].map((e) => e.handle)]),
+    subscribe: changed.subscribe
+  };
+}
+
+export { CLOCK_RATES, clockPosition, createClock, createClockRegistry, holdAt, holdElapsed, shownInPass };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mixFollow.ts","../src/place.ts","../src/ramp.ts","../src/rates.ts","../src/validate.ts","../src/clock.ts","../src/hold.ts","../src/registry.ts"],"names":["createEmitter"],"mappings":"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","file":"index.js","sourcesContent":["import type { ClockedMix } from './types';\n\n/** Keeps `mix` at the clock's time: its host clock only goes forward, by what\n *  the clock moved forward, and it seeks back when the clock does. */\nexport function followMix(mix: ClockedMix | null): (elapsed: number) => void {\n  let host = 0;\n  mix?.sync(host);\n  return (elapsed) => {\n    if (!mix) return;\n    const ahead = elapsed - mix.now;\n    if (ahead > 0) {\n      host += ahead;\n      mix.sync(host);\n    } else if (ahead < 0) mix.seek(elapsed);\n  };\n}\n","/** Which pass `elapsed` falls in and how far through it. `edge` reads the\n *  start of a pass after the first as the end of the one before. */\nexport function placeOf(\n  elapsed: number,\n  duration: number,\n  passes: number,\n  edge: boolean,\n): { pass: number; phase: number } {\n  if (!(duration > 0) || !Number.isFinite(duration)) return { pass: 0, phase: 0 };\n  if (elapsed >= duration * passes) return { pass: passes - 1, phase: 1 };\n  const pass = Math.floor(elapsed / duration);\n  if (edge && pass > 0 && elapsed === pass * duration) return { pass: pass - 1, phase: 1 };\n  return { pass, phase: (elapsed % duration) / duration };\n}\n\n/** How many passes `loop` makes. */\nexport const passesOf = (loop: boolean | number): number =>\n  loop === true ? Number.POSITIVE_INFINITY : loop === false ? 1 : Math.max(1, loop);\n","/** A rate on its way to `to`, `left` real ms from arriving. */\nexport interface Ramp {\n  to: number;\n  left: number;\n}\n\n/** What one step of `dt` real ms did: the ms of clock time it covered, the rate\n *  after it, the ramp still running (`null` once settled), and whether it settled. */\nexport interface RampStep {\n  area: number;\n  rate: number;\n  ramp: Ramp | null;\n  settled: boolean;\n}\n\n/** Steps `rate` over `dt` real ms along `ramp` (none: constant), integrating the\n *  clock time covered. Does not mutate `ramp`. */\nexport function stepRamp(rate: number, ramp: Ramp | null, dt: number): RampStep {\n  if (!ramp) return { area: rate * dt, rate, ramp: null, settled: false };\n  if (dt >= ramp.left) {\n    const area = ((rate + ramp.to) / 2) * ramp.left + ramp.to * (dt - ramp.left);\n    return { area, rate: ramp.to, ramp: null, settled: true };\n  }\n  const next = rate + ((ramp.to - rate) * dt) / ramp.left;\n  return {\n    area: ((rate + next) / 2) * dt,\n    rate: next,\n    ramp: { to: ramp.to, left: ramp.left - dt },\n    settled: false,\n  };\n}\n","/** The speeds a transport offers by default, unsigned. */\nexport const CLOCK_RATES = [0.25, 0.5, 1, 2, 4] as const;\n","import { CLOCK_RATES } from './rates';\nimport type { ClockSpec } from './types';\n\nexport const checkDuration = (duration: number): void => {\n  if (!(duration > 0)) throw new RangeError(`a clock's duration is positive, not ${duration}`);\n};\n\nexport const ratesOf = (spec: ClockSpec): number[] => {\n  const rates = [...(spec.rates ?? CLOCK_RATES)].sort((a, b) => a - b);\n  if (rates.length === 0 || rates.some((r) => !(r > 0) || !Number.isFinite(r)))\n    throw new RangeError('a clock offers at least one rate, each finite and positive');\n  return rates;\n};\n\nexport const checkRate = (rate: number, seekable: boolean): void => {\n  if (!Number.isFinite(rate)) throw new RangeError(`a clock's rate is finite, not ${rate}`);\n  if (rate < 0 && !seekable)\n    throw new RangeError('a clock that is not seekable cannot run backward');\n};\n\nexport const checkSpeed = (speed: number): void => {\n  if (!(speed > 0) || !Number.isFinite(speed))\n    throw new RangeError(`a clock's speed is finite and positive, not ${speed}`);\n};\n\nexport const checkOrigin = (origin: number): void => {\n  if (!Number.isFinite(origin)) throw new RangeError(`a clock's origin is finite, not ${origin}`);\n};\n","import { createEmitter } from '@weasel-js/registry';\nimport { followMix } from './mixFollow';\nimport { passesOf, placeOf } from './place';\nimport { type Ramp, stepRamp } from './ramp';\nimport type { Clock, ClockHandle, ClockPosition, ClockSpec } from './types';\nimport { checkDuration, checkOrigin, checkRate, checkSpeed, ratesOf } from './validate';\n\n/** Where `clock` stands, for a record to reopen it at; `declared` is the\n *  duration its spec gave, and `declaredOrigin` the origin. */\nexport function clockPosition(\n  clock: Clock,\n  declared: number | undefined,\n  declaredOrigin = 0,\n): ClockPosition {\n  const duration = declared ?? Number.POSITIVE_INFINITY;\n  return {\n    elapsed: clock.elapsed,\n    rate: clock.rate,\n    ...(clock.duration !== duration ? { duration: clock.duration } : {}),\n    ...(clock.origin !== declaredOrigin ? { origin: clock.origin } : {}),\n    ...(clock.phase === 1 && !clock.ended ? { passEnd: true as const } : {}),\n  };\n}\n\n/** A clock's moving parts, read and written by the functions below. */\ninterface Run {\n  duration: number;\n  loop: boolean | number;\n  span: number;\n  origin: number;\n  speed: number;\n  rate: number;\n  elapsed: number;\n  edge: boolean;\n  ramp: Ramp | null;\n  last: number;\n  /** Changed since the last sync, so the next one is due even when paused. */\n  changed: boolean;\n  /** Inert as of the last sync: the next one only records the time. */\n  slept: boolean;\n  wakeFired: boolean;\n}\n\ninterface Hub {\n  wakes: ReturnType<typeof createEmitter>;\n  subs: ReturnType<typeof createEmitter>;\n  frames: ReturnType<typeof createEmitter<[elapsed: number, pass: number]>>;\n  follow: (elapsed: number) => void;\n  /** Where a new run opens. */\n  opening: () => number;\n}\n\nconst clamp = (run: Run, ms: number): number => Math.min(Math.max(0, ms), run.span);\nconst isInert = (run: Run): boolean => run.rate === 0 && run.ramp === null && !run.changed;\nconst passAt = (run: Run): number =>\n  placeOf(run.elapsed, run.duration, passesOf(run.loop), run.edge).pass;\nconst phaseAt = (run: Run): number =>\n  placeOf(run.elapsed, run.duration, passesOf(run.loop), run.edge).phase;\n/** The speed a transport plays a paused clock at, when none is declared. */\nconst restingSpeed = (rate: number): number => Math.abs(rate) || 1;\n\n/** Which pass `elapsed` falls in and how far into it, in ms; a pass's end stands as its own. */\nfunction passOf(run: Run): { pass: number; into: number } {\n  const { pass } = placeOf(run.elapsed, run.duration, passesOf(run.loop), run.edge);\n  return { pass, into: pass === 0 ? run.elapsed : run.elapsed - pass * run.duration };\n}\n\n/** Places `into` ms into pass `pass` of the run, the pass clamped to the run's last and\n *  `into` to the pass; a time on a boundary stands as the end of the pass before. */\nfunction placeIn(run: Run, pass: number, into: number): void {\n  const last = passesOf(run.loop) - 1;\n  const within = Math.min(Math.max(0, into), run.duration);\n  run.elapsed = clamp(run, Math.min(pass, last) * run.duration + within);\n  run.edge = run.elapsed > 0 && run.elapsed % run.duration === 0;\n}\n\nfunction change(run: Run, hub: Hub): void {\n  run.changed = true;\n  if (run.wakeFired) return;\n  run.wakeFired = true;\n  hub.wakes.emit();\n}\n\nfunction setDuration(run: Run, hub: Hub, next: number): void {\n  checkDuration(next);\n  if (next === run.duration) return;\n  if (Number.isFinite(run.duration) && Number.isFinite(next)) {\n    const ended = run.elapsed >= run.span;\n    const at = passAt(run) + phaseAt(run);\n    run.duration = next;\n    run.span = run.duration * passesOf(run.loop);\n    run.elapsed = ended ? run.span : clamp(run, at * run.duration);\n  } else {\n    run.duration = next;\n    run.span = run.duration * passesOf(run.loop);\n    run.elapsed = clamp(run, run.elapsed);\n  }\n  change(run, hub);\n  hub.subs.emit();\n}\n\n/** The four fields `declare` takes up, resolved. */\ninterface Declared {\n  duration: number;\n  origin: number;\n  loop: boolean | number;\n  speed: number;\n}\n\n/** A runtime replacement for the declared `duration` and `origin`; see `ClockHandle.override`. */\ntype SpanOverride = { duration?: number; origin?: number } | null;\n\nfunction declaredOf(run: Run, spec: ClockSpec): Declared {\n  return {\n    duration: spec.duration ?? Number.POSITIVE_INFINITY,\n    origin: spec.origin ?? 0,\n    loop: spec.loop ?? false,\n    speed: spec.speed ?? restingSpeed(run.rate),\n  };\n}\n\n/** Takes up `declared` with `override` laid over it, keeping the pass and the\n *  shown time within it, clamped. */\nfunction applyRun(run: Run, hub: Hub, declared: Declared, override: SpanOverride): void {\n  const duration = override?.duration ?? declared.duration;\n  const origin = override?.origin ?? declared.origin;\n  checkDuration(duration);\n  checkOrigin(origin);\n  checkSpeed(declared.speed);\n  const finite = Number.isFinite(run.duration) && Number.isFinite(duration);\n  const { pass, into } = finite ? passOf(run) : { pass: 0, into: run.elapsed };\n  const shown = run.origin + into;\n  run.duration = duration;\n  run.loop = declared.loop;\n  run.span = duration * passesOf(run.loop);\n  run.origin = origin;\n  run.speed = declared.speed;\n  if (Number.isFinite(duration)) placeIn(run, pass, shown - origin);\n  else {\n    run.elapsed = clamp(run, shown - origin);\n    run.edge = false;\n  }\n  change(run, hub);\n  hub.subs.emit();\n}\n\n/** ms of clock time over `dt` real ms, ramp included; settles the ramp. */\nfunction advance(run: Run, hub: Hub, dt: number): number {\n  const step = stepRamp(run.rate, run.ramp, dt);\n  run.rate = step.rate;\n  run.ramp = step.ramp;\n  if (step.settled) hub.subs.emit();\n  return step.area;\n}\n\nfunction syncTo(run: Run, hub: Hub, timestamp: number): void {\n  const wasChanged = run.changed;\n  const before = run.elapsed;\n  if (!Number.isNaN(run.last) && !run.slept) {\n    run.elapsed += advance(run, hub, Math.max(0, timestamp - run.last));\n    if (run.elapsed >= run.span && run.rate > 0) {\n      run.elapsed = run.span;\n      run.rate = 0;\n      run.ramp = null;\n      hub.subs.emit();\n    } else if (run.elapsed <= 0 && run.rate < 0) {\n      run.elapsed = 0;\n      run.rate = 0;\n      run.ramp = null;\n      hub.subs.emit();\n    }\n  }\n  run.last = timestamp;\n  run.changed = false;\n  run.wakeFired = false;\n  run.slept = isInert(run);\n  if (run.elapsed !== before) run.edge = false;\n  if (run.elapsed !== before || wasChanged) {\n    hub.follow(run.elapsed);\n    hub.frames.emit(run.elapsed, passAt(run));\n  }\n}\n\nfunction clockOf(run: Run, hub: Hub, seekable: boolean, rates: readonly number[]): Clock {\n  const clock: Clock = {\n    get elapsed() {\n      return run.elapsed;\n    },\n    get pass() {\n      return passAt(run);\n    },\n    get phase() {\n      return phaseAt(run);\n    },\n    get duration() {\n      return run.duration;\n    },\n    set duration(next: number) {\n      setDuration(run, hub, next);\n    },\n    get origin() {\n      return run.origin;\n    },\n    get speed() {\n      return run.speed;\n    },\n    rates,\n    seekable,\n    get ended() {\n      return Number.isFinite(run.span) && run.elapsed >= run.span;\n    },\n    get rate() {\n      return run.rate;\n    },\n    set rate(next: number) {\n      checkRate(next, seekable);\n      run.rate = next;\n      run.ramp = null;\n      change(run, hub);\n      hub.subs.emit();\n    },\n    get loop() {\n      return run.loop;\n    },\n    set loop(next: boolean | number) {\n      const { pass, into } = passOf(run);\n      run.loop = next;\n      run.span = run.duration * passesOf(run.loop);\n      if (run.elapsed > run.span) placeIn(run, pass, into);\n      change(run, hub);\n      hub.subs.emit();\n    },\n    ramp(to, over) {\n      checkRate(to, seekable);\n      if (!(over > 0)) {\n        clock.rate = to;\n        return;\n      }\n      run.ramp = { to, left: over };\n      change(run, hub);\n      hub.subs.emit();\n    },\n    seek(target, line = 'start') {\n      if (!seekable) throw new Error('this clock is not seekable');\n      run.elapsed = clamp(run, target);\n      run.edge = line === 'end';\n      change(run, hub);\n      hub.subs.emit();\n    },\n    sync: (timestamp) => syncTo(run, hub, timestamp),\n    rebase() {\n      run.last = Number.NaN;\n    },\n    get inert() {\n      return isInert(run);\n    },\n    onWake: hub.wakes.subscribe,\n    subscribe: hub.subs.subscribe,\n  };\n  return clock;\n}\n\n/** A clock, opened from its declaration and, for a run reopened, where it\n *  stood. */\nexport function createClock(spec: ClockSpec, at?: ClockPosition): ClockHandle {\n  const duration = at?.duration ?? spec.duration ?? Number.POSITIVE_INFINITY;\n  checkDuration(duration);\n  const seekable = spec.seekable ?? true;\n  const openRate = spec.rate ?? 0;\n  checkRate(openRate, seekable);\n  const rates = ratesOf(spec);\n\n  const origin = at?.origin ?? spec.origin ?? 0;\n  checkOrigin(origin);\n  if (spec.speed !== undefined) checkSpeed(spec.speed);\n  const loop = spec.loop ?? false;\n  const run: Run = {\n    duration,\n    loop,\n    span: duration * passesOf(loop),\n    origin,\n    speed: spec.speed ?? restingSpeed(openRate),\n    rate: at ? at.rate : openRate,\n    elapsed: 0,\n    edge: at?.passEnd ?? false,\n    ramp: null,\n    last: Number.NaN,\n    changed: false,\n    slept: false,\n    wakeFired: false,\n  };\n  const opening = (): number => {\n    if (spec.start !== 'end') return clamp(run, spec.start ?? 0);\n    if (!Number.isFinite(run.span))\n      throw new RangeError(\"a run that never ends has no 'end' to start at\");\n    return run.span;\n  };\n  run.elapsed = at ? clamp(run, at.elapsed) : opening();\n\n  const mix = spec.mix?.() ?? null;\n  const hub: Hub = {\n    wakes: createEmitter(),\n    subs: createEmitter(),\n    frames: createEmitter<[elapsed: number, pass: number]>(),\n    follow: followMix(mix),\n    opening,\n  };\n  const clock = clockOf(run, hub, seekable, rates);\n  hub.follow(run.elapsed);\n\n  let declared: Declared = {\n    duration: spec.duration ?? Number.POSITIVE_INFINITY,\n    origin: spec.origin ?? 0,\n    loop: run.loop,\n    speed: run.speed,\n  };\n  let override: SpanOverride = null;\n\n  return {\n    clock,\n    mix,\n    step: spec.step,\n    reset() {\n      run.elapsed = hub.opening();\n      run.edge = false;\n      run.rate = openRate;\n      run.ramp = null;\n      change(run, hub);\n      hub.subs.emit();\n    },\n    declare(next) {\n      const was = declared.loop;\n      declared = declaredOf(run, next);\n      // A declaration that keeps its loop leaves one set since, as a transport's toggle.\n      applyRun(run, hub, { ...declared, loop: declared.loop !== was ? declared.loop : run.loop }, override);\n    },\n    override(next) {\n      override = next ? { ...next } : null;\n      applyRun(run, hub, { ...declared, loop: run.loop }, override);\n    },\n    onFrame: hub.frames.subscribe,\n  };\n}\n","import { passesOf } from './place';\nimport type { Clock, ClockHandle, ClockPosition } from './types';\n\n/** The time a clock standing `elapsed` into a run of `loop` passes shows\n *  within its pass: a time on a pass boundary past the start shows as the end\n *  of the pass before, and one past the run's end runs on in its last pass. */\nexport function shownInPass(\n  origin: number,\n  elapsed: number,\n  duration: number,\n  loop: boolean | number = true,\n): number {\n  if (!Number.isFinite(duration)) return origin + elapsed;\n  const last = (passesOf(loop) - 1) * duration;\n  if (elapsed > last + duration) return origin + elapsed - last;\n  const into = elapsed % duration;\n  return origin + (into === 0 && elapsed > 0 ? duration : into);\n}\n\n/** A clock held at a time its span may not reach yet. */\nexport interface PlayheadHold {\n  /** The held time while the clock stands elsewhere (clamped), else null. */\n  pending(): number | null;\n  /** Stop holding. Idempotent. */\n  release(): void;\n}\n\n/**\n * Pauses `handle`'s clock at `shown`, a time shown within a pass (`null`: the\n * span's start), placed in the first pass, and keeps seeking there as `declare`\n * or a `duration` write moves the span. A time past the pass's end waits at it.\n * Any other change (a rate, a seek of someone else's) releases the hold. A\n * clock that is not seekable is never held.\n */\nexport function holdAt(handle: ClockHandle, shown: number | null): PlayheadHold {\n  return holdWhere(\n    handle,\n    (clock) => {\n      const within = Math.min(shown === null ? 0 : shown - clock.origin, clock.duration);\n      return [within, within > 0 && within === clock.duration ? 'end' : 'start'];\n    },\n    (clock) => (shown === null || clock.origin + clock.elapsed === shown ? null : shown),\n  );\n}\n\n/** A recorded position `holdElapsed` holds at. */\nexport type HeldPosition = Pick<ClockPosition, 'elapsed' | 'passEnd' | 'duration' | 'origin'>;\n\n/**\n * As {@link holdAt}, but at a recorded position across the whole run, so a\n * clock of several passes comes back in the pass it stood in. A position\n * recorded under another `duration` or `origin` keeps its pass and the time it\n * showed within it. `pending` reports the `elapsed` it holds for, on the\n * clock's current span.\n */\nexport function holdElapsed(handle: ClockHandle, at: HeldPosition): PlayheadHold {\n  return holdWhere(\n    handle,\n    (clock) => elapsedOn(clock, at),\n    (clock) => {\n      const [target] = elapsedOn(clock, at);\n      return clock.elapsed === target ? null : target;\n    },\n  );\n}\n\n/** Where `at` stands on `clock`'s span: the same pass, and the same time shown in it. */\nfunction elapsedOn(clock: Clock, at: HeldPosition): [elapsed: number, line: Line] {\n  const line: Line = at.passEnd ? 'end' : 'start';\n  const from = at.duration ?? clock.duration;\n  const origin = at.origin ?? clock.origin;\n  if (from === clock.duration && origin === clock.origin) return [at.elapsed, line];\n  if (!Number.isFinite(from) || !Number.isFinite(clock.duration))\n    return [at.elapsed + origin - clock.origin, line];\n  let pass = Math.floor(at.elapsed / from);\n  let into = at.elapsed - pass * from;\n  if (at.passEnd && into === 0 && pass > 0) {\n    pass -= 1;\n    into = from;\n  }\n  const within = Math.min(Math.max(0, origin + into - clock.origin), clock.duration);\n  const end = within > 0 && within === clock.duration;\n  return [pass * clock.duration + within, end ? 'end' : 'start'];\n}\n\ntype Line = 'start' | 'end';\n\nfunction holdWhere(\n  handle: ClockHandle,\n  where: (clock: Clock) => [elapsed: number, line: Line],\n  wanted: (clock: Clock) => number | null,\n): PlayheadHold {\n  const { clock } = handle;\n  let released = false;\n  let busy = false;\n  let unsub: (() => void) | null = null;\n  let duration = clock.duration;\n  let origin = clock.origin;\n  let loop = clock.loop;\n  let set = clock.elapsed;\n\n  const release = (): void => {\n    released = true;\n    unsub?.();\n    unsub = null;\n  };\n\n  const place = (): void => {\n    busy = true;\n    try {\n      clock.seek(...where(clock));\n    } finally {\n      busy = false;\n    }\n    duration = clock.duration;\n    origin = clock.origin;\n    loop = clock.loop;\n    set = clock.elapsed;\n  };\n\n  if (!clock.seekable) {\n    released = true;\n  } else {\n    clock.rate = 0;\n    place();\n    unsub = clock.subscribe(() => {\n      if (busy || released) return;\n      if (clock.rate !== 0) release();\n      else if (clock.duration !== duration || clock.origin !== origin || clock.loop !== loop) place();\n      else if (clock.elapsed !== set) release();\n    });\n  }\n\n  return {\n    pending: () => (released ? null : wanted(clock)),\n    release,\n  };\n}\n","import { createEmitter } from '@weasel-js/registry';\nimport type { ClockHandle } from './types';\n\n/** Resolves the view showing a clock: an `Element` where there is a DOM, and\n *  opaque to the registry, so its root entry needs no DOM. */\nexport type ClockTarget = () => object | null;\n\n/** A host's clocks: each run's, by id, and one shared among them. An id has at\n *  most one, and runs playing on the shared clock all hold that one. */\nexport interface ClockRegistry {\n  /** Publish `handle` under `id` and return its release. `target` names the\n   *  element showing it, resolved when read, so a ref filled later works. */\n  register(id: string, handle: ClockHandle, target?: ClockTarget): () => void;\n  get(id: string): ClockHandle | null;\n  /** The clock shared among the runs, when the host declares one. */\n  readonly shared: ClockHandle | null;\n  /** The elements showing `handle`, one per registration. Empty when any\n   *  registration named none, since that one may be seen anywhere. */\n  targets(handle: ClockHandle): readonly ClockTarget[];\n  /** Every clock once, however many ids hold it. */\n  all(): Iterable<ClockHandle>;\n  /** Fires after any register or release. Shaped for `useSyncExternalStore`. */\n  subscribe(listener: () => void): () => void;\n}\n\n/** An in-memory `ClockRegistry`, holding the shared clock when given one. */\nexport function createClockRegistry(shared: ClockHandle | null = null): ClockRegistry {\n  interface Entry {\n    handle: ClockHandle;\n    target: ClockTarget | undefined;\n  }\n  const entries = new Map<string, Entry>();\n  const changed = createEmitter();\n  const notify = changed.emit;\n  return {\n    register(id, handle, target) {\n      const entry: Entry = { handle, target };\n      entries.set(id, entry);\n      notify();\n      return () => {\n        if (entries.get(id) !== entry) return;\n        entries.delete(id);\n        notify();\n      };\n    },\n    get: (id) => entries.get(id)?.handle ?? null,\n    targets(handle) {\n      const found: ClockTarget[] = [];\n      for (const entry of entries.values()) {\n        if (entry.handle !== handle) continue;\n        if (!entry.target) return [];\n        found.push(entry.target);\n      }\n      return found;\n    },\n    shared,\n    all: () => new Set([...(shared ? [shared] : []), ...[...entries.values()].map((e) => e.handle)]),\n    subscribe: changed.subscribe,\n  };\n}\n"]}

package/dist/react.d.ts

@@ -0,0 +1,14 @@
+import { VisibleRafOptions } from '@weasel-js/react';
+import { d as ClockRegistry } from './registry-C2h_prHD.js';
+
+/**
+ * The one frame loop for every clock in a registry: syncs each clock that is not
+ * inert, and sleeps once every clock is, until one wakes. A clock registered with
+ * a target is skipped, and rebased, while every target of it is out of the
+ * viewport. Shaped like a blits `ticker`, so one could take its place.
+ *
+ * `options` supplies the frame clock, for tests.
+ */
+declare function useClockLoop(registry: ClockRegistry, options?: Pick<VisibleRafOptions, 'requestFrame' | 'cancelFrame'>): void;
+
+export { useClockLoop };

package/dist/react.js

@@ -0,0 +1,109 @@
+import { useVisibleRaf } from '@weasel-js/react';
+import { useRef, useEffect } from 'react';
+
+// src/useClockLoop.ts
+var entriesOf = (registry) => Array.from(registry.all(), (handle) => ({
+  handle,
+  shared: handle === registry.shared,
+  targets: registry.targets(handle)
+}));
+function outOfSight(entry, seen) {
+  if (entry.shared || entry.targets.length === 0) return false;
+  return entry.targets.every((target) => {
+    const el = target();
+    return el instanceof Element && seen.get(el) === false;
+  });
+}
+function syncObserved(entries, io, seen, named) {
+  if (!io) return;
+  named.clear();
+  for (const { targets } of entries) {
+    for (const target of targets) {
+      const el = target();
+      if (el instanceof Element) named.add(el);
+    }
+  }
+  for (const el of seen.keys()) {
+    if (named.has(el)) continue;
+    io.unobserve(el);
+    seen.delete(el);
+  }
+  for (const el of named) {
+    if (seen.has(el)) continue;
+    seen.set(el, true);
+    io.observe(el);
+  }
+}
+function useClockLoop(registry, options) {
+  const seen = useRef(/* @__PURE__ */ new Map());
+  const named = useRef(/* @__PURE__ */ new Set());
+  const observer = useRef(null);
+  const entries = useRef([]);
+  const loop = useVisibleRaf(
+    (timestamp, loop2) => {
+      syncObserved(entries.current, observer.current, seen.current, named.current);
+      let live = false;
+      for (const entry of entries.current) {
+        const { clock } = entry.handle;
+        if (outOfSight(entry, seen.current)) {
+          clock.rebase();
+          continue;
+        }
+        if (clock.inert) continue;
+        clock.sync(timestamp);
+        if (!clock.inert) live = true;
+      }
+      if (live) loop2.request();
+    },
+    {
+      ...options,
+      onResume: () => {
+        for (const { handle } of entries.current) handle.clock.rebase();
+      }
+    }
+  );
+  useEffect(() => {
+    const seenNow = seen.current;
+    if (typeof IntersectionObserver !== "undefined") {
+      observer.current = new IntersectionObserver((entries2) => {
+        let returned = false;
+        for (const entry of entries2) {
+          if (!seenNow.has(entry.target)) continue;
+          if (entry.isIntersecting && seenNow.get(entry.target) === false) returned = true;
+          seenNow.set(entry.target, entry.isIntersecting);
+        }
+        if (returned) loop.request();
+      });
+    }
+    return () => {
+      observer.current?.disconnect();
+      observer.current = null;
+      seenNow.clear();
+    };
+  }, [loop]);
+  useEffect(() => {
+    let unwakes = [];
+    const attach = () => {
+      for (const off2 of unwakes) off2();
+      unwakes = [];
+      entries.current = entriesOf(registry);
+      syncObserved(entries.current, observer.current, seen.current, named.current);
+      for (const { handle } of entries.current) {
+        const { clock } = handle;
+        unwakes.push(clock.onWake(() => loop.request()));
+        if (!clock.inert) loop.request();
+      }
+    };
+    attach();
+    const off = registry.subscribe(attach);
+    return () => {
+      off();
+      for (const unwake of unwakes) unwake();
+      entries.current = [];
+    };
+  }, [registry, loop]);
+}
+
+export { useClockLoop };
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/useClockLoop.ts"],"names":["loop","entries","off"],"mappings":"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","file":"react.js","sourcesContent":["import { useVisibleRaf, type VisibleRafOptions } from '@weasel-js/react';\nimport { useEffect, useRef } from 'react';\nimport type { ClockRegistry, ClockTarget } from './registry';\nimport type { ClockHandle } from './types';\n\n/** A clock the loop syncs, and the targets its registrations name, as of the\n *  registry's last change. */\ninterface Entry {\n  handle: ClockHandle;\n  shared: boolean;\n  targets: readonly ClockTarget[];\n}\n\nconst entriesOf = (registry: ClockRegistry): Entry[] =>\n  Array.from(registry.all(), (handle) => ({\n    handle,\n    shared: handle === registry.shared,\n    targets: registry.targets(handle),\n  }));\n\n/** Whether `entry`'s clock is out of sight: not the shared clock, every\n *  registration of it names an element, and none intersects the viewport. A\n *  target not yet resolved, not an element, or not yet reported counts as seen. */\nfunction outOfSight(entry: Entry, seen: ReadonlyMap<Element, boolean>): boolean {\n  if (entry.shared || entry.targets.length === 0) return false;\n  return entry.targets.every((target) => {\n    const el = target();\n    return el instanceof Element && seen.get(el) === false;\n  });\n}\n\n/** Has `io` observe every element a registration names, and lets go of the\n *  rest; `named` is scratch, reused across calls. */\nfunction syncObserved(\n  entries: readonly Entry[],\n  io: IntersectionObserver | null,\n  seen: Map<Element, boolean>,\n  named: Set<Element>,\n): void {\n  if (!io) return;\n  named.clear();\n  for (const { targets } of entries) {\n    for (const target of targets) {\n      const el = target();\n      if (el instanceof Element) named.add(el);\n    }\n  }\n  for (const el of seen.keys()) {\n    if (named.has(el)) continue;\n    io.unobserve(el);\n    seen.delete(el);\n  }\n  for (const el of named) {\n    if (seen.has(el)) continue;\n    seen.set(el, true);\n    io.observe(el);\n  }\n}\n\n/**\n * The one frame loop for every clock in a registry: syncs each clock that is not\n * inert, and sleeps once every clock is, until one wakes. A clock registered with\n * a target is skipped, and rebased, while every target of it is out of the\n * viewport. Shaped like a blits `ticker`, so one could take its place.\n *\n * `options` supplies the frame clock, for tests.\n */\nexport function useClockLoop(\n  registry: ClockRegistry,\n  options?: Pick<VisibleRafOptions, 'requestFrame' | 'cancelFrame'>,\n): void {\n  const seen = useRef(new Map<Element, boolean>());\n  const named = useRef(new Set<Element>());\n  const observer = useRef<IntersectionObserver | null>(null);\n  const entries = useRef<readonly Entry[]>([]);\n\n  const loop = useVisibleRaf(\n    (timestamp, loop) => {\n      syncObserved(entries.current, observer.current, seen.current, named.current);\n      let live = false;\n      for (const entry of entries.current) {\n        const { clock } = entry.handle;\n        if (outOfSight(entry, seen.current)) {\n          clock.rebase();\n          continue;\n        }\n        if (clock.inert) continue;\n        clock.sync(timestamp);\n        if (!clock.inert) live = true;\n      }\n      if (live) loop.request();\n    },\n    {\n      ...options,\n      onResume: () => {\n        for (const { handle } of entries.current) handle.clock.rebase();\n      },\n    },\n  );\n\n  useEffect(() => {\n    const seenNow = seen.current;\n    if (typeof IntersectionObserver !== 'undefined') {\n      observer.current = new IntersectionObserver((entries) => {\n        let returned = false;\n        for (const entry of entries) {\n          if (!seenNow.has(entry.target)) continue;\n          if (entry.isIntersecting && seenNow.get(entry.target) === false) returned = true;\n          seenNow.set(entry.target, entry.isIntersecting);\n        }\n        if (returned) loop.request();\n      });\n    }\n    return () => {\n      observer.current?.disconnect();\n      observer.current = null;\n      seenNow.clear();\n    };\n  }, [loop]);\n\n  useEffect(() => {\n    let unwakes: (() => void)[] = [];\n    const attach = (): void => {\n      for (const off of unwakes) off();\n      unwakes = [];\n      entries.current = entriesOf(registry);\n      syncObserved(entries.current, observer.current, seen.current, named.current);\n      for (const { handle } of entries.current) {\n        const { clock } = handle;\n        unwakes.push(clock.onWake(() => loop.request()));\n        if (!clock.inert) loop.request();\n      }\n    };\n    attach();\n    const off = registry.subscribe(attach);\n    return () => {\n      off();\n      for (const unwake of unwakes) unwake();\n      entries.current = [];\n    };\n  }, [registry, loop]);\n}\n"]}

package/dist/registry-C2h_prHD.d.ts

@@ -0,0 +1,155 @@
+/**
+ * What a caller declares to get a clock: how long a pass runs, how many
+ * passes, and how it opens. Shaped like a blits voice spec.
+ */
+interface ClockSpec {
+    /** ms per pass. Omitted, the run never ends. `Clock.duration` changes
+     *  it later, for a run whose length follows its content. */
+    duration?: number;
+    /** Passes: `true` endless, `false` one, `n` that many. Default `false`. */
+    loop?: boolean | number;
+    /** The rate it opens at; `0`, the default, opens paused. */
+    rate?: number;
+    /** Where a new run opens, in ms, clamped to the run; `'end'` is the end of
+     *  its last pass. Default `0`. A reopened run opens where it stood. */
+    start?: number | 'end';
+    /** The time `elapsed` 0 is shown as, in ms. Display only: nothing in the
+     *  run moves with it. Default `0`. */
+    origin?: number;
+    /** The unsigned speed a transport plays a paused clock at. Default `|rate|`,
+     *  or `1` for a clock that opens paused. */
+    speed?: number;
+    /** The speeds a transport offers, unsigned. Default `CLOCK_RATES`. */
+    rates?: readonly number[];
+    /** `false` for a clock whose state is built up by running, so time can
+     *  only move by running: no seek and no negative rate. Default `true`. */
+    seekable?: boolean;
+    /** ms a frame when the host runs the clock forward with nothing shown, which
+     *  is how a still of a clock that is not seekable reaches its time. Omitted,
+     *  such a still stays where the clock opens. */
+    step?: number;
+    /** Makes a blits mix, which then plays on this clock: its mix time is kept
+     *  at `elapsed`, synced forward and sought back, so scrubbing and reverse
+     *  reach it. Give it `history` with a `tape` reaching back over the whole
+     *  run, or a seek past it throws. Leave the mix's own `rate` alone; the
+     *  clock's is the one that plays. */
+    mix?: () => ClockedMix;
+}
+/** What a clock needs of a blits `Mix`. */
+interface ClockedMix {
+    sync(timestamp: number): void;
+    seek(time: number): void;
+    readonly now: number;
+}
+/**
+ * A run of time. A position (`elapsed`) moved by a signed `rate`, synced by a
+ * frame loop once a frame. Named after blits' owner handle and `Ticked`, so a
+ * blits ticker can drive one and blits voices can play under it.
+ */
+interface Clock {
+    /** ms the run has played, rate applied, counted across passes. */
+    readonly elapsed: number;
+    /** Which pass `elapsed` falls in, 0 first; the last once the run is over. */
+    readonly pass: number;
+    /** How far through its pass, 0 to 1; 1 once the run is over. 0 with no duration. */
+    readonly phase: number;
+    /** ms per pass; `Infinity` for a run that never ends. A write keeps `pass`
+     *  and `phase`, so the playhead holds its place in the content. */
+    duration: number;
+    /** The time `elapsed` 0 is shown as; display only. */
+    readonly origin: number;
+    /** The unsigned speed a transport plays a paused clock at. */
+    readonly speed: number;
+    /** The speeds a transport offers, unsigned and ascending. */
+    readonly rates: readonly number[];
+    /** Whether `seek` and a negative `rate` are allowed. */
+    readonly seekable: boolean;
+    /** A finite run has played to its end. */
+    readonly ended: boolean;
+    /** Signed: 0 pauses and a negative rate plays backward. A write changes speed
+     *  at once and replaces any ramp. */
+    rate: number;
+    /** Passes, as `ClockSpec.loop`. A write that shortens the run past `elapsed`
+     *  keeps the time within the pass, in the last pass left. */
+    loop: boolean | number;
+    /** Move `rate` to `to` linearly over `over` real ms; position stays continuous. */
+    ramp(to: number, over: number): void;
+    /** Move to `elapsed` ms from the start, clamped to the run. Never runs state
+     *  forward to meet it. Throws on a clock that is not seekable. A time on the
+     *  line between two passes is the start of the later one; `'end'` stands at
+     *  the end of the earlier, `phase` 1, until the clock next moves. */
+    seek(elapsed: number, line?: 'start' | 'end'): void;
+    /** The frame loop reports the time, once a frame. */
+    sync(timestamp: number): void;
+    /** The time between now and the next sync does not count. */
+    rebase(): void;
+    /** Another frame would change nothing: paused, no ramp, nothing changed since
+     *  the last sync. */
+    readonly inert: boolean;
+    /** Called when a change needs frames again, once until the next sync. */
+    onWake(fn: () => void): () => void;
+    /** Called on a rate, seek or loop change, and when the run ends; never per frame. */
+    subscribe(fn: () => void): () => void;
+}
+/** Where a clock stood, as a record keeps it. */
+interface ClockPosition {
+    elapsed: number;
+    rate: number;
+    /** Absent when the clock still ran at its declared duration. */
+    duration?: number;
+    /** Absent when the clock still showed its declared origin. */
+    origin?: number;
+    /** It stood at the end of a pass another follows, as `seek(…, 'end')` leaves it. */
+    passEnd?: true;
+}
+/** A clock, and what its host does with it. */
+interface ClockHandle {
+    clock: Clock;
+    /** The mix `ClockSpec.mix` made, playing on `clock`. */
+    mix: ClockedMix | null;
+    /** `ClockSpec.step`. */
+    step?: number | undefined;
+    /** Back to where it opened, at the declared rate — a Reset,
+     *  allowed on a clock that is not seekable. */
+    reset(): void;
+    /** Takes up `spec`'s `duration`, `origin` and `speed`, and its `loop` when
+     *  that differs from the last declaration's. Keeps the pass and the time
+     *  shown within it (`origin` plus ms into the pass), clamped to the new pass
+     *  and run; play state and rate are left alone. Notifies like a seek. Unlike
+     *  assigning `duration`, this does not keep `phase`. */
+    declare(spec: ClockSpec): void;
+    /** Replaces the declared `duration` and `origin` with `span`'s, where it
+     *  gives them, until called with `null`; a later `declare` changes what lies
+     *  under it, not the override. Keeps the pass and shown time like `declare`. */
+    override(span: {
+        duration?: number;
+        origin?: number;
+    } | null): void;
+    /** Called after each sync that moved the clock or followed a change. */
+    onFrame(fn: (elapsed: number, pass: number) => void): () => void;
+}
+
+/** Resolves the view showing a clock: an `Element` where there is a DOM, and
+ *  opaque to the registry, so its root entry needs no DOM. */
+type ClockTarget = () => object | null;
+/** A host's clocks: each run's, by id, and one shared among them. An id has at
+ *  most one, and runs playing on the shared clock all hold that one. */
+interface ClockRegistry {
+    /** Publish `handle` under `id` and return its release. `target` names the
+     *  element showing it, resolved when read, so a ref filled later works. */
+    register(id: string, handle: ClockHandle, target?: ClockTarget): () => void;
+    get(id: string): ClockHandle | null;
+    /** The clock shared among the runs, when the host declares one. */
+    readonly shared: ClockHandle | null;
+    /** The elements showing `handle`, one per registration. Empty when any
+     *  registration named none, since that one may be seen anywhere. */
+    targets(handle: ClockHandle): readonly ClockTarget[];
+    /** Every clock once, however many ids hold it. */
+    all(): Iterable<ClockHandle>;
+    /** Fires after any register or release. Shaped for `useSyncExternalStore`. */
+    subscribe(listener: () => void): () => void;
+}
+/** An in-memory `ClockRegistry`, holding the shared clock when given one. */
+declare function createClockRegistry(shared?: ClockHandle | null): ClockRegistry;
+
+export { type Clock as C, type ClockPosition as a, type ClockSpec as b, type ClockHandle as c, type ClockRegistry as d, type ClockTarget as e, type ClockedMix as f, createClockRegistry as g };

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "@weasel-js/clock",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.13.0",
+  "description": "A clock for a run of time: a position moved by a signed rate, with passes, ramps and seeking. The root entry has no React and no DOM.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./react": {
+      "import": "./dist/react.js",
+      "types": "./dist/react.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@weasel-js/react": "1.13.0",
+    "@weasel-js/registry": "1.13.0"
+  },
+  "devDependencies": {
+    "@msb235/blits": "0.12.0",
+    "@weasel-js/history": "1.13.0"
+  },
+  "author": "orochi235",
+  "homepage": "https://orochi235.github.io/weasel/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/orochi235/weasel.git",
+    "directory": "packages/clock"
+  },
+  "bugs": {
+    "url": "https://github.com/orochi235/weasel/issues"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}