@demlik/tea 0.14.0 → 0.16.0

package/dist/{index-4vZzljCD.d.ts → index-_dOR3xqA.d.ts}

@@ -1,6 +1,5 @@
-import { C as Cmd } from './core-CTzMJ82M.js';
-import { S as SubscribeHandler } from './types-DP3f5NIl.js';
-import { D as DeadlineExceeded, a as DeadlineSub } from './index-q0hXFeZ0.js';
+import { C as Cmd, T as TimerDeps, d as Subscribe } from './core-BbgtiXdg.js';
+import { D as DeadlineExceeded, a as DeadlineSub, b as DeadlinesSub } from './index-Xufl55W8.js';
 
 /**
  * internal/flow/batch-window — coalesce a stream of items into size- or
@@ -8,14 +7,13 @@ import { D as DeadlineExceeded, a as DeadlineSub } from './index-q0hXFeZ0.js';
  *
  * What this module actually DELEGATES to, vs. what it merely RE-EXPORTS:
  *
- *   - `../deadline` — REAL delegation (the only one). The window timer IS a
- *     `deadline` Sub: `subsFor` returns `deadlineSub` keyed on the window's
- *     identity, the subscribe cell is `subscribeDeadline` verbatim, and the
- *     expiry Msg is `deadlineExceeded`. Nothing about the timer is redrawn here.
- *     "Fire at an absolute instant, even across a rehydrate" is exactly
- *     `deadline`'s absolute-target lifecycle: a late subscribe (post-`Store`
- *     rehydrate) recomputes the remaining delay from the current clock and still
- *     fires at the correct moment.
+ *   - `../deadline` — REAL delegation (the only one). The window timer's Msg
+ *     is `deadlineExceeded`, keyed on the window's identity. `timerFor` arms it
+ *     through the engine's built-in `timer` Sub: `maxMs` counted from the
+ *     transition that opened the window, so a machine needs no runner. The
+ *     absolute-instant form is still here too — `subsFor` lists the same
+ *     deadline for `deadlinesSub` + `subscribeDeadline`, which re-arms for the
+ *     REMAINING time after a `Store` rehydrate rather than a fresh `maxMs`.
  *   - `../work-queue` — TYPE re-export only, NOT a sink this module calls. A
  *     flush emits a Cmd; the CONSUMER's interpret handler is what enqueues onto a
  *     `createQueue(store)`. This module never touches queue status — it has no
@@ -48,10 +46,10 @@ import { D as DeadlineExceeded, a as DeadlineSub } from './index-q0hXFeZ0.js';
  *   // Model:        { batch: BatchWindow<LogLine>, ... }
  *   // init:         (loaded) => [loaded ?? { batch: bw.init(), ... }, []]
  *   // update cells:
- *   //   LogArrived:   (s, m) => mapBatch(s, bw.add(s.batch, m.line, m.at))
- *   //   WindowFired:  (s, m) => mapBatch(s, bw.onWindow(s.batch, m.atMs))
- *   // subscriptions: (s) => bw.subs(s.batch)
- *   // subscribe:     { ...bw.handlers() }
+ *   //   LogArrived:        (s, m) => mapBatch(s, bw.add(s.batch, m.line, m.at))
+ *   //   deadline_exceeded: (s, m) => mapBatch(s, bw.onWindow(s.batch, m.atMs))
+ *   // subs:         [{ type: "timer", deps: (s: Model) => bw.timer(s.batch) }]
+ *   // at run:       run(machine, { interpret })   // `timer` is built in
  *
  * where `mapBatch(s, [batch, cmds]) => [{ ...s, batch }, cmds]` lifts the slice
  * transition into the consumer's Model. The `FlushBatch` Cmd's interpret handler
@@ -118,26 +116,26 @@ interface BatchWindow<I> {
 /** The starting slice: closed window, empty buffer. */
 declare function initBatchWindow<I>(): BatchWindow<I>;
 /**
- * The Sub a batch window's open timer produces: it IS `../deadline`'s
+ * The deadline a batch window's open timer lists: it IS `../deadline`'s
  * `DeadlineSub`, not a re-tagged copy. `atMs` is the absolute flush-by instant
  * (`openedAt + maxMs`). Aliasing the deadline type (rather than redeclaring an
  * identical shape) is what lets `subsFor` return `deadlineSub(...)` with no
  * cast — the value's static type already satisfies this name. Consumers running
- * several windows route each one by the Sub's `id`, not by a distinct type.
+ * several windows route each one by the deadline's `id`, not by a distinct type.
  */
 type BatchWindowSub = DeadlineSub;
 /** The Msg a closed-by-time window dispatches. Alias of `deadline`'s Msg. */
 type BatchWindowExpired = DeadlineExceeded;
 /**
  * Construct the window-expired Msg for the window identified by `id`, flushing
- * by `atMs`. Re-exported alias of `deadlineExceeded` so the subscribe cell and
+ * by `atMs`. Re-exported alias of `deadlineExceeded` so the runner and
  * the consumer's reducer share one constructor rather than two literals that
  * can drift. The consumer handles it in a reducer cell by calling `onWindow`.
  */
 declare function batchWindowExpired(id: string, atMs: number): BatchWindowExpired;
 /**
  * The bound knob returned by `createBatchWindow`. `init` + the two pure verbs +
- * `subs` + `handlers`, all closing over one `BatchWindowConfig`. The verbs
+ * `timer` + `subs`, all closing over one `BatchWindowConfig`. The verbs
  * return `readonly [BatchWindow<I>, readonly C[]]`: the next slice and the Cmds
  * to emit (one `flush` Cmd when a window closes, none otherwise).
  */
@@ -154,18 +152,16 @@ interface BatchWindowKnob<I, C extends Cmd> {
      */
     onWindow(state: BatchWindow<I>, at: number): readonly [BatchWindow<I>, readonly C[]];
     /**
-     * The window timer Sub, armed only while a window is open. See `subsFor`.
-     * `id` keys the deadline so several windows on one machine route distinctly.
+     * The built-in `timer` Sub's deps while a window is open, `null` while it is
+     * closed. See `timerFor`. `id` keys the Msg so several windows on one
+     * machine route distinctly.
      */
-    subs(state: BatchWindow<I>, id?: string): readonly BatchWindowSub[];
+    timer(state: BatchWindow<I>, id?: string): TimerDeps<BatchWindowExpired> | null;
     /**
-     * The `subscribe` cells this knob splices into `machine.subscribe`. One cell,
-     * keyed `"deadline"`, delegating to `../deadline`'s subscribe handler. Spread
-     * into the consumer's subscribe map: `subscribe: { ...bw.handlers() }`.
+     * The window timer as an absolute deadline, listed only while a window is
+     * open — for `deadlinesSub` + `subscribeBatchWindow`. See `subsFor`.
      */
-    handlers(): {
-        deadline: SubscribeHandler<BatchWindowSub, BatchWindowExpired, unknown>;
-    };
+    subs(state: BatchWindow<I>, id?: string): readonly BatchWindowSub[];
 }
 /**
  * Buffer `item` and decide whether the size trigger fires. PURE.
@@ -215,18 +211,18 @@ declare function addItem<I, C extends Cmd>(config: BatchWindowConfig<I, C>, stat
  */
 declare function onWindow<I, C extends Cmd>(config: BatchWindowConfig<I, C>, state: BatchWindow<I>, _at: number): readonly [BatchWindow<I>, readonly C[]];
 /**
- * The window timer Sub, derived from the slice. PURE.
+ * The window timer deadline, derived from the slice. PURE.
  *
- * Returns the single `deadline` Sub targeting `openedAt + maxMs` while a window
- * is open (buffer non-empty), or `[]` while it is closed. The substrate's
- * reconcile pass arms the timer when the array gains the Sub and disarms it
- * (clearing the pending `setTimeout`) when the array loses it — so a size-flush
- * that empties the buffer auto-cancels the now-irrelevant time trigger on the
- * next transition.
+ * Returns the single deadline targeting `openedAt + maxMs` while a window is
+ * open (buffer non-empty), or `[]` while it is closed. Fed through
+ * `deadlinesSub`, the engine arms the timer when the list gains the deadline
+ * and disarms it (clearing the pending `setTimeout`) when the list loses it —
+ * so a size-flush that empties the buffer auto-cancels the now-irrelevant time
+ * trigger on the next transition.
  *
  * `id` defaults to `"batch-window"`; pass a distinct id per window when a
- * machine runs several so the dispatched `BatchWindowExpired` Msg (and its
- * reconcile identity) routes to the right one.
+ * machine runs several so the dispatched `BatchWindowExpired` Msg routes to the
+ * right one.
  *
  * @param config the knob (maxMs)
  * @param state  the current slice
@@ -235,22 +231,38 @@ declare function onWindow<I, C extends Cmd>(config: BatchWindowConfig<I, C>, sta
  */
 declare function subsFor<I, C extends Cmd>(config: BatchWindowConfig<I, C>, state: BatchWindow<I>, id?: string): readonly BatchWindowSub[];
 /**
- * The `subscribe["deadline"]` cell for a batch window's timer — the exact
- * `../deadline` handler. Arms a one-shot timer for `max(0, atMs - now)` and
- * dispatches `batchWindowExpired(...)`; returns a cleanup that clears it. The
- * consumer assigns it via the knob's `handlers()`.
+ * The built-in `timer` Sub's deps for a batch window. PURE.
+ *
+ * While a window is open it counts `maxMs` down from the transition that
+ * opened it — the deps are fixed for the window's life (`openedAt` never moves
+ * while items append), so the engine starts the countdown exactly once — and
+ * fires `batchWindowExpired(id, openedAt + maxMs)`. A closed window is `null`,
+ * so a size-flush that empties the buffer cancels the countdown on the next
+ * transition.
+ *
+ * Relative by construction: a process that rehydrates an open window counts a
+ * fresh `maxMs`. Reach for `subsFor` + `subscribeBatchWindow` when the flush
+ * must land at the original absolute instant.
+ */
+declare function timerFor<I, C extends Cmd>(config: BatchWindowConfig<I, C>, state: BatchWindow<I>, id?: string): TimerDeps<BatchWindowExpired> | null;
+/**
+ * The `deadline` runner for a batch window's absolute timer — the exact
+ * `../deadline` runner. Arms a one-shot timer per listed deadline for
+ * `max(0, atMs - now)` and dispatches `batchWindowExpired(...)`; returns a
+ * cleanup that clears them. Hand it to `run` as `subscribe.deadline` when the
+ * machine declares `deadlinesSub((s) => bw.subs(s.batch))`.
  */
-declare const subscribeBatchWindow: SubscribeHandler<BatchWindowSub, BatchWindowExpired, unknown>;
+declare const subscribeBatchWindow: Subscribe<BatchWindowExpired, DeadlinesSub, unknown>["deadline"];
 /**
  * Build a batch window knob from a config. Combinator form (the default L2
  * ergonomic): hand it the config, splice the ~4 returned hooks into your
  * machine. The pure verbs (`add` / `onWindow`) close over the config so the
- * consumer's reducer cells stay a uniform `(state, ...args)` shape; `subs` /
- * `handlers` pre-wire the window timer.
+ * consumer's reducer cells stay a uniform `(state, ...args)` shape; `timer`
+ * arms the window timer.
  *
  * @typeParam I the item type buffered into each batch
  * @typeParam C the Cmd type `config.flush` returns
  */
 declare function createBatchWindow<I, C extends Cmd>(config: BatchWindowConfig<I, C>): BatchWindowKnob<I, C>;
 
-export { type BatchWindow as B, type BatchWindowSub as a, type BatchWindowConfig as b, type BatchWindowExpired as c, type BatchWindowKnob as d, addItem as e, batchWindowExpired as f, createBatchWindow as g, subscribeBatchWindow as h, initBatchWindow as i, onWindow as o, subsFor as s };
+export { type BatchWindow as B, type BatchWindowSub as a, type BatchWindowExpired as b, type BatchWindowConfig as c, type BatchWindowKnob as d, addItem as e, batchWindowExpired as f, createBatchWindow as g, subscribeBatchWindow as h, initBatchWindow as i, onWindow as o, subsFor as s, timerFor as t };