@demlik/tea 0.12.0 → 0.14.0

package/dist/subs/index.d.ts

@@ -1,471 +0,0 @@
-import { S as Sub, a as Port, e as Dispose, D as DepKeyedSub, b as SubId } from '../core-Bjc0bS8j.js';
-import { S as SubscribeHandler } from '../types-D7u9DkH7.js';
-import { R as Runtime } from '../runtime-types-Bxc637bp.js';
-import 'better-result';
-
-/**
- * The imperative listener target, expressed as the `add`/`remove` pair the
- * substrate pairs into a reconciled resource. Both halves receive the SAME
- * `listener` reference — the substrate builds it once — so `remove` can never
- * be handed a different function than `add` saw.
- *
- * `add`/`remove` also receive `(sub, ctx)` so the target may be resolved from
- * `ctx` (a runtime, a port, a DOM node looked up lazily) or keyed on the Sub
- * (an alarm name, a channel name). Resolving the target inside `add` and
- * closing over nothing but the listener keeps a target swap from leaking the
- * old target's listener — same rationale as `fromEventTarget`'s captured
- * target.
- *
- * `Args` is the tuple the platform invokes the listener with — `[Alarm]` for
- * `chrome.alarms.onAlarm`, `[message, sender, sendResponse]` for
- * `chrome.runtime.onMessage`, `[changes, areaName]` for
- * `chrome.storage.onChanged`. The substrate builds ONE function of this exact
- * shape and threads the IDENTICAL reference to both `add` and `remove` — so a
- * platform that matches `removeListener` by reference (every chrome surface)
- * removes exactly what it added. A consumer that wrapped the listener inside
- * `add` would break reference identity (leak #2 above); carrying the native
- * `Args` on the listener itself removes the need for any wrapper.
- */
-interface ListenerTarget<Args extends readonly unknown[], S extends Sub, Ctx> {
-    add: (listener: (...args: Args) => void, sub: S, ctx: Ctx) => void;
-    remove: (listener: (...args: Args) => void, sub: S, ctx: Ctx) => void;
-}
-/**
- * Build a listener-backed Sub factory whose cleanup is mandatory and derived.
- *
- * `Args`, `S`, `Ctx` are fixed when the target is defined — they describe the
- * one listener topology this factory owns (the platform arg tuple, which Sub
- * shape it filters on, what context resolves it). `M` is supplied at the
- * subscribe cell because the same listener feeds different Msgs in different
- * machines. Pinning `S` here (rather than at the `msgFn` step) lets
- * `add`/`remove` read the concrete Sub's fields — `sub.alarmName`,
- * `sub.channel` — with NO cast at the substrate edge: the narrowing happens in
- * author-land where the Sub shape is in scope.
- *
- * The returned function is a `SubscribeHandler` factory in the exact shape of
- * every other `@demlik/tea/subs` battery: supply the `msgFn` projection, get a
- * `(sub, ctx, dispatch) => cleanup` handler assignable to `machine.subscribe`.
- * The cleanup the author NEVER writes is `() => remove(listener, sub, ctx)`,
- * with `listener` the identical reference passed to `add`.
- */
-declare function defineListener<Args extends readonly unknown[], S extends Sub = Sub, Ctx = unknown>(target: ListenerTarget<Args, S, Ctx>): <M>(msgFn: (sub: S, ...args: Args) => M | null) => SubscribeHandler<S, M, Ctx>;
-
-interface MinimalEvent {
-    readonly type: string;
-}
-interface MinimalMessageEvent extends MinimalEvent {
-    readonly data: unknown;
-}
-interface MinimalEventTarget {
-    addEventListener(type: string, listener: (event: MinimalEvent) => void): void;
-    removeEventListener(type: string, listener: (event: MinimalEvent) => void): void;
-}
-interface MinimalCloseEvent extends MinimalEvent {
-    readonly code: number;
-    readonly reason: string;
-}
-interface MinimalWebSocket {
-    close(code?: number, reason?: string): void;
-    onopen: ((event: MinimalEvent) => void) | null;
-    onmessage: ((event: MinimalMessageEvent) => void) | null;
-    onerror: ((event: MinimalEvent) => void) | null;
-    onclose: ((event: MinimalCloseEvent) => void) | null;
-}
-
-type BroadcastSubData = {
-    channelName: string;
-};
-declare function fromBroadcastChannel<S extends Sub & BroadcastSubData, M>(msgFn: (event: MinimalMessageEvent, sub: S) => M | null): SubscribeHandler<S, M, unknown>;
-
-type EventSourceSubData = {
-    url: string;
-};
-interface EventSourceFactoryOpts<S, M> {
-    onMessage: (data: string, sub: S) => M | null;
-    onError?: (event: MinimalEvent, sub: S) => M | null;
-    onOpen?: (sub: S) => M | null;
-}
-declare function fromEventSource<S extends Sub & EventSourceSubData, M>(opts: EventSourceFactoryOpts<S, M>): SubscribeHandler<S, M, unknown>;
-
-declare function fromEventTarget<S extends Sub, M>(getTarget: () => MinimalEventTarget, eventName: string, msgFn: (event: MinimalEvent, sub: S) => M | null): SubscribeHandler<S, M, unknown>;
-
-type IntervalSubData = {
-    intervalMs: number;
-};
-declare function fromInterval<S extends Sub & IntervalSubData, M>(msgFn: (sub: S) => M): SubscribeHandler<S, M, unknown>;
-
-declare function fromPort<S extends Sub, M, Ctx, T, RS = unknown, RM extends {
-    type: string;
-} = {
-    type: string;
-}>(selectRuntime: (ctx: Ctx) => Runtime<RS, RM>, port: Port<T>, msgFn: (value: T, sub: S) => M | null): SubscribeHandler<S, M, Ctx>;
-
-type WebSocketSubData = {
-    wsUrl: string;
-};
-interface WebSocketFactoryOpts<S, M> {
-    onMessage: (data: unknown, sub: S) => M | null;
-    onOpen?: (sub: S) => M | null;
-    onError?: (event: MinimalEvent, sub: S) => M | null;
-    onClose?: (code: number, reason: string, sub: S) => M | null;
-}
-declare function fromWebSocket<S extends Sub & WebSocketSubData, M>(opts: WebSocketFactoryOpts<S, M>): SubscribeHandler<S, M, unknown>;
-
-/** Cancels a scheduled reconnect timer (the inverse of `schedule`). */
-type CancelTimer = () => void;
-interface ReconnectingWebSocketFactoryOpts<S, M> {
-    onMessage: (data: unknown, sub: S) => M | null;
-    onOpen?: (sub: S) => M | null;
-    onError?: (event: MinimalEvent, sub: S) => M | null;
-    onClose?: (code: number, reason: string, sub: S) => M | null;
-    /**
-     * Fires when a reconnection (any open after the first) succeeds, carrying the
-     * 1-based reconnect count — the resync hook. Omitting drops reconnect events
-     * silently.
-     */
-    onReconnect?: (attempt: number, sub: S) => M | null;
-    /** First backoff delay in ms (doubles each failed attempt). Default 250. */
-    backoffBaseMs?: number;
-    /** Backoff ceiling in ms. Default 5000. */
-    backoffMaxMs?: number;
-    /** Inject the socket constructor (defaults to the global `WebSocket`); the test seam. */
-    connect?: (url: string) => MinimalWebSocket;
-    /** Inject the timer (defaults to `setTimeout`/`clearTimeout`); the test seam. */
-    schedule?: (fn: () => void, ms: number) => CancelTimer;
-}
-declare function fromReconnectingWebSocket<S extends Sub & WebSocketSubData, M>(opts: ReconnectingWebSocketFactoryOpts<S, M>): SubscribeHandler<S, M, unknown>;
-
-type TimeoutSubData = {
-    delayMs: number;
-};
-declare function fromTimeout<S extends Sub & TimeoutSubData, M>(msgFn: (sub: S) => M): SubscribeHandler<S, M, unknown>;
-
-/**
- * The Sub the battery builds. The consumer's `Sub` union includes
- * `ManagedResourceSub<TKey>` directly — the substrate reconciles by `id` and
- * `type` like any other Sub.
- */
-interface ManagedResourceSub<TKey> extends Sub<"managed_resource"> {
-    /** The lifetime key. Stable while the resource should be held; a change
-     *  retires the old resource (release) and acquires a fresh one. */
-    readonly key: TKey;
-}
-/**
- * A battery paired with a state-gate. Self-contained: it knows its `name`
- * (for the unique-name assert), how to derive its live Sub from a state
- * (`subFor`), how to handle its own `subscribe`, and whether it `owns` a given
- * Sub id.
- *
- * Generic in the consumer state `S`, the shared lifetime key `TKey`, and the
- * shared `Ctx`. `Handle` is the ONLY thing erased — each battery's handle type
- * differs (a checkpoint saver vs. a tool-call bridge) but never crosses this
- * interface, so a `combineManagedResources` array holds entries of
- * heterogeneous handle types with no cast. The sub type stays
- * `ManagedResourceSub<TKey>` end to end, so the substrate's narrowed Sub flows
- * straight in.
- */
-interface GatedManagedResource<S, TKey, Ctx> {
-    /** The owning battery's `name`. The combinator asserts these are unique. */
-    readonly name: string;
-    /**
-     * Derive this resource's live Sub for a given state: the battery's
-     * `.sub(key)` when `when(state)` returns a key, or `null` when it returns
-     * `null` (the resource should be torn down in that state).
-     */
-    readonly subFor: (state: S) => ManagedResourceSub<TKey> | null;
-    /**
-     * This battery's own `.subscribe`. The combinator routes an incoming
-     * `managed_resource` Sub to the entry whose `owns(sub)` is true, then calls
-     * this.
-     */
-    readonly subscribe: (sub: ManagedResourceSub<TKey>, ctx: Ctx, dispatch: (msg: never) => void) => Dispose;
-    /**
-     * Does this entry own the given Sub? `sub.id === subIdFor(sub.key)` encodes
-     * the battery `name`, so a match is unambiguous.
-     */
-    readonly owns: (sub: ManagedResourceSub<TKey>) => boolean;
-}
-/**
- * What `combineManagedResources` returns: the single managed-resource
- * `subscribe` cell for the machine's `subscribe` record, and a `subs(state)`
- * builder for `subscriptions(state)`.
- */
-interface CombinedManagedResources<S, TKey, Ctx> {
-    /**
-     * Map every entry through its `when(state)`, drop the `null`s, and build the
-     * live Subs. Spread into `subscriptions(state)`. The derived list and the
-     * `subscribe` routing share one source — the entries — so they never drift.
-     */
-    readonly subs: (state: S) => ManagedResourceSub<TKey>[];
-    /**
-     * The SINGLE `subscribe.managed_resource` handler. Routes an incoming Sub to
-     * the owning battery by matching `sub.id === battery.subIdFor(sub.key)` (the
-     * id encodes the battery `name`). Throws loudly on an unrouted id — a wiring
-     * bug, never a silent no-op resource.
-     */
-    readonly subscribe: (sub: ManagedResourceSub<TKey>, ctx: Ctx, dispatch: (msg: never) => void) => Dispose;
-}
-interface DefineManagedResourceOpts<TKey, Handle, Ctx> {
-    /**
-     * A short, stable name. The Sub id is `managed:${name}:${stringify(key)}`,
-     * so two managed resources in one machine never collide and neither
-     * collides with a `fromTransport` Sub keyed on the same identity.
-     */
-    readonly name: string;
-    /**
-     * Build the resource. Runs when the Sub appears in `subscriptions(state)`.
-     * The returned Handle is the ONLY thing `release` receives — capture
-     * everything teardown needs into it. If `acquire` throws, the substrate's
-     * reconcile does NOT register the Sub and `release` is never called (no
-     * dangling half-built resource).
-     */
-    readonly acquire: (key: TKey, ctx: Ctx) => Handle;
-    /**
-     * Tear the resource down. Runs when the Sub leaves the desired set (phase
-     * exited) or when its key changes. MANDATORY — the guaranteed teardown is
-     * the reason this battery exists.
-     *
-     * May be sync or async, and an async one is really awaited: the promise is
-     * returned to the substrate, which tracks it and drains it inside `stop()`
-     * (bounded by `run({ disposeTimeoutMs })`). So `await runtime.stop()` means
-     * the release finished — the reading a host evicting an isolate acts on.
-     * MID-RUN teardown (a phase exit, a key change) is still fire-and-forget
-     * (Rule 2): the reconcile pass is synchronous by construction, so it starts
-     * the release and moves on. A rejection is never a Msg — it reaches the
-     * runtime's `onError` sink under `phase: "sub-cleanup"`.
-     */
-    readonly release: (handle: Handle) => void | Promise<void>;
-}
-/**
- * What the battery returns: a `.sub(key)` builder for `subscriptions`, the
- * `.subscribe` handler for the machine's `subscribe` record, a `.get(key)`
- * accessor so Cmd handlers can reach the live Handle while the resource is
- * held, and a `.subIdFor(key)` for tests.
- */
-interface ManagedResourceBattery<TKey, Handle, Ctx> {
-    /**
-     * Build the Sub for `subscriptions(state)`. The consumer calls this from
-     * inside their `subscriptions` cell for the phases where the resource
-     * should be live.
-     */
-    readonly sub: (key: TKey) => ManagedResourceSub<TKey>;
-    /**
-     * Pair this battery with a state-gate, producing a self-contained entry for
-     * `combineManagedResources`. `when(state)` returns the resource's KEY when
-     * it should be live in that state, or `null` when it should be torn down.
-     *
-     * Folding "is it active?" and "what key?" into ONE declaration at the
-     * battery's own definition site is the point: a central `subscriptions(state)`
-     * list can silently forget to gate a new phase, but a per-resource gate
-     * travels with the resource. The combinator derives BOTH the active-sub list
-     * and the subscribe routing from these entries, so the two can never disagree.
-     *
-     * Generic in the consumer's state `S` (each `.gated` call binds its own `S`).
-     * The returned entry erases this battery's `Handle` — `combineManagedResources`
-     * holds entries of heterogeneous handle types with no cast — while keeping
-     * `TKey` and `Ctx` so the substrate's narrowed `ManagedResourceSub<TKey>`
-     * flows straight into the entry's `subscribe`.
-     */
-    readonly gated: <S>(when: (state: S) => TKey | null) => GatedManagedResource<S, TKey, Ctx>;
-    /**
-     * Dep-keyed entry for the machine's `subs` array. `when(state)` returns the
-     * resource's KEY when it should be held, or `null` when it should be torn
-     * down — the exact gate `.gated` takes, now producing a `DepKeyedSub` the
-     * kernel folds directly instead of an entry the `combineManagedResources`
-     * router multiplexes.
-     *
-     * This is the simplification the dep-keyed kernel unlocks: two managed
-     * resources used to COLLIDE on the single `subscribe.managed_resource` key
-     * (both subs share `type: "managed_resource"`), forcing
-     * `combineManagedResources` to route by SubId. A dep-keyed Sub has its OWN
-     * reconcile slot (its array position), so there is no shared `type` to route
-     * — each resource is one `subs` entry, no combinator, no router. `acquire` /
-     * `release` still ride the kernel's dispose-on-change / dispose-on-null
-     * reconcile, now via the dep-keyed source's `Dispose` instead of the
-     * `subscribe` cell's cleanup.
-     */
-    readonly depKeyed: <S>(when: (state: S) => TKey | null) => DepKeyedSub<S, never, Ctx>;
-    /**
-     * The `subscribe.managed_resource` handler. Drop straight into the
-     * machine's `subscribe` record. Runs `acquire` on install, holds the
-     * Handle in the battery's handle table, and returns a cleanup that runs
-     * `release` (and forgets the Handle) on reconcile-out.
-     */
-    readonly subscribe: (sub: ManagedResourceSub<TKey>, ctx: Ctx, dispatch: (msg: never) => void) => Dispose;
-    /**
-     * Accessor for the live Handle, keyed on `key`. Returns `undefined` when
-     * the resource is not currently held (no active sub for that key) — the
-     * caller decides whether that is an error. A Cmd handler wires its
-     * `ctx.getX(key)` through this, so the handler reads the SAME owner the
-     * reconciler holds, never a hand-built duplicate.
-     */
-    readonly get: (key: TKey) => Handle | undefined;
-    /** Pre-derived subId for `(key)` — handy for tests. */
-    readonly subIdFor: (key: TKey) => SubId;
-}
-/**
- * Build the battery. One call per managed resource at the machine's host
- * file.
- *
- * @example
- *   const checkpointStore = defineManagedResource<RunId, CheckpointSaver, Ctx>({
- *     name: "checkpoint",
- *     acquire: (runId, ctx) =>
- *       new CheckpointSaver({ storage: ctx.storage, bucket: ctx.bucket, runId }),
- *     release: (saver) => saver.clear(),
- *   });
- *
- *   // In the machine:
- *   subscriptions: (state) =>
- *     state.type === "running" ? [checkpointStore.sub(state.runId)] : [],
- *   subscribe: { managed_resource: checkpointStore.subscribe },
- *
- *   // In interpret (read the live handle the reconciler holds):
- *   start_graph: async (cmd, ctx) => {
- *     const saver = checkpointStore.get(cmd.runId);  // same owner, no rebuild
- *     ...
- *   }
- */
-declare function defineManagedResource<TKey, Handle, Ctx>(opts: DefineManagedResourceOpts<TKey, Handle, Ctx>): ManagedResourceBattery<TKey, Handle, Ctx>;
-declare function combineManagedResources<S, TKey, Ctx>(entries: readonly GatedManagedResource<S, TKey, Ctx>[]): CombinedManagedResources<S, TKey, Ctx>;
-
-/**
- * Duplex transport. The host (DO, worker thread, in-process bus) constructs
- * one from whatever the platform offers. `fromTransport` does not know what
- * a WebSocket is — it knows `send`, `onMessage`, `onClose`.
- */
-interface Transport {
-    /** Send a string frame. Best-effort; failures are logged at the boundary. */
-    send(data: string): void;
-    /**
-     * Subscribe to inbound frames. Returns a cleanup that removes the listener.
-     * The battery wires this in its Sub's subscribe handler; cleanup runs when
-     * the phase exits (the substrate's reconcileSubs).
-     */
-    onMessage(listener: (data: string) => void): () => void;
-    /**
-     * Subscribe to a one-shot close. Returns a cleanup that removes the
-     * listener. The battery dispatches `lostMsg` on close.
-     */
-    onClose(listener: () => void): () => void;
-    /** Close the underlying channel cleanly. Called by the Sub cleanup. */
-    close(): void;
-}
-/**
- * Factory the consumer wires to a platform-specific transport. The battery
- * passes the runtime-derived key (`runId`, or whatever identity is on the
- * phase) so per-run transports can be addressed.
- */
-type TransportFactory<K> = (key: K) => Transport;
-/**
- * The Sub the battery builds. The consumer's `Sub` union includes
- * `TransportSub<TKey>` directly — no wrapping needed, the substrate
- * reconciles by `id` and `type` like any other Sub.
- */
-interface TransportSub<TKey> extends Sub<"transport"> {
-    /** The phase / run identity. Stable for the lifetime of the seam. */
-    readonly key: TKey;
-}
-interface FromTransportOpts<TKey, Inbound, Outbound, M, Ctx> {
-    /**
-     * A short, stable name for this seam. The Sub id is derived from
-     * `${name}:${stringify(key)}` so two seams in the same machine (e.g.
-     * `hands` + `worker`) never collide.
-     */
-    readonly name: string;
-    /**
-     * Build the transport. The battery owns the lifetime; the factory is the
-     * platform-specific constructor (`new WebSocket(...)` adapter on a DO,
-     * `MessagePort` adapter in a worker, in-memory stub in tests).
-     */
-    readonly openTransport: (key: TKey, ctx: Ctx) => Transport;
-    /**
-     * Parse one inbound frame. The battery hands `unknown` through (boundary
-     * parse is the consumer's responsibility per invariant 8). Returning
-     * `null` drops the frame silently — useful for frames the seam doesn't
-     * recognize at this layer (e.g. transport-level keepalive).
-     */
-    readonly parseInbound: (raw: string, key: TKey) => Inbound | null;
-    /**
-     * Map a parsed inbound to a domain Msg. Returning `null` drops the
-     * dispatch (e.g. a transport-level pong that doesn't change domain state).
-     */
-    readonly onInbound: (inbound: Inbound, key: TKey) => M | null;
-    /**
-     * The Msg dispatched when the transport closes (peer gone, network
-     * dropped, normal close). ONE Msg arm, not a Sub, not a heartbeat-derived
-     * deadline — the transport's own close signal is the truth.
-     */
-    readonly lostMsg: (key: TKey) => M;
-    /**
-     * Serialize an outbound. Called by the Cmd handler the battery wires.
-     * Pure data → string at the seam boundary.
-     */
-    readonly serializeOutbound: (outbound: Outbound) => string;
-}
-/**
- * What the battery returns: a Sub builder (for `subscriptions`), the Sub's
- * `subscribe` handler (for `subscribe.transport`), and a `send(key, outbound)`
- * helper the consumer's Cmd handler calls. Plus a `subIdFor` factory the
- * consumer can use when keying related Subs (e.g. a deadline) to the same seam
- * identity.
- */
-interface TransportBattery<TKey, Outbound, M, Ctx> {
-    /**
-     * Build the Sub for `subscriptions(state)`. The consumer calls this from
-     * inside their `subscriptions` cell when the seam should be open.
-     */
-    readonly sub: (key: TKey) => TransportSub<TKey>;
-    /**
-     * The `subscribe.transport` handler. Drop straight into the machine's
-     * `subscribe` record — the battery wires inbound + close in one shot.
-     */
-    readonly subscribe: (sub: TransportSub<TKey>, ctx: Ctx, dispatch: (msg: M) => void) => () => void;
-    /**
-     * Outbound send. The Cmd handler calls this; the battery's handle table
-     * (built when subscribe ran) routes to the live transport. If the seam
-     * is closed (no active sub), the send is dropped honestly (logged, not
-     * thrown — the reducer already moved past caring, same shape as Rule 2
-     * fire-and-forget Cmds).
-     */
-    readonly send: (key: TKey, outbound: Outbound) => void;
-    /** Pre-derived subId for `(key)` — handy for deadline Subs keyed to the same seam. */
-    readonly subIdFor: (key: TKey) => SubId;
-    /**
-     * Pair this seam with a state-gate, producing a dep-keyed Sub for the
-     * machine's `subs` array. `when(state)` returns the seam's KEY when it
-     * should be open, or `null` when it should be torn down. The kernel derives
-     * the id from `structuralHash(key)` and reconciles the seam's lifetime — so
-     * the author neither lists this Sub in a central `subscriptions(state)` nor
-     * writes its id. Replaces `subscriptions: (s) => active(s) ? [hands.sub(...)] : []`
-     * + `subscribe: { transport: hands.subscribe }` with one `subs` entry.
-     *
-     * The `source` closes over the battery's own `subscribe` (open inbound +
-     * close, wire the handle table) using the same `ctx` the kernel passes every
-     * Sub source.
-     */
-    readonly depKeyed: <S>(when: (state: S) => TKey | null) => DepKeyedSub<S, M, Ctx>;
-}
-/**
- * Build the battery. One call per seam at the machine's host file.
- *
- * @example
- *   const handsSeam = fromTransport<RunId, HandsInbound, HandsOutbound, Msg, Ctx>({
- *     name: "hands",
- *     openTransport: (runId, ctx) => ctx.openHandsWs(runId),
- *     parseInbound: (raw) => parseHandsInbound(JSON.parse(raw)),
- *     onInbound: (inbound, runId) => ({ type: "hands_said", runId, inbound }),
- *     lostMsg: (runId) => ({ type: "hands_lost", runId }),
- *     serializeOutbound: (out) => JSON.stringify(out),
- *   });
- *
- *   // In the machine:
- *   subscriptions: (state) => state.type === "auditing" ? [handsSeam.sub(state.runId)] : [],
- *   subscribe: { transport: handsSeam.subscribe },
- *
- *   // In interpret:
- *   send_hands: async (cmd) => { handsSeam.send(cmd.runId, cmd.outbound); },
- */
-declare function fromTransport<TKey, Inbound, Outbound, M, Ctx>(opts: FromTransportOpts<TKey, Inbound, Outbound, M, Ctx>): TransportBattery<TKey, Outbound, M, Ctx>;
-
-export { type CancelTimer, type CombinedManagedResources, type DefineManagedResourceOpts, type EventSourceFactoryOpts, type FromTransportOpts, type GatedManagedResource, type ListenerTarget, type ManagedResourceBattery, type ManagedResourceSub, type ReconnectingWebSocketFactoryOpts, SubscribeHandler, type Transport, type TransportBattery, type TransportFactory, type TransportSub, type WebSocketFactoryOpts, type WebSocketSubData, combineManagedResources, defineListener, defineManagedResource, fromBroadcastChannel, fromEventSource, fromEventTarget, fromInterval, fromPort, fromReconnectingWebSocket, fromTimeout, fromTransport, fromWebSocket };

package/dist/subs/index.js

@@ -1,7 +0,0 @@
-export { combineManagedResources, defineListener, defineManagedResource, fromBroadcastChannel, fromEventSource, fromEventTarget, fromInterval, fromPort, fromReconnectingWebSocket, fromTransport, fromWebSocket } from '../chunk-3JU6657S.js';
-export { fromTimeout } from '../chunk-2YFLOCWX.js';
-import '../chunk-ZJ5AOYBH.js';
-import '../chunk-5EHLEUTL.js';
-import '../chunk-B5VXOFMZ.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/subs/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/throttle/index.d.ts

@@ -1,134 +0,0 @@
-/**
- * @demlik/tea/throttle — a timer-based call transformer that caps invocation
- * to at most once per `ms` window.
- *
- * Sibling of `@demlik/tea/debounce` — the two share a SYMMETRIC surface
- * (`Throttled<A>` / `Debounced<A>`, both callable + `.cancel()` + `.flush()`,
- * both `{ leading?, trailing? }`) so they read as a pair. They are kept in
- * separate files with NO cross-import: each is a self-contained timer, and the
- * coalesce-vs-drop policies differ enough that sharing code would hide the
- * distinction. The contrast IS the lesson:
- *
- *   - **debounce** waits for quiet — fires once AFTER a burst settles.
- *   - **throttle** enforces a rate — fires AT MOST once per `ms` while the
- *     burst is ongoing, dropping the calls in between.
- *
- * Layering with `@demlik/tea/throttled-input`: `throttle` and `debounce` are
- * the two host-boundary PRIMITIVES — two distinct algorithms
- * (at-most-once-per-window vs collapse-a-burst) behind one signature shape.
- * `throttled-input` is NOT a third primitive: it is a TEA machine composed
- * OVER them (the same semantics, reimplemented as pure, durable Model state)
- * that re-exports both. Wrapping a raw host event → these primitives; durable, replayable
- * gating inside a machine → `throttled-input` (see its module doc for the full
- * layering map).
- *
- * WHAT THIS IS NOT — and why it lives outside `update`:
- *
- *   - NOT a reducer / Transitions cell. Reducers are PURE (invariant 2 — same
- *     inputs → same outputs, no `Date.now`, no timers). A throttle holds a live
- *     `setTimeout` handle and a window cursor; folding it into `update` would
- *     smuggle a timer into the pure core.
- *   - NOT a Sub. A Sub is a continuous SOURCE of Msgs the substrate reconciles
- *     by id every transition (invariant 4). A throttle is a SINK transformer:
- *     it wraps a `void`-returning handler (the canonical one is
- *     `Runtime.dispatch`) so a high-frequency HOST event is rate-limited BEFORE
- *     it ever becomes a Msg.
- *
- * It is a higher-order function at the host boundary (pattern 14 — TEA owns
- * state, JS owns timing). The host attaches the wrapped function to a
- * high-frequency event source (`mousemove`, `scroll`, `pointermove`, a game
- * loop) and the substrate downstream only ever sees the rate-limited Msg:
- *
- *   const onMoved = throttle(
- *     (e: PointerEvent) =>
- *       runtime.dispatch({ type: "UserMovedCursor", x: e.clientX, y: e.clientY }),
- *     16, // ~60fps cap
- *   );
- *   window.addEventListener("pointermove", onMoved);
- *   // cleanup: onMoved.cancel(); window.removeEventListener("pointermove", onMoved);
- *
- * NOT exported from the package root — reached via the `@demlik/tea/throttle`
- * subpath, same one-shape-per-package rule as `rate-limit`, `deadline`, and
- * `work-queue`.
- *
- * Uses the universal `setTimeout` / `clearTimeout` timer idiom (same discipline
- * as `subs/from-timeout.ts`): exactly one live handle at a time, the window
- * timer clears itself on expiry, `cancel` / `flush` clear and null it so a
- * stale callback can never run.
- */
-/**
- * A throttled wrapper around `fn`. Callable with the SAME argument tuple as
- * `fn` — `(...args: A) => void` — plus two control methods that share names and
- * shapes with `Debounced<A>` so the two modules read as a symmetric pair.
- */
-interface Throttled<A extends readonly unknown[]> {
-    /** Invoke `fn` if the window is open, else record args for the trailing fire. */
-    (...args: A): void;
-    /**
-     * Drop any pending trailing fire WITHOUT invoking `fn`, and close the active
-     * window. Clears the timer, forgets the captured trailing args, and resets
-     * the cursor so the next call fires immediately on the leading edge (if
-     * `leading` is enabled). Idempotent.
-     *
-     * The host-cleanup partner of `removeEventListener`: cancel the pending fire
-     * when the component unmounts / the listener detaches, so a queued
-     * `dispatch` can't land after teardown.
-     */
-    cancel(): void;
-    /**
-     * Fire any pending trailing call IMMEDIATELY with its latest captured args,
-     * then close the window. No-op when nothing is pending. Use to force the last
-     * dropped call out early — e.g. flush the final cursor position when a drag
-     * ends, so the rest state isn't a stale mid-drag sample.
-     */
-    flush(): void;
-}
-/**
- * Wrap `fn` so it runs AT MOST once per `ms` window, no matter how often it is
- * called.
- *
- * Leading + trailing (the default): the first call fires `fn` IMMEDIATELY (the
- * leading edge) and opens a `ms` window. Calls during the window are dropped
- * from immediate firing but their args are remembered; when the window closes,
- * `fn` fires ONCE more with the LATEST dropped args (the trailing edge) and a
- * new window opens. A call after the window has already closed leads a fresh
- * window immediately. Spacing every call at least `ms` apart therefore fires
- * each one on its own leading edge.
- *
- * @param fn   The handler to rate-limit. Typically `(...) => runtime.dispatch(...)`,
- *             but any `(...args: A) => void` works. The return value is
- *             ignored — throttle is a fire transformer, not a value pipe.
- * @param ms   Window length in milliseconds. `fn` fires at most once per `ms`.
- * @param opts.leading   Fire on the FIRST call of a window (the leading edge),
- *             immediately. Default `true`.
- * @param opts.trailing  Fire once at window END with the latest args dropped
- *             during the window. Default `true`.
- *
- * Edge combinations (matching lodash's settled semantics, the de-facto
- * standard the ecosystem rediscovered):
- *
- *   - `{ leading: true, trailing: true }` (default): immediate fire + a
- *     trailing fire per window while calls keep arriving. The trailing fire is
- *     SUPPRESSED when no extra call arrived during the window (a lone call
- *     already fired on the leading edge — no stale trailing double-fire).
- *   - `{ leading: true, trailing: false }`: only the immediate fire; everything
- *     in the window is dropped with no catch-up at the end.
- *   - `{ leading: false, trailing: true }`: no immediate fire; the FIRST call
- *     opens a window and `fn` fires at the window's end with the latest args.
- *     Steady "sample every `ms`" behavior with no instant response.
- *   - `{ leading: false, trailing: false }`: never fires. Degenerate but legal;
- *     we don't throw — the caller asked for a no-op transformer.
- *
- * WHY a default of leading + trailing both `true`: a throttle's job is "respond
- * now, then keep responding at a steady rate." Leading gives the instant
- * response (the first `mousemove` updates immediately); trailing guarantees the
- * FINAL sample of a window isn't lost (the cursor ends where the user actually
- * left it, not one window-width behind). Dropping either loses one of those two
- * guarantees, so both default on.
- */
-declare function throttle<A extends readonly unknown[]>(fn: (...args: A) => void, ms: number, opts?: {
-    leading?: boolean;
-    trailing?: boolean;
-}): Throttled<A>;
-
-export { type Throttled, throttle };

package/dist/throttle/index.js

@@ -1,3 +0,0 @@
-export { throttle } from '../chunk-HCEVHFJ7.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/throttle/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}