bireactive 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Orion Reed
+
+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

@@ -0,0 +1,81 @@
+# bireactive
+
+Reactive programming where edges can go both ways. Write to an input and
+everything derived from it updates; write the *derived* value and the input
+adjusts to match. Forward and backward propagation are handled by the engine, with the same set of caveats as regular reactive programming.
+
+## Install
+
+```sh
+npm install bireactive
+```
+
+Runtime dependencies [`temml`](https://temml.org) (for `tex`) and
+[`prism-esm`](https://github.com/orionhealthotago/prism-esm) (for `code`) are
+installed automatically. They may be split into separate packages later so the
+core stays dependency-free.
+
+## Sketch
+
+```ts
+import { cell } from "bireactive";
+
+// A derived value with an inverse — the edge runs both ways.
+const celsius = cell(20);
+const fahrenheit = celsius.lens(
+  c => (c * 9) / 5 + 32, // forward
+  f => ((f - 32) * 5) / 9, // backward
+);
+
+fahrenheit.value; // 68
+fahrenheit.value = 212; // write the derived end…
+celsius.value; // 100 — …and the source updates to match
+```
+
+Values also come as small classes (`Num`, `Vec`, `Box`, `Color`, ...) with field
+lenses and bidirectional operators.
+
+```ts
+import { vec, box, midpointLens } from "bireactive";
+
+// Free-function lens: the midpoint of two points, writable.
+const a = vec(0, 0);
+const b = vec(10, 0);
+const mid = midpointLens(a, b);
+mid.value = { x: 5, y: 10 }; // drag it up…
+a.value; // { x: 0, y: 10 } — both ends translate to keep it the midpoint
+
+// Chaining value-class operators builds a multi-step writable view.
+const p = vec(10, 20);
+const view = p.scale(2).right(5); // ×2, then shift +5 in x
+view.value; // { x: 25, y: 40 }
+view.value = { x: 5, y: 0 }; // write the end of the chain…
+p.value; // { x: 0, y: 0 } — inverted back through right, then scale
+
+// Cross-type lens: a Box/Vec relation projected to Bool, still writable.
+const region = box(0, 0, 100, 100); // x, y, w, h
+const q = vec(150, 50); // outside the box
+const inside = region.contains(q); // Bool view of "q ∈ region"
+inside.value; // false
+inside.value = true; // assert membership…
+q.value; // { x: 100, y: 50 } — q snaps to the nearest in-box point
+```
+
+## Develop
+
+```sh
+npm run dev        # serve the landing page at :5555
+npm run site       # build the static site into dist-web/
+npm run build      # compile the library into dist/
+npm test           # run the test suite
+```
+
+## Status
+
+`0.x` — APIs are still moving. The package is a single bundle today;
+sub-packages (`@bireactive/core`, `@bireactive/animation`, `@bireactive/shapes`, …) are used
+internally as path aliases and will be split out once the surface settles.
+
+## License
+
+MIT

package/dist/animation/anim.d.ts

@@ -0,0 +1,57 @@
+export interface Tick {
+    readonly dt: number;
+    readonly elapsed: number;
+}
+export type Yieldable = undefined | number | Animator<any> | readonly Yieldable[] | Suspend<any>;
+export type Animator<R = void> = Generator<Yieldable, R, Tick>;
+export type Suspend<T = void> = (wake: Wake<T>, 
+/** Spawn `g` at engine root, returning a cancel handle. **/
+spawn: (g: Animator<any>) => () => void) => void | (() => void);
+export type Resume<Y> = Y extends Animator<infer R> ? R : Y extends Suspend<infer R> ? R : void;
+export type Cut<T> = {
+    readonly [CUT_KEY]: T;
+};
+/** Cut sentinel — return `cut(v)` from a concurrent kid to settle the
+ *  enclosing group with `v` and cancel siblings. Outside a group, the
+ *  sentinel is transparently unwrapped to `v`. */
+export declare const cut: <T>(value: T) => Cut<T>;
+/** True if `v` is a Generator (duck-typed via `.next`). */
+export declare const isGenerator: (v: unknown) => v is Animator;
+export declare class Anim {
+    #private;
+    private actives;
+    private deads;
+    /** Re-entry guard: nested `step()` throws. start/stop/cancel stay legal
+     *  (they only mutate `actives`, handled via index + skip-checks). */
+    private stepping;
+    private stepListeners;
+    private onError;
+    get clock(): number;
+    constructor(opts?: {
+        onError?: (e: unknown) => void;
+    });
+    /** Spawn root-level actives; the returned handle cancels all. (Inside
+     *  a gen, `yield [a, b]` instead for a joined, cascading-cancel group.) */
+    start(...gs: Animator<any>[]): () => void;
+    /** Fire `cb(dt)` after every successful `step()` completes. */
+    onStep(cb: (dt: number) => void): () => void;
+    stop(): void;
+    step(dt: number): void;
+    private stepInner;
+    private spawn;
+    private cancel;
+    private settle;
+    private safe;
+    private compact;
+    private advance;
+    private suspend;
+    /** Park `a` and spawn `gen` as its child; resume `a` with the
+     *  child's return value (or error) on settle. */
+    private awaitChild;
+    private concurrent;
+}
+declare const CUT_KEY: unique symbol;
+type Wake<T = void> = ([T] extends [void] ? () => void : (value: T) => void) & {
+    throw(error: unknown): void;
+};
+export {};

package/dist/animation/anim.js

@@ -0,0 +1,318 @@
+//   Yield contract:
+//   undefined       park 1 frame
+//   number > 0      sleep N seconds
+//   Animator        spawn child, await its return value
+//   Suspend         callback-wake `(wake, spawn) => dispose`
+//   Yieldable[]     run concurrently; resume with results[]
+//
+//   Resume values are either:
+//   Tick, a { dt: number, elapsed: number } object
+//   Example: `const { dt } = yield;`
+//
+//   T (generic), if the suspend is `(wake, spawn) => T`
+//   Example: `const result = yield (wake, spawn) => { ... }`
+/** Cut sentinel — return `cut(v)` from a concurrent kid to settle the
+ *  enclosing group with `v` and cancel siblings. Outside a group, the
+ *  sentinel is transparently unwrapped to `v`. */
+export const cut = (value) => ({ [CUT_KEY]: value });
+/** True if `v` is a Generator (duck-typed via `.next`). */
+export const isGenerator = (v) => v !== null && typeof v === "object" && typeof v.next === "function";
+export class Anim {
+    actives = [];
+    deads = 0;
+    /** Re-entry guard: nested `step()` throws. start/stop/cancel stay legal
+     *  (they only mutate `actives`, handled via index + skip-checks). */
+    stepping = false;
+    stepListeners = null;
+    onError;
+    #clock = 0;
+    get clock() {
+        return this.#clock;
+    }
+    constructor(opts = {}) {
+        this.onError = opts.onError ?? (e => console.error("bireactive:", e));
+    }
+    /** Spawn root-level actives; the returned handle cancels all. (Inside
+     *  a gen, `yield [a, b]` instead for a joined, cascading-cancel group.) */
+    start(...gs) {
+        if (gs.length === 0)
+            return () => { };
+        const actives = gs.map(g => this.spawn(g, null, null));
+        return () => {
+            for (const a of actives)
+                this.cancel(a);
+        };
+    }
+    /** Fire `cb(dt)` after every successful `step()` completes. */
+    onStep(cb) {
+        (this.stepListeners ??= new Set()).add(cb);
+        return () => {
+            this.stepListeners?.delete(cb);
+        };
+    }
+    stop() {
+        const snap = this.actives.slice();
+        this.actives.length = 0;
+        for (const a of snap)
+            this.cancel(a);
+    }
+    step(dt) {
+        if (this.stepping) {
+            throw new Error("bireactive: re-entrant step() is not supported");
+        }
+        this.stepping = true;
+        try {
+            this.stepInner(dt);
+        }
+        finally {
+            this.stepping = false;
+        }
+        if (this.stepListeners) {
+            for (const cb of this.stepListeners) {
+                try {
+                    cb(dt);
+                }
+                catch (e) {
+                    this.onError(e);
+                }
+            }
+        }
+    }
+    stepInner(dt) {
+        if (dt > 0 && Number.isFinite(dt))
+            this.#clock += dt;
+        const as = this.actives;
+        const alen = as.length;
+        const d0 = this.deads;
+        for (let i = 0; i < alen; i++) {
+            const a = as[i];
+            if (!a || a.wakeAt === DEAD || a.wakeAt === PARKED)
+                continue;
+            if (dt > 0)
+                a.localClock += dt;
+            if (a.wakeAt <= a.localClock) {
+                const saved = a.wakeAt;
+                a.wakeAt = READY;
+                // Sub-frame: only the time since the wake threshold is "owed".
+                const dtEff = saved > 0 ? Math.min(dt, a.localClock - saved) : dt;
+                const tick = { dt: dtEff, elapsed: a.localClock };
+                this.advance(a, tick, false);
+            }
+        }
+        if (this.deads !== d0)
+            this.compact();
+    }
+    spawn(gen, parent, onSettle) {
+        const a = new Active(gen);
+        a.onSettle = onSettle;
+        a.localClock = parent ? parent.localClock : 0;
+        this.actives.push(a);
+        this.advance(a, undefined, false);
+        return a;
+    }
+    cancel(a) {
+        if (a.wakeAt === DEAD)
+            return;
+        a.wakeAt = DEAD;
+        this.deads++;
+        const c = a.cleanup;
+        a.cleanup = null;
+        a.onSettle = null;
+        this.safe(c);
+        try {
+            a.gen.return(undefined);
+        }
+        catch (e) {
+            this.onError(e);
+        }
+    }
+    settle(a, value, errored, error) {
+        if (a.wakeAt === DEAD)
+            return;
+        a.wakeAt = DEAD;
+        this.deads++;
+        const cb = a.onSettle;
+        a.onSettle = null;
+        if (cb)
+            cb(errored ? undefined : value, errored ? error : undefined);
+        else if (errored)
+            this.onError(error);
+    }
+    safe(fn) {
+        if (!fn)
+            return;
+        try {
+            fn();
+        }
+        catch (e) {
+            this.onError(e);
+        }
+    }
+    compact() {
+        const as = this.actives;
+        let w = 0;
+        for (let i = 0; i < as.length; i++)
+            if (as[i].wakeAt !== DEAD)
+                as[w++] = as[i];
+        as.length = w;
+        this.deads = 0;
+    }
+    advance(a, payload, asThrow) {
+        try {
+            const r = asThrow ? a.gen.throw(payload) : a.gen.next(payload);
+            while (!r.done) {
+                if (a.wakeAt === DEAD)
+                    return;
+                const v = r.value;
+                if (v === undefined)
+                    return; // park 1 frame
+                if (typeof v === "number") {
+                    // `yield N <= 0` parks (semantic alignment with `yield`).
+                    if (v > 0)
+                        a.wakeAt = a.localClock + v;
+                    return;
+                }
+                if (typeof v === "function")
+                    return this.suspend(a, v);
+                if (Array.isArray(v))
+                    return this.concurrent(a, v);
+                if (isGenerator(v))
+                    return this.awaitChild(a, v);
+                throw new TypeError(`anim: unsupported yield (${describe(v)})`);
+            }
+            this.settle(a, r.value, false, undefined);
+        }
+        catch (e) {
+            this.settle(a, undefined, true, e);
+        }
+    }
+    suspend(a, impl) {
+        let resumed = false;
+        const finish = (action) => {
+            if (resumed || a.wakeAt === DEAD)
+                return;
+            resumed = true;
+            const c = a.cleanup;
+            a.cleanup = null;
+            a.wakeAt = READY;
+            this.safe(c);
+            action();
+        };
+        const wake = ((v) => finish(() => this.advance(a, unwrapCut(v), false)));
+        wake.throw = (e) => finish(() => this.advance(a, e, true));
+        const spawn = (g) => {
+            const child = this.spawn(g, null, null);
+            return () => this.cancel(child);
+        };
+        let dispose;
+        try {
+            dispose = impl(wake, spawn) ?? undefined;
+        }
+        catch (e) {
+            if (!resumed && a.wakeAt !== DEAD) {
+                resumed = true;
+                this.advance(a, e, true);
+            }
+            else
+                this.onError(e);
+            return;
+        }
+        if (resumed || a.wakeAt === DEAD)
+            this.safe(dispose);
+        else {
+            a.wakeAt = PARKED;
+            a.cleanup = dispose ?? null;
+        }
+    }
+    /** Park `a` and spawn `gen` as its child; resume `a` with the
+     *  child's return value (or error) on settle. */
+    awaitChild(a, gen) {
+        a.wakeAt = PARKED;
+        let c = null;
+        a.cleanup = () => {
+            if (c && c.wakeAt !== DEAD)
+                this.cancel(c);
+        };
+        c = this.spawn(gen, a, (v, err) => {
+            if (a.wakeAt === DEAD || a.cleanup === null)
+                return;
+            a.cleanup = null;
+            a.wakeAt = READY;
+            this.advance(a, err === undefined ? unwrapCut(v) : err, err !== undefined);
+        });
+    }
+    concurrent(a, kids) {
+        if (kids.length === 0)
+            return this.advance(a, [], false);
+        const children = [];
+        const results = new Array(kids.length);
+        let left = kids.length;
+        let aborted = false;
+        a.wakeAt = PARKED;
+        a.cleanup = () => {
+            aborted = true;
+            for (const c of children)
+                if (c.wakeAt !== DEAD)
+                    this.cancel(c);
+        };
+        const settle = (v, asThrow, cancelSibs) => {
+            if (aborted)
+                return;
+            aborted = true;
+            a.cleanup = null;
+            a.wakeAt = READY;
+            if (cancelSibs)
+                for (const c of children)
+                    if (c.wakeAt !== DEAD)
+                        this.cancel(c);
+            this.advance(a, v, asThrow);
+        };
+        for (let j = 0; j < kids.length; j++) {
+            if (aborted)
+                return;
+            const k = kids[j];
+            const idx = j;
+            const kidGen = isGenerator(k) ? k : asGen(k);
+            children.push(this.spawn(kidGen, a, (value, error) => {
+                if (aborted)
+                    return;
+                if (error !== undefined)
+                    return settle(error, true, true);
+                if (isCut(value))
+                    return settle(value[CUT_KEY], false, true);
+                results[idx] = value;
+                if (--left === 0)
+                    settle(results, false, false);
+            }));
+        }
+    }
+}
+const DEAD = Number.NEGATIVE_INFINITY;
+const READY = 0;
+const PARKED = Number.POSITIVE_INFINITY;
+const CUT_KEY = Symbol("cut");
+const isCut = (v) => v !== null && typeof v === "object" && CUT_KEY in v;
+const unwrapCut = (v) => (isCut(v) ? v[CUT_KEY] : v);
+class Active {
+    gen;
+    /** READY (0) | PARKED (Inf) | DEAD (-Inf) | positive sleep target. */
+    wakeAt = READY;
+    /** Per-active subjective clock — advances by engine dt each step.
+     *  Inherited from parent on spawn, then advances independently. */
+    localClock = 0;
+    cleanup = null;
+    onSettle = null;
+    constructor(gen) {
+        this.gen = gen;
+    }
+}
+function* asGen(y) {
+    yield y;
+}
+function describe(v) {
+    if (v === null)
+        return "null";
+    if (typeof v !== "object")
+        return String(v);
+    return v.constructor?.name ?? "object";
+}

package/dist/animation/combinators.d.ts

@@ -0,0 +1,39 @@
+import { type Animator, type Cut, type Resume, type Suspend, type Tick, type Yieldable } from "./anim.js";
+/** Park each frame until `cb` returns `false`. `t` is elapsed since the
+ *  first call (sampled from `tick.elapsed` — no float accumulation). */
+export declare function drive(cb: (tick: Tick, t: number) => boolean | void): Animator<void>;
+/** Park until `wake(value)`; resume with the typed value. */
+export declare function suspend<T = void>(impl: Suspend<T>): Animator<T>;
+/** Wait for a DOM event on `target`; resume with the event. */
+export declare function untilEvent<E extends Event = Event>(target: EventTarget, name: string, opts?: AddEventListenerOptions): Animator<E>;
+/** Wait for a promise; resume with its value (rejection → `gen.throw`). */
+export declare function untilPromise<T>(p: PromiseLike<T>): Animator<T>;
+/** Wrap a Yieldable so it cuts its enclosing group with its result. */
+export declare function commit<T>(k: Yieldable): Animator<Cut<T>>;
+/** Run children in parallel; resume with a typed tuple of return values. */
+export declare function all<Cs extends readonly Yieldable[]>(...children: Cs): Animator<{
+    [K in keyof Cs]: Resume<Cs[K]>;
+}>;
+/** First-completion race; resume with the winner's payload. */
+export declare function race<Cs extends readonly Yieldable[]>(...children: Cs): Animator<Resume<Cs[number]>>;
+/** First N completions win; resume with their values in completion order. */
+export declare function firstN<R>(n: number, kids: readonly Yieldable[]): Animator<R[]>;
+/** First kid whose value matches `pred` cuts the group with it;
+ *  otherwise settles with the full results array. */
+export declare function firstMatching<R>(pred: (v: R) => boolean, kids: readonly Yieldable[]): Animator<R | R[]>;
+/** First kid to resolve wins; all-throw → `AggregateError` (~ `Promise.any`). */
+export declare function anySuccess<R>(...kids: readonly Yieldable[]): Animator<R>;
+/** Run every kid; collect results and errors. Never throws. */
+export type Settled<R> = {
+    readonly ok: true;
+    readonly value: R;
+} | {
+    readonly ok: false;
+    readonly error: unknown;
+};
+export declare function allSettled<R>(...kids: readonly Yieldable[]): Animator<Settled<R>[]>;
+/** Pick one child uniformly at random and run it; others never advance. */
+export declare function rand(...children: Animator[]): Animator;
+/** Spawn `g` at engine root, resume parent immediately. Detached child
+ *  outlives the spawning parent (survives parent cancel; dies on engine.stop()). */
+export declare function detach<R>(g: Animator<R>): Animator<void>;

package/dist/animation/combinators.js

@@ -0,0 +1,113 @@
+// Cell-free combinators over `Anim`. Concurrency rules are expressed
+// per-kid via `cut(v)` — no engine-side strategy abstraction.
+import { cut, } from "./anim.js";
+/** Park each frame until `cb` returns `false`. `t` is elapsed since the
+ *  first call (sampled from `tick.elapsed` — no float accumulation). */
+export function* drive(cb) {
+    let startElapsed = Number.NaN;
+    while (true) {
+        const tick = yield;
+        if (startElapsed !== startElapsed)
+            startElapsed = tick.elapsed - tick.dt;
+        if (cb(tick, tick.elapsed - startElapsed) === false)
+            return;
+    }
+}
+/** Park until `wake(value)`; resume with the typed value. */
+export function* suspend(impl) {
+    return (yield impl);
+}
+/** Wait for a DOM event on `target`; resume with the event. */
+export function untilEvent(target, name, opts) {
+    return suspend(wake => {
+        const handler = (e) => wake(e);
+        target.addEventListener(name, handler, opts);
+        return () => target.removeEventListener(name, handler, opts);
+    });
+}
+/** Wait for a promise; resume with its value (rejection → `gen.throw`). */
+export function untilPromise(p) {
+    return suspend(wake => {
+        let cancelled = false;
+        p.then(v => {
+            if (!cancelled)
+                wake(v);
+        }, e => {
+            if (!cancelled)
+                wake.throw(e);
+        });
+        return () => {
+            cancelled = true;
+        };
+    });
+}
+/** Wrap a Yieldable so it cuts its enclosing group with its result. */
+export function* commit(k) {
+    return cut((yield k));
+}
+/** Run children in parallel; resume with a typed tuple of return values. */
+export function* all(...children) {
+    return (yield children);
+}
+/** First-completion race; resume with the winner's payload. */
+export function* race(...children) {
+    return (yield children.map(c => commit(c)));
+}
+/** First N completions win; resume with their values in completion order. */
+export function* firstN(n, kids) {
+    const collected = [];
+    return (yield kids.map(k => (function* () {
+        const v = (yield k);
+        collected.push(v);
+        return collected.length >= n ? cut(collected) : v;
+    })()));
+}
+/** First kid whose value matches `pred` cuts the group with it;
+ *  otherwise settles with the full results array. */
+export function* firstMatching(pred, kids) {
+    return (yield kids.map(k => (function* () {
+        const v = (yield k);
+        return pred(v) ? cut(v) : v;
+    })()));
+}
+/** First kid to resolve wins; all-throw → `AggregateError` (~ `Promise.any`). */
+export function* anySuccess(...kids) {
+    const errors = [];
+    return (yield kids.map(k => (function* () {
+        try {
+            return cut((yield k));
+        }
+        catch (e) {
+            errors.push(e);
+            if (errors.length === kids.length) {
+                throw new AggregateError(errors, "anySuccess: all kids failed");
+            }
+            return undefined;
+        }
+    })()));
+}
+export function* allSettled(...kids) {
+    return (yield kids.map(k => (function* () {
+        try {
+            return { ok: true, value: (yield k) };
+        }
+        catch (e) {
+            return { ok: false, error: e };
+        }
+    })()));
+}
+/** Pick one child uniformly at random and run it; others never advance. */
+export function* rand(...children) {
+    if (children.length === 0)
+        return;
+    const i = Math.floor(Math.random() * children.length);
+    yield* children[i];
+}
+/** Spawn `g` at engine root, resume parent immediately. Detached child
+ *  outlives the spawning parent (survives parent cancel; dies on engine.stop()). */
+export function* detach(g) {
+    yield (wake, spawn) => {
+        spawn(g);
+        wake();
+    };
+}

package/dist/animation/easings.d.ts

@@ -0,0 +1,5 @@
+export type Easing = (t: number) => number;
+export declare const linear: Easing;
+export declare const easeIn: Easing;
+export declare const easeOut: Easing;
+export declare const easeInOut: Easing;

package/dist/animation/easings.js

@@ -0,0 +1,5 @@
+// Easing curves — pure (t: number) => number.
+export const linear = t => t;
+export const easeIn = t => t * t;
+export const easeOut = t => 1 - (1 - t) * (1 - t);
+export const easeInOut = t => (t < 0.5 ? 2 * t * t : 1 - 2 * (1 - t) * (1 - t));

package/dist/animation/index.d.ts

@@ -0,0 +1,3 @@
+export { Anim, type Animator, type Cut, cut, isGenerator, type Resume, type Suspend, type Tick, type Yieldable, } from "./anim.js";
+export { all, allSettled, anySuccess, commit, detach, drive, firstMatching, firstN, race, rand, type Settled, suspend, untilEvent, untilPromise, } from "./combinators.js";
+export { type Easing, easeIn, easeInOut, easeOut, linear } from "./easings.js";

package/dist/animation/index.js

@@ -0,0 +1,3 @@
+export { Anim, cut, isGenerator, } from "./anim.js";
+export { all, allSettled, anySuccess, commit, detach, drive, firstMatching, firstN, race, rand, suspend, untilEvent, untilPromise, } from "./combinators.js";
+export { easeIn, easeInOut, easeOut, linear } from "./easings.js";

package/dist/assert/algebra.d.ts

@@ -0,0 +1,20 @@
+import { type Read } from "../core/index.js";
+import type { Scoped } from "./scope.js";
+import type { Span } from "./span.js";
+/** Anything an interval can be derived from. */
+export type Scope = Scoped<any> | Span | Read<boolean>;
+/** "Is this scope open right now?" Spans → one-shot interval; scoped
+ *  factories → "any open invocation"; bool signals pass through. */
+export declare function intervals(s: Scope): Read<boolean>;
+/** Always-true scope; useful as a default when no scope is given. */
+export declare function always(): Read<boolean>;
+/** Latch a predicate. Holds at `init` until `pred` is observed `!init`
+ *  within `scope`, then flips and stays; re-arms on each `scope` rising
+ *  edge. Outside `scope`, `pred` isn't consulted (latch holds). */
+export declare function latch(pred: Read<boolean>, init: boolean, scope?: Read<boolean>): Read<boolean>;
+/** First false→true edge wins. Returns `{ first, at }` (winner index +
+ *  recorder-clock time), or undefined until one fires. Sticky once decided. */
+export declare function firstOf(...events: Read<boolean>[]): Read<{
+    first: number;
+    at: number;
+} | undefined>;