@demlik/tea 0.13.0 → 0.15.0

package/dist/{throttled-input → timing}/index.d.ts

@@ -1,14 +1,145 @@
-import { TtlCache } from '../cache/index.js';
-import { DeadlineSub } from '../deadline/index.js';
-export { DeadlineExceeded as ThrottledInputSettled, subscribeDeadline as subscribeThrottledInput, deadlineExceeded as throttledInputSettled } from '../deadline/index.js';
-import { C as Cmd, S as Sub } from '../core-Co0LWkIA.js';
-export { Debounced, debounce } from '../debounce/index.js';
-export { Throttled, throttle } from '../throttle/index.js';
-import '../types-XS_miRnB.js';
+export { D as Debounced, d as debounce } from '../index-DHSUmQTR.js';
+import { C as Cmd, S as Sub } from '../core-DnzqWy6u.js';
+import { T as TtlCache, a as DeadlineSub } from '../index-HSYgG2Yt.js';
+export { D as ThrottledInputSettled, s as subscribeThrottledInput, d as throttledInputSettled } from '../index-HSYgG2Yt.js';
 import 'zod';
+import '../types-BseNPIhr.js';
 
 /**
- * @demlik/tea/throttled-input — gate a high-frequency input stream into a
+ * internal/timing/throttle — a timer-based call transformer that caps invocation
+ * to at most once per `ms` window.
+ *
+ * Sibling of `../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 `../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);
+ *
+ * Internal since #47 — not published on any subpath; reached from inside the
+ * package as `internal/timing/throttle`. 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>;
+
+/**
+ * internal/timing/throttled-input — gate a high-frequency input stream into a
  * SETTLED, RATE-CAPPED, optionally DEDUPED sequence of emits, as a TEA knob: one
  * config object + a few pre-wired hooks you spread into your machine.
  *
@@ -90,9 +221,9 @@ import 'zod';
  *
  * NOT a substrate primitive: it depends only on sibling subpaths (`../throttle`,
  * `../debounce`, `../cache`, `../deadline`) and the core `Cmd` / `Sub` types.
- * Consumers reach it via the `@demlik/tea/throttled-input` subpath; the L1
- * escape hatch is those sibling subpaths threaded by hand. NOT exported from the
- * package root — same one-shape-per-package rule as `batch-window` and `poller`.
+ * Internal since #47 — reached from inside the package as
+ * `internal/timing/throttled-input`; the L1 escape hatch is those siblings
+ * threaded by hand. Same one-shape-per-package rule as `batch-window` and `poller`.
  */
 
 /**
@@ -378,4 +509,4 @@ interface ThrottledInputKnob<V, C extends Cmd> {
  */
 declare function createThrottledInput<V, C extends Cmd>(config: ThrottledInputConfig<V, C>): ThrottledInputKnob<V, C>;
 
-export { type PendingInput, type ThrottledInput, type ThrottledInputConfig, type ThrottledInputKnob, type ThrottledInputNoCache, type ThrottledInputSub, type ThrottledInputWithCache, createThrottledInput, initThrottledInput, input, onFlush, subsFor };
+export { type PendingInput, type Throttled, type ThrottledInput, type ThrottledInputConfig, type ThrottledInputKnob, type ThrottledInputNoCache, type ThrottledInputSub, type ThrottledInputWithCache, createThrottledInput, initThrottledInput, input, onFlush, subsFor, throttle };

package/dist/{throttled-input → timing}/index.js

@@ -1,15 +1,60 @@
-export { debounce } from '../chunk-J6527VRQ.js';
-export { throttle } from '../chunk-HCEVHFJ7.js';
-import { initCache, get, set } from '../chunk-RH5EFRVJ.js';
-import { deadlineSub } from '../chunk-DGE4PV4A.js';
-export { subscribeDeadline as subscribeThrottledInput, deadlineExceeded as throttledInputSettled } from '../chunk-DGE4PV4A.js';
-import '../chunk-VYFAZN3F.js';
-import '../chunk-2YFLOCWX.js';
-import '../chunk-ZJ5AOYBH.js';
-import '../chunk-ZSUUOEPL.js';
-import '../chunk-OOYD44JI.js';
+export { debounce } from '../chunk-LFZUK6J2.js';
+import { deadlineSub, initCache, get, set } from '../chunk-22POWGFA.js';
+export { subscribeDeadline as subscribeThrottledInput, deadlineExceeded as throttledInputSettled } from '../chunk-22POWGFA.js';
+import '../chunk-66PY5WYF.js';
 
-// src/throttled-input/index.ts
+// src/internal/timing/throttle/index.ts
+function throttle(fn, ms, opts) {
+  const leading = opts?.leading ?? true;
+  const trailing = opts?.trailing ?? true;
+  let handle = null;
+  let pendingArgs = null;
+  function clearHandle() {
+    if (handle !== null) {
+      clearTimeout(handle);
+      handle = null;
+    }
+  }
+  function onWindowExpired() {
+    if (trailing && pendingArgs !== null) {
+      const args = pendingArgs;
+      pendingArgs = null;
+      handle = setTimeout(onWindowExpired, ms);
+      fn(...args);
+    } else {
+      handle = null;
+    }
+  }
+  const throttled = (...args) => {
+    if (handle === null) {
+      if (leading) {
+        fn(...args);
+      } else if (trailing) {
+        pendingArgs = args;
+      }
+      handle = setTimeout(onWindowExpired, ms);
+    } else if (trailing) {
+      pendingArgs = args;
+    }
+  };
+  throttled.cancel = () => {
+    clearHandle();
+    pendingArgs = null;
+  };
+  throttled.flush = () => {
+    if (pendingArgs !== null) {
+      const args = pendingArgs;
+      pendingArgs = null;
+      clearHandle();
+      fn(...args);
+    } else {
+      clearHandle();
+    }
+  };
+  return throttled;
+}
+
+// src/internal/timing/throttled-input/index.ts
 var DEFAULT_SUB_ID = "throttled-input:settle";
 function initThrottledInput() {
   return { lastAt: null, pending: null };
@@ -84,6 +129,6 @@ function createThrottledInput(config) {
   };
 }
 
-export { createThrottledInput, initThrottledInput, input, onFlush, subsFor };
+export { createThrottledInput, initThrottledInput, input, onFlush, subsFor, throttle };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/timing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internal/timing/throttle/index.ts","../../src/internal/timing/throttled-input/index.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * internal/timing/throttle — a timer-based call transformer that caps invocation\n * to at most once per `ms` window.\n *\n * Sibling of `../debounce` — the two share a SYMMETRIC surface\n * (`Throttled<A>` / `Debounced<A>`, both callable + `.cancel()` + `.flush()`,\n * both `{ leading?, trailing? }`) so they read as a pair. They are kept in\n * separate files with NO cross-import: each is a self-contained timer, and the\n * coalesce-vs-drop policies differ enough that sharing code would hide the\n * distinction. The contrast IS the lesson:\n *\n *   - **debounce** waits for quiet — fires once AFTER a burst settles.\n *   - **throttle** enforces a rate — fires AT MOST once per `ms` while the\n *     burst is ongoing, dropping the calls in between.\n *\n * Layering with `../throttled-input`: `throttle` and `debounce` are\n * the two host-boundary PRIMITIVES — two distinct algorithms\n * (at-most-once-per-window vs collapse-a-burst) behind one signature shape.\n * `throttled-input` is NOT a third primitive: it is a TEA machine composed\n * OVER them (the same semantics, reimplemented as pure, durable Model state)\n * that re-exports both. Wrapping a raw host event → these primitives; durable, replayable\n * gating inside a machine → `throttled-input` (see its module doc for the full\n * layering map).\n *\n * WHAT THIS IS NOT — and why it lives outside `update`:\n *\n *   - NOT a reducer / Transitions cell. Reducers are PURE (invariant 2 — same\n *     inputs → same outputs, no `Date.now`, no timers). A throttle holds a live\n *     `setTimeout` handle and a window cursor; folding it into `update` would\n *     smuggle a timer into the pure core.\n *   - NOT a Sub. A Sub is a continuous SOURCE of Msgs the substrate reconciles\n *     by id every transition (invariant 4). A throttle is a SINK transformer:\n *     it wraps a `void`-returning handler (the canonical one is\n *     `Runtime.dispatch`) so a high-frequency HOST event is rate-limited BEFORE\n *     it ever becomes a Msg.\n *\n * It is a higher-order function at the host boundary (pattern 14 — TEA owns\n * state, JS owns timing). The host attaches the wrapped function to a\n * high-frequency event source (`mousemove`, `scroll`, `pointermove`, a game\n * loop) and the substrate downstream only ever sees the rate-limited Msg:\n *\n *   const onMoved = throttle(\n *     (e: PointerEvent) =>\n *       runtime.dispatch({ type: \"UserMovedCursor\", x: e.clientX, y: e.clientY }),\n *     16, // ~60fps cap\n *   );\n *   window.addEventListener(\"pointermove\", onMoved);\n *   // cleanup: onMoved.cancel(); window.removeEventListener(\"pointermove\", onMoved);\n *\n * Internal since #47 — not published on any subpath; reached from inside the\n * package as `internal/timing/throttle`. Same one-shape-per-package rule as\n * `rate-limit`, `deadline`, and `work-queue`.\n *\n * Uses the universal `setTimeout` / `clearTimeout` timer idiom (same discipline\n * as `subs/from-timeout.ts`): exactly one live handle at a time, the window\n * timer clears itself on expiry, `cancel` / `flush` clear and null it so a\n * stale callback can never run.\n */\n\n/**\n * A throttled wrapper around `fn`. Callable with the SAME argument tuple as\n * `fn` — `(...args: A) => void` — plus two control methods that share names and\n * shapes with `Debounced<A>` so the two modules read as a symmetric pair.\n */\nexport interface Throttled<A extends readonly unknown[]> {\n  /** Invoke `fn` if the window is open, else record args for the trailing fire. */\n  (...args: A): void;\n  /**\n   * Drop any pending trailing fire WITHOUT invoking `fn`, and close the active\n   * window. Clears the timer, forgets the captured trailing args, and resets\n   * the cursor so the next call fires immediately on the leading edge (if\n   * `leading` is enabled). Idempotent.\n   *\n   * The host-cleanup partner of `removeEventListener`: cancel the pending fire\n   * when the component unmounts / the listener detaches, so a queued\n   * `dispatch` can't land after teardown.\n   */\n  cancel(): void;\n  /**\n   * Fire any pending trailing call IMMEDIATELY with its latest captured args,\n   * then close the window. No-op when nothing is pending. Use to force the last\n   * dropped call out early — e.g. flush the final cursor position when a drag\n   * ends, so the rest state isn't a stale mid-drag sample.\n   */\n  flush(): void;\n}\n\n/**\n * Wrap `fn` so it runs AT MOST once per `ms` window, no matter how often it is\n * called.\n *\n * Leading + trailing (the default): the first call fires `fn` IMMEDIATELY (the\n * leading edge) and opens a `ms` window. Calls during the window are dropped\n * from immediate firing but their args are remembered; when the window closes,\n * `fn` fires ONCE more with the LATEST dropped args (the trailing edge) and a\n * new window opens. A call after the window has already closed leads a fresh\n * window immediately. Spacing every call at least `ms` apart therefore fires\n * each one on its own leading edge.\n *\n * @param fn   The handler to rate-limit. Typically `(...) => runtime.dispatch(...)`,\n *             but any `(...args: A) => void` works. The return value is\n *             ignored — throttle is a fire transformer, not a value pipe.\n * @param ms   Window length in milliseconds. `fn` fires at most once per `ms`.\n * @param opts.leading   Fire on the FIRST call of a window (the leading edge),\n *             immediately. Default `true`.\n * @param opts.trailing  Fire once at window END with the latest args dropped\n *             during the window. Default `true`.\n *\n * Edge combinations (matching lodash's settled semantics, the de-facto\n * standard the ecosystem rediscovered):\n *\n *   - `{ leading: true, trailing: true }` (default): immediate fire + a\n *     trailing fire per window while calls keep arriving. The trailing fire is\n *     SUPPRESSED when no extra call arrived during the window (a lone call\n *     already fired on the leading edge — no stale trailing double-fire).\n *   - `{ leading: true, trailing: false }`: only the immediate fire; everything\n *     in the window is dropped with no catch-up at the end.\n *   - `{ leading: false, trailing: true }`: no immediate fire; the FIRST call\n *     opens a window and `fn` fires at the window's end with the latest args.\n *     Steady \"sample every `ms`\" behavior with no instant response.\n *   - `{ leading: false, trailing: false }`: never fires. Degenerate but legal;\n *     we don't throw — the caller asked for a no-op transformer.\n *\n * WHY a default of leading + trailing both `true`: a throttle's job is \"respond\n * now, then keep responding at a steady rate.\" Leading gives the instant\n * response (the first `mousemove` updates immediately); trailing guarantees the\n * FINAL sample of a window isn't lost (the cursor ends where the user actually\n * left it, not one window-width behind). Dropping either loses one of those two\n * guarantees, so both default on.\n */\nexport function throttle<A extends readonly unknown[]>(\n  fn: (...args: A) => void,\n  ms: number,\n  opts?: { leading?: boolean; trailing?: boolean },\n): Throttled<A> {\n  const leading = opts?.leading ?? true;\n  const trailing = opts?.trailing ?? true;\n\n  // Exactly one live handle at a time (the from-timeout discipline). `null`\n  // when no window is open — the single source of truth for \"is a window\n  // active?\". The window timer arms on a fire and clears itself on expiry; the\n  // call path never stacks overlapping timers.\n  let handle: ReturnType<typeof setTimeout> | null = null;\n  // The latest args seen DURING an open window, held for the trailing fire.\n  // Overwritten by every dropped call (the trailing edge fires with the LAST\n  // args), cleared the instant we fire / cancel. `null` (not `undefined`) is\n  // the empty sentinel because `A` may itself contain `undefined` elements — a\n  // present-but-empty tuple is still a pending call, distinct from \"nothing\n  // pending\".\n  let pendingArgs: A | null = null;\n\n  function clearHandle(): void {\n    if (handle !== null) {\n      clearTimeout(handle);\n      handle = null;\n    }\n  }\n\n  // Window expiry: the `ms` window just closed. If a call arrived during the\n  // window (`pendingArgs !== null`) and trailing is enabled, fire it now and\n  // open a FRESH window so the rate cap continues across a sustained burst.\n  // If nothing was dropped, let the window close (handle → null) so the next\n  // call leads a new window immediately.\n  function onWindowExpired(): void {\n    if (trailing && pendingArgs !== null) {\n      const args = pendingArgs;\n      pendingArgs = null;\n      // Re-arm BEFORE firing so a re-entrant call from inside `fn` sees an open\n      // window (and is correctly dropped/queued) rather than leading a second\n      // window — keeps the \"at most once per `ms`\" invariant under re-entry.\n      handle = setTimeout(onWindowExpired, ms);\n      fn(...args);\n    } else {\n      // No trailing fire owed — close the window.\n      handle = null;\n    }\n  }\n\n  const throttled = (...args: A): void => {\n    if (handle === null) {\n      // Window is closed → this call leads a new window.\n      if (leading) {\n        fn(...args);\n      } else if (trailing) {\n        // No leading fire, but trailing wants the first call's args so the\n        // window's end has something to fire. Without this, a leading:false\n        // throttle would swallow a lone call entirely.\n        pendingArgs = args;\n      }\n      handle = setTimeout(onWindowExpired, ms);\n    } else if (trailing) {\n      // Window is open → drop this call from immediate firing, but remember its\n      // args as the latest candidate for the trailing edge.\n      pendingArgs = args;\n    }\n    // Window open + trailing disabled → pure drop, nothing to remember.\n  };\n\n  throttled.cancel = (): void => {\n    clearHandle();\n    pendingArgs = null;\n  };\n\n  throttled.flush = (): void => {\n    // Force the pending trailing fire out now and close the window. Mirrors\n    // `onWindowExpired`'s fire branch but is caller-driven, so it tears the\n    // timer down rather than re-arming.\n    if (pendingArgs !== null) {\n      const args = pendingArgs;\n      pendingArgs = null;\n      clearHandle();\n      fn(...args);\n    } else {\n      // Nothing pending — still close a lingering window so a post-flush call\n      // leads cleanly.\n      clearHandle();\n    }\n  };\n\n  return throttled;\n}\n","/**\n * internal/timing/throttled-input — gate a high-frequency input stream into a\n * SETTLED, RATE-CAPPED, optionally DEDUPED sequence of emits, as a TEA knob: one\n * config object + a few pre-wired hooks you spread into your machine.\n *\n * Layering (the throttle-family map): `../throttle` and `../debounce` are the\n * two host-boundary PRIMITIVES — two distinct algorithms\n * (at-most-once-per-window vs collapse-a-burst) behind one signature shape.\n * THIS module is the third name but NOT a third primitive: a TEA machine\n * composed OVER them that re-exports both. Three exports, one layering — not\n * duplication. The reuse list below spells out composition vs reimplemented\n * semantic per sibling.\n *\n * What it reuses, and HOW (composition vs. reimplemented semantic — the two are\n * not the same, so this list keeps them apart):\n *\n *   - `../cache` — COMPOSED directly. The DEDUPE / memoize layer is `../cache`'s\n *     `TtlCache` plus its `get` / `set` / `initCache` ops, called at runtime —\n *     not reinvented. While `cacheTtlMs` is set, an input whose `cacheKey` is\n *     already cached and unexpired is served from the cache and emits NOTHING\n *     (the downstream effect ran once for that key within its TTL); a fresh emit\n *     writes the value into the cache so the next identical input within\n *     `cacheTtlMs` is suppressed. The optional eviction Sub is the consumer's to\n *     wire if they want memory reclaim (this knob's correctness needs only TTL\n *     reads).\n *   - `../deadline` — COMPOSED directly. The settle timer IS a `../deadline`\n *     Sub: `subsFor` builds it via `deadlineSub`, and the subscribe cell +\n *     Msg constructor are RE-EXPORTS of `../deadline`'s own (`subscribeDeadline`\n *     → `subscribeThrottledInput`, `deadlineExceeded` → `throttledInputSettled`).\n *     The timer lifecycle stays owned by `../deadline`; this knob redraws none\n *     of it.\n *   - `../throttle` / `../debounce` — TYPE + SEMANTIC reuse only, NOT composed.\n *     Those siblings are host-boundary SINK transformers that hold a live\n *     `setTimeout`; a `setTimeout` in a closure is exactly what a durable,\n *     replayable knob must NOT hold. So their CODE is never called here. Instead\n *     the RATE-cap semantic (\"at most once per `ms`\", leading-edge) and the\n *     SETTLE semantic (\"wait until quiet\", trailing-edge) are REIMPLEMENTED as\n *     pure Model state: `lastAt` is the durable rate cursor (half-open cutoff\n *     `at - lastAt >= throttleMs`), and `pending` + the `../deadline` Sub realize\n *     the debounce window inside `update`. The `throttle` / `debounce`\n *     transformers themselves are RE-EXPORTED (the only reuse of their actual\n *     code) so a consumer can pre-throttle / pre-coalesce a genuinely bursty\n *     HOST event at the boundary BEFORE it ever becomes an `input` Msg — a\n *     separate, optional escape hatch, not part of this knob's gates.\n *\n * \"Omit a brick, omit its gate\" (the resilient-call config rule): every gate\n * field is optional. Omit `throttleMs` → no rate cap (every input passes the\n * rate gate). Omit `debounceMs` → no settle wait (an input that clears the rate\n * gate emits IMMEDIATELY rather than being held). Omit `cacheTtlMs` → no cache\n * slice at all (the `cache` field is absent; no dedupe). A config with all three\n * omitted is a pass-through: `input` always emits.\n *\n * Why this is a knob and not hand-wired logic: the managed state (`lastAt`,\n * `pending`, `cache`) lives in the Model, so it survives DO eviction / reload\n * (durable) and every transition is still a Msg through `update` (replayable). A\n * closure holding a `setTimeout` and a mutable \"last value\" would break both —\n * banned. `input` / `onFlush` are PURE: time arrives as an `at` parameter, never\n * `Date.now()`; they return NEW slice values, never mutate.\n *\n * Typical wiring (combinator form):\n *\n *   const search = createThrottledInput<string, Msg>({\n *     debounceMs: 200,        // wait for the user to stop typing\n *     throttleMs: 1_000,      // but never fire more than 1/s during a long burst\n *     cacheTtlMs: 30_000,     // skip a query repeated within 30s\n *     cacheKey: (q) => q,\n *     emit: (q) => ({ type: \"RunSearch\", query: q }),\n *   });\n *\n *   // Model:        { search: ThrottledInput<string>, ... }\n *   // init:         (loaded) => [loaded ?? { search: search.init(), ... }, []]\n *   // update cells:\n *   //   QueryTyped:   (s, m) => mapInput(s, search.input(s.search, m.value, m.at))\n *   //   SettleFired:  (s, m) => mapInput(s, search.onFlush(s.search, m.atMs))\n *   // subscriptions: (s) => search.subs(s.search)\n *   // subscribe:     { ...search.handlers() }\n *\n * where `mapInput(s, [slice, cmds]) => [{ ...s, search: slice }, cmds]` lifts the\n * slice transition into the consumer's Model. The `RunSearch` Cmd's interpret\n * handler is the consumer's — it is where the settled input meets I/O.\n *\n * NOT a substrate primitive: it depends only on sibling subpaths (`../throttle`,\n * `../debounce`, `../cache`, `../deadline`) and the core `Cmd` / `Sub` types.\n * Internal since #47 — reached from inside the package as\n * `internal/timing/throttled-input`; the L1 escape hatch is those siblings\n * threaded by hand. Same one-shape-per-package rule as `batch-window` and `poller`.\n */\n\nimport type { Cmd, Sub } from \"../../../index\";\nimport {\n  get as cacheGet,\n  set as cacheSet,\n  initCache,\n  type TtlCache,\n} from \"../../resilience/cache\";\nimport { type DeadlineSub, deadlineSub } from \"../../resilience/deadline\";\n\n// `../throttle` + `../debounce` — host-boundary pre-transformers (see file\n// header). Re-exported so a consumer that wants to throttle/debounce a bursty\n// HOST source BEFORE it becomes an `input` Msg reaches them from the same\n// import as the durable gate.\nexport { type Debounced, debounce } from \"../debounce\";\nexport { type Throttled, throttle } from \"../throttle\";\n\n/**\n * The gate fields every throttled-input config shares, regardless of whether\n * dedupe is on. The two dedupe variants below extend this with mutually\n * exclusive cache fields.\n *\n * `emit` is a pure Cmd CONSTRUCTOR, not a closure-with-state: it maps a settled\n * value to the single Cmd the runtime performs when the gates let a value\n * through. Keeping it `(value) => Cmd` (not `(value) => void`) is what keeps the\n * trigger replayable — the emit is a Cmd in the transition's output, never a\n * side effect inside the verb (mirrors `batch-window`'s `flush`).\n */\ninterface ThrottledInputGates<V, C extends Cmd> {\n  /**\n   * Rate cap, in milliseconds. An input that lands within `throttleMs` of the\n   * last EMIT (`at - lastAt < throttleMs`) is dropped from immediate firing —\n   * the leading-edge \"at most once per `throttleMs`\" rate-cap rule, applied to\n   * emits. The half-open cutoff (`>=` passes) matches `../throttle` and\n   * `../cache`'s window-edge convention. Omit for no rate cap.\n   *\n   * Interacts with `debounceMs`: when both are set, a rate-blocked input is\n   * still HELD as `pending` (so the settle timer eventually trails it out at a\n   * legal moment) rather than silently dropped — the trailing-edge guarantee\n   * that the FINAL sample of a window is never lost.\n   */\n  readonly throttleMs?: number;\n  /**\n   * Settle wait, in milliseconds. An input that clears the rate gate is not\n   * emitted immediately; it is held as `pending` and a debounce deadline is\n   * armed at `pendingAt + debounceMs`. A fresh input re-arms (slides) the\n   * window. `onFlush` emits the pending value when the window finally expires.\n   * Omit for no settle wait — a passing input emits on arrival.\n   */\n  readonly debounceMs?: number;\n  /**\n   * Map a settled value to the single Cmd the runtime performs. Called with the\n   * value the gates let through; the returned Cmd is what `input` / `onFlush`\n   * emit. PURE constructor — no I/O, no clock; the I/O happens later in the\n   * consumer's interpret handler for the returned Cmd.\n   */\n  readonly emit: (value: V) => C;\n}\n\n/**\n * Configuration for a throttled input — the knob. Pure config, no mutable state\n * (the `ThrottledInput<V>` slice carries that). One config object is shared\n * across every input of one logical stream (often a module-scope const).\n *\n * A DISCRIMINATED UNION on the presence of dedupe, so the type system makes a\n * cache-key collision UNREPRESENTABLE (\"omit a brick, omit its gate\"):\n *\n *   - **No dedupe** (`ThrottledInputNoCache`): `cacheTtlMs` absent ⇒ no cache\n *     slice, no dedupe. `cacheKey` is statically forbidden here (`never`) — a\n *     key with no cache to feed is dead config, so the type rejects it rather\n *     than silently ignoring it.\n *   - **Dedupe** (`ThrottledInputWithCache`): `cacheTtlMs` set ⇒ `cacheKey` is\n *     REQUIRED. There is no `String(value)` default to fall back to, so a\n *     structured value can NEVER collapse two distinct values to one slot (the\n *     `\"[object Object]\"` collision). The consumer must state the identity that\n *     keys the cache; a primitive stream still trivially passes `(v) => v` /\n *     `String`, but it does so EXPLICITLY.\n */\nexport type ThrottledInputConfig<V, C extends Cmd> =\n  | ThrottledInputNoCache<V, C>\n  | ThrottledInputWithCache<V, C>;\n\n/**\n * The no-dedupe config variant: gates only, no cache. `cacheTtlMs` is absent\n * and `cacheKey` is statically `never` so a stray key (which would feed no\n * cache) is a type error, not a silently-ignored field.\n */\nexport interface ThrottledInputNoCache<V, C extends Cmd>\n  extends ThrottledInputGates<V, C> {\n  readonly cacheTtlMs?: undefined;\n  readonly cacheKey?: never;\n}\n\n/**\n * The dedupe config variant: a per-entry TTL plus a REQUIRED `cacheKey`. An\n * input whose `cacheKey` is already cached and unexpired emits NOTHING (the\n * downstream effect ran once for that key within its TTL); a fresh emit writes\n * the value into the cache.\n *\n * `cacheKey` is required (no `String(value)` default) precisely so a structured\n * value cannot silently collide — the consumer names the identity, the cache\n * keys on exactly that.\n */\nexport interface ThrottledInputWithCache<V, C extends Cmd>\n  extends ThrottledInputGates<V, C> {\n  /**\n   * Dedupe / memoize TTL, in milliseconds. An input whose `cacheKey` is already\n   * cached and unexpired emits NOTHING; a fresh emit writes the value into the\n   * cache so the next identical input within `cacheTtlMs` is suppressed.\n   */\n  readonly cacheTtlMs: number;\n  /**\n   * Key a value for the dedupe cache. REQUIRED whenever `cacheTtlMs` is set:\n   * there is no `String(value)` fallback, so a structured value's identity is\n   * always the consumer's explicit choice and two distinct values can never\n   * collapse to one slot. A primitive stream passes `(v) => v` / `String`.\n   */\n  readonly cacheKey: (value: V) => string;\n}\n\n/**\n * The Model slice a throttled input owns — its visible slice (the knob\n * principle: managed state lives in the Model, never a closure, so it is durable\n * and replayable).\n *\n * - `lastAt`  — the `at` of the most recent EMIT, or `null` before the first\n *               emit. The `../throttle` rate cap measures against it: an input\n *               within `throttleMs` of `lastAt` is rate-blocked. Persisted so a\n *               resumed gate keeps its rate cursor.\n * - `pending` — the value HELD for the settle (debounce) window, paired with the\n *               `at` it was held (the anchor the deadline targets), or `null`\n *               when nothing is waiting. The single source of truth for \"is a\n *               settle window open?\" — the debounce timer Sub arms iff this is\n *               non-null.\n * - `cache`   — the `../cache` TTL store backing dedupe, present IFF\n *               `cacheTtlMs` is configured. Absent (the field omitted) for a\n *               gate with no dedupe — no per-op cost, nothing to serialize.\n */\nexport interface ThrottledInput<V> {\n  readonly lastAt: number | null;\n  readonly pending: PendingInput<V> | null;\n  readonly cache?: TtlCache<V>;\n}\n\n/**\n * A value held for the settle window: the `value` itself and the `at` it was\n * held (the anchor the debounce deadline targets, `at + debounceMs`). A distinct\n * type (not a bare `V`) because `V` may itself be `null` — a present-but-null\n * value is still a real pending input, distinct from \"nothing pending\", exactly\n * the `null`-sentinel discipline `../throttle` / `../debounce` use for their\n * `pendingArgs`.\n */\nexport interface PendingInput<V> {\n  readonly value: V;\n  readonly at: number;\n}\n\n/**\n * The Sub variant a throttled input's settle timer produces — a `../deadline`\n * Sub (so the window fires at the correct ABSOLUTE moment even after a late\n * subscribe / rehydrate, and so a consumer running several gates routes each by\n * `id`). `atMs` is the absolute settle-by instant (`pendingAt + debounceMs`).\n */\nexport type ThrottledInputSub = DeadlineSub;\n\n/**\n * The stable Sub id the gate arms its settle deadline under. A single gate arms\n * exactly one settle timer at a time, so one id suffices; a consumer running\n * several gates on one machine namespaces them by composing the knob under\n * distinct slices with distinct ids (the `subs(state, id)` parameter).\n */\nconst DEFAULT_SUB_ID = \"throttled-input:settle\";\n\n/**\n * The starting slice: no prior emit, nothing pending. The `cache` field is\n * seeded only when `cacheTtlMs` is configured (see `createThrottledInput`); the\n * free `initThrottledInput` leaves it absent (the no-dedupe shape).\n */\nexport function initThrottledInput<V>(): ThrottledInput<V> {\n  return { lastAt: null, pending: null };\n}\n\n/**\n * Resolve a value's cache key under a DEDUPE config. PURE. Takes the narrowed\n * `ThrottledInputWithCache` (not the union) because `cacheKey` is only present —\n * and only meaningful — when dedupe is on; there is no `String(value)` default\n * to fall back to, so a structured value's identity is always the consumer's\n * explicit choice and two distinct values can never collapse to one slot.\n */\nfunction keyOf<V, C extends Cmd>(\n  config: ThrottledInputWithCache<V, C>,\n  value: V,\n): string {\n  return config.cacheKey(value);\n}\n\n/**\n * Narrow `config` to its dedupe variant iff a cache slice is actually wired —\n * `cacheTtlMs` set AND a `cache` store present. Returns the narrowed config\n * (carrying the required `cacheKey`) paired with the resolved `cache` store, or\n * `null` when no dedupe is configured. The single place the union is\n * discriminated, so `isCacheHit` / `commitEmit` share one narrowing — and reuse\n * the resolved `cache` — rather than re-deriving the predicate and re-narrowing\n * `state.cache`.\n */\nfunction cacheConfig<V, C extends Cmd>(\n  config: ThrottledInputConfig<V, C>,\n  state: ThrottledInput<V>,\n): {\n  readonly config: ThrottledInputWithCache<V, C>;\n  readonly cache: TtlCache<V>;\n} | null {\n  return config.cacheTtlMs !== undefined && state.cache !== undefined\n    ? { config, cache: state.cache }\n    : null;\n}\n\n/**\n * Whether `value` is a cache HIT under `config` at `at` — present and unexpired.\n * PURE — reads only. Always `false` when `cacheTtlMs` is unset or no `cache`\n * slice exists (no dedupe configured), so the dedupe gate is a no-op for an\n * unconfigured gate.\n */\nfunction isCacheHit<V, C extends Cmd>(\n  config: ThrottledInputConfig<V, C>,\n  state: ThrottledInput<V>,\n  value: V,\n  at: number,\n): boolean {\n  const cached = cacheConfig(config, state);\n  if (cached === null) return false;\n  return cacheGet(cached.cache, keyOf(cached.config, value), at) !== undefined;\n}\n\n/**\n * Emit `value` at clock `at`: bump the rate cursor, refresh the dedupe cache,\n * and clear any pending hold. PURE. The single place an emit's bookkeeping\n * lives, shared by `input` (immediate emit) and `onFlush` (trailing emit) so the\n * two paths can never drift on what an emit updates.\n *\n * - `lastAt` advances to `at` — the next input is rate-measured against this\n *   emit, the `../throttle` window cursor.\n * - `cache` (when configured) records `value` under its key with `cacheTtlMs`\n *   from `at` — so the next identical input within the TTL is suppressed.\n * - `pending` clears — the value just went out; nothing is waiting.\n */\nfunction commitEmit<V, C extends Cmd>(\n  config: ThrottledInputConfig<V, C>,\n  state: ThrottledInput<V>,\n  value: V,\n  at: number,\n): readonly [ThrottledInput<V>, readonly C[]] {\n  const cached = cacheConfig(config, state);\n  const cache =\n    cached !== null\n      ? cacheSet(\n          cached.cache,\n          keyOf(cached.config, value),\n          value,\n          at,\n          cached.config.cacheTtlMs,\n        )\n      : state.cache;\n  const next: ThrottledInput<V> = {\n    ...state,\n    lastAt: at,\n    pending: null,\n    ...(cache !== undefined ? { cache } : {}),\n  };\n  return [next, [config.emit(value)]];\n}\n\n/**\n * Feed a new input `value` arriving at clock `at` through the gates. PURE.\n *\n * The gate order is DEDUPE → RATE → SETTLE (each skipped when its config field\n * is omitted), the same cache-first-then-gate order `resilient-call` uses (a hit\n * short-circuits before the expensive path):\n *\n *   1. **Dedupe** (`cacheTtlMs` set): if `value`'s key is cached and unexpired,\n *      suppress — return the slice UNCHANGED (no emit, no pending, no re-arm).\n *      The downstream effect already ran for this key within its TTL.\n *   2. **Rate** (`throttleMs` set): if `at` is within `throttleMs` of the last\n *      emit (`at - lastAt < throttleMs`), this input is rate-blocked.\n *        - With `debounceMs` set → HOLD it as `pending` (the trailing edge: the\n *          settle timer will emit it at a legal moment, so the final sample is\n *          never lost). The deadline `subs` arms targets `at + debounceMs`.\n *        - Without `debounceMs` → DROP it (pure rate cap, no catch-up).\n *   3. **Settle** (`debounceMs` set): the input cleared the rate gate. HOLD it\n *      as `pending` and let the debounce window slide; `onFlush` emits it once\n *      the window expires. A fresh input before expiry overwrites `pending` (the\n *      trailing edge fires with the LAST value, the `../debounce` default).\n *   4. **Pass-through**: no `debounceMs`, cleared the rate gate → EMIT now.\n *\n * @param config the knob (the three optional gates + `emit`)\n * @param state  the current slice\n * @param value  the input value\n * @param at     the arrival instant (epoch ms) — the caller stamps it; the verb\n *               never reads the clock\n */\nexport function input<V, C extends Cmd>(\n  config: ThrottledInputConfig<V, C>,\n  state: ThrottledInput<V>,\n  value: V,\n  at: number,\n): readonly [ThrottledInput<V>, readonly C[]] {\n  // 1. Dedupe gate — a cached, unexpired key short-circuits everything.\n  if (isCacheHit(config, state, value, at)) {\n    return [state, []];\n  }\n\n  // 2. Rate gate — half-open cutoff (`>=` passes). `lastAt === null` (no prior\n  // emit) always passes: the first input is never rate-blocked. Shared with\n  // `onFlush` via `rateBlockedAt` so the arrival and trailing-edge paths agree\n  // on the window.\n  if (rateBlockedAt(config, state, at)) {\n    // With a settle window, a rate-blocked input is HELD (trailing edge) so it\n    // emits at the next legal moment; without one, it is a pure drop.\n    if (config.debounceMs !== undefined) {\n      return [{ ...state, pending: { value, at } }, []];\n    }\n    return [state, []];\n  }\n\n  // 3. Settle gate — passed the rate gate; if a debounce window is configured,\n  // hold the value and (re)arm the settle deadline rather than emit now.\n  if (config.debounceMs !== undefined) {\n    return [{ ...state, pending: { value, at } }, []];\n  }\n\n  // 4. Pass-through — no settle wait, cleared the rate gate: emit immediately.\n  return commitEmit(config, state, value, at);\n}\n\n/**\n * Whether emitting at clock `at` would breach the rate cap — `at` lands within\n * `throttleMs` of the last emit (`at - lastAt < throttleMs`). PURE — reads only.\n * Always `false` when `throttleMs` is unset (no rate cap) or before the first\n * emit (`lastAt === null`), so an unconfigured / never-fired gate never holds on\n * the rate gate. The single rate-gate predicate, shared by `input` (drop / hold\n * on arrival) and `onFlush` (re-hold a still-early trailing edge) so the two\n * paths can never drift on what \"within the rate window\" means.\n */\nfunction rateBlockedAt<V, C extends Cmd>(\n  config: ThrottledInputConfig<V, C>,\n  state: ThrottledInput<V>,\n  at: number,\n): boolean {\n  return (\n    config.throttleMs !== undefined &&\n    state.lastAt !== null &&\n    at - state.lastAt < config.throttleMs\n  );\n}\n\n/**\n * Emit the pending value because the settle (debounce) window closed. PURE.\n *\n * - Pending present, rate gate CLEAR → emit `config.emit(pending.value)`,\n *   advance the rate cursor (`lastAt = at`), refresh the dedupe cache, and clear\n *   `pending`. The trailing edge of `../debounce` realized as a Model transition.\n * - Pending present, rate gate STILL BLOCKED → re-HOLD: return the slice with\n *   `pending` intact and NO Cmds. A settle Msg can fire at `pending.at +\n *   debounceMs`, which may still be inside the rate window (`lastAt +\n *   throttleMs`) — emitting then would breach the headline \"at most once per\n *   `throttleMs`\" cap. Re-holding keeps the value waiting; `subs` re-arms the\n *   deadline at `max(pending.at + debounceMs, lastAt + throttleMs)` so the next\n *   timer fires at a LEGAL moment and the trailing edge is deferred, never lost.\n * - Pending absent → no-op: return the same slice and no Cmds. Guards the race\n *   where an `input` already emitted (or a dedupe hit cleared interest) before\n *   the settle timer's Msg lands — a stale `onFlush` must NOT emit. Symmetric\n *   with `batch-window`'s closed-window guard.\n *\n * `at` is the firing instant the settle Msg carried (the caller stamps it; the\n * verb never reads the clock). It becomes the new rate cursor and the cache\n * write's `nowMs`, so a settled emit rate-blocks subsequent inputs from its\n * actual fire moment, not the moment the value was first held.\n *\n * @param config the knob (`throttleMs`, `emit`, cache config)\n * @param state  the current slice\n * @param at     the settle-timer firing instant (epoch ms)\n */\nexport function onFlush<V, C extends Cmd>(\n  config: ThrottledInputConfig<V, C>,\n  state: ThrottledInput<V>,\n  at: number,\n): readonly [ThrottledInput<V>, readonly C[]] {\n  // No pending value = an immediate emit already fired, or a dedupe hit cleared\n  // interest. A stale timer Msg must not emit — return the slice untouched.\n  if (state.pending === null) return [state, []];\n  // Rate gate re-check: a settle Msg can land before the rate window opens (its\n  // naive deadline is pending.at + debounceMs, which `subs` lifts to a legal\n  // target — but a stale / early timer can still arrive). Emitting now would\n  // breach \"at most once per throttleMs\", so re-hold and let `subs` re-arm at\n  // the legal moment. The value stays pending; nothing is dropped.\n  if (rateBlockedAt(config, state, at)) return [state, []];\n  return commitEmit(config, state, state.pending.value, at);\n}\n\n/**\n * The settle timer Sub, derived from the slice. PURE.\n *\n * Returns the single `../deadline` Sub while a value is held AND a settle window\n * is configured, or `[]` otherwise. The deadline target is the LATER of two\n * constraints (so the timer never fires before BOTH are satisfied):\n *\n *   - `pending.at + debounceMs` — the settle (debounce) deadline: the value has\n *     stopped sliding, the burst has gone quiet.\n *   - `lastAt + throttleMs` — the rate cap: emitting earlier would breach \"at\n *     most once per `throttleMs`\". Only applies once a prior emit exists\n *     (`lastAt !== null`) and a rate cap is configured (`throttleMs` set).\n *\n * `max(settleAt, rateAt)` is the earliest LEGAL trailing-edge moment. Anchoring\n * the timer here — rather than the naive `pending.at + debounceMs` — is what\n * keeps the rate cap intact across the trailing edge: a value held while still\n * inside the rate window arms its timer at `lastAt + throttleMs`, so `onFlush`\n * fires at a moment the rate gate already permits. (`onFlush` re-checks the gate\n * anyway and re-holds if an early/stale timer slips through, so the cap holds\n * even if a timer fires ahead of this target.)\n *\n * The substrate's reconcile pass arms the timer when the array gains the Sub and\n * disarms it (clearing the pending `setTimeout`) when the array loses it — so an\n * `onFlush` (or a dedupe hit) that clears `pending` auto-cancels the now-stale\n * settle timer on the next transition, and a sliding input that re-stamps\n * `pending.at` re-arms a fresh absolute target.\n *\n * `debounceMs` undefined ⇒ no settle window ⇒ `[]` even with a `pending` value\n * (an unconfigured settle never holds, but the guard keeps `subs` total).\n *\n * @param config the knob (`debounceMs`, `throttleMs`)\n * @param state  the current slice\n * @param id     stable identity for this gate's settle timer (default\n *               `\"throttled-input:settle\"`); pass a distinct id per gate when a\n *               machine runs several so the dispatched Msg routes distinctly.\n */\nexport function subsFor<V, C extends Cmd>(\n  config: ThrottledInputConfig<V, C>,\n  state: ThrottledInput<V>,\n  id = DEFAULT_SUB_ID,\n): readonly ThrottledInputSub[] {\n  if (config.debounceMs === undefined || state.pending === null) return [];\n  const settleAt = state.pending.at + config.debounceMs;\n  // The rate floor: the earliest moment the rate cap permits an emit. Absent\n  // when no rate cap is configured or no prior emit set a cursor — then the\n  // settle deadline alone governs.\n  const rateAt =\n    config.throttleMs !== undefined && state.lastAt !== null\n      ? state.lastAt + config.throttleMs\n      : settleAt;\n  return [deadlineSub(id, Math.max(settleAt, rateAt))];\n}\n\n/**\n * The bound knob returned by `createThrottledInput`. `init` + the two pure verbs\n * + `subs`, all closing over one `ThrottledInputConfig`. The verbs return\n * `readonly [ThrottledInput<V>, readonly C[]]`: the next slice and the Cmds to\n * emit (one `emit` Cmd when a value passes, none while held / dropped / deduped).\n *\n * Pure-ops + subs module: there is no `handlers(ports)` cell. The settle timer's\n * subscribe cell IS `../deadline`'s `subscribeDeadline` (re-exported below) —\n * the consumer wires it into `subscribe` directly; the knob redraws no timer\n * lifecycle of its own. (Compare `poller`, identical: it too reuses\n * `../deadline`'s cell and ships no `handlers`.)\n */\nexport interface ThrottledInputKnob<V, C extends Cmd> {\n  /** Seed the Model slice (with a cache iff `cacheTtlMs` is configured). */\n  init(): ThrottledInput<V>;\n  /**\n   * Feed a new input through the dedupe → rate → settle gates. See `input`.\n   */\n  input(\n    state: ThrottledInput<V>,\n    value: V,\n    at: number,\n  ): readonly [ThrottledInput<V>, readonly C[]];\n  /**\n   * Emit the held value because the settle window closed. See `onFlush`.\n   */\n  onFlush(\n    state: ThrottledInput<V>,\n    at: number,\n  ): readonly [ThrottledInput<V>, readonly C[]];\n  /**\n   * The settle timer Sub, armed only while a value is held. See `subsFor`.\n   * `id` keys the deadline so several gates on one machine route distinctly.\n   */\n  subs(state: ThrottledInput<V>, id?: string): readonly Sub[];\n}\n\n/**\n * Build a throttled-input knob from `config`. Combinator form (the default L2\n * ergonomic): hand it the config, splice the returned hooks into your machine.\n * The pure verbs (`input` / `onFlush`) close over the config so the consumer's\n * reducer cells stay a uniform `(state, ...args)` shape; `subs` pre-wires the\n * settle timer.\n *\n * `init()` seeds a `cache` slice IFF `cacheTtlMs` is configured — an unconfigured\n * gate carries no cache field (nothing to serialize, no dedupe). Pure factory —\n * no clock read, no timer; everything happens when the consumer calls the\n * returned verbs / `subs` with an injected `at`.\n *\n * @typeParam V the input value type\n * @typeParam C the Cmd type `config.emit` returns\n */\nexport function createThrottledInput<V, C extends Cmd>(\n  config: ThrottledInputConfig<V, C>,\n): ThrottledInputKnob<V, C> {\n  function init(): ThrottledInput<V> {\n    const base = initThrottledInput<V>();\n    // Seed the cache only when dedupe is configured — an unconfigured gate\n    // carries no cache field at all (the no-dedupe shape).\n    return config.cacheTtlMs !== undefined\n      ? { ...base, cache: initCache<V>() }\n      : base;\n  }\n\n  return {\n    init,\n    input: (state, value, at) => input(config, state, value, at),\n    onFlush: (state, at) => onFlush(config, state, at),\n    subs: (state, id) => subsFor(config, state, id),\n  };\n}\n\n/**\n * The settle-timer wiring, RE-EXPORTED from `../deadline` (not redrawn) so the\n * timer lifecycle stays owned there. Consolidated into one `export ... from`:\n *\n *   - `subscribeThrottledInput` (= `../deadline`'s `subscribeDeadline`) — the\n *     `subscribe[\"deadline\"]` cell. Arms a one-shot timer for `max(0, atMs -\n *     now)`, dispatches the deadline Msg, returns a cleanup that clears it. The\n *     consumer assigns it: `subscribe: { deadline: subscribeThrottledInput }`.\n *   - `throttledInputSettled` (= `../deadline`'s `deadlineExceeded`) +\n *     `ThrottledInputSettled` (= `DeadlineExceeded`) — the settle-timer Msg\n *     constructor and type the consumer handles via `onFlush`. Sharing one\n *     constructor with the subscribe cell keeps the two from drifting; the\n *     reducer reads `msg.atMs` as the `at` it threads into `onFlush`.\n */\nexport {\n  type DeadlineExceeded as ThrottledInputSettled,\n  deadlineExceeded as throttledInputSettled,\n  subscribeDeadline as subscribeThrottledInput,\n} from \"../../resilience/deadline\";\n"]}

package/dist/{types-XS_miRnB.d.ts → types-BseNPIhr.d.ts}

@@ -1,4 +1,4 @@
-import { S as Sub } from './core-Co0LWkIA.js';
+import { S as Sub } from './core-DnzqWy6u.js';
 
 type SubscribeHandler<S extends Sub, M, Ctx> = (sub: S, ctx: Ctx, dispatch: (msg: M) => void) => () => void;
 

package/dist/work-queue/index.d.ts

@@ -1,73 +1,149 @@
-import { S as Store } from '../runtime-types-CNLmhWif.js';
+import { Q as QueueItem } from '../index-CSyMYDAB.js';
+export { E as EnqueueInput, a as QueueItemStatus, c as createQueue } from '../index-CSyMYDAB.js';
+import '../runtime-types-CMF13BBh.js';
 import 'better-result';
-import '../core-Co0LWkIA.js';
+import '../core-DnzqWy6u.js';
 import 'zod';
 
 /**
- * @packageDocumentation
- * @demlik/tea/work-queue — substrate-agnostic work-queue lifecycle on `Store<S>`.
+ * internal/work-queue/adapter — the verb seam over the pure queue ops.
  *
- * Two public surfaces, one shape:
- *   - `createQueue(store)` (this file) is the in-process adapter — it binds the
- *     pure ops to an injected `Store` and runs `load → mutate → save`.
- *   - `@demlik/tea/work-queue/ops` (`./ops`) is the BLESSED, importable surface
- *     of those same pure ops. L2 compositions that own their own Model slice
- *     (`monitored-run`, `idempotent-intake`, …) import the ops directly and
- *     delegate status flips to them instead of re-rolling the transitions.
- * Both routes call the identical ops, so the lifecycle rules live in exactly
- * one place. This mirrors `@demlik/tea/do`'s one-shape-per-package rule.
+ * The pure ops in `./ops` are the BLESSED transitions, but their names and
+ * argument tuples (`enqueueOp(queue, input, now, id)`, `claimNextOp(queue,
+ * now)`, …) and their `{ next, item }` / `{ next, changed }` result shapes are
+ * the STORE's vocabulary, not the consumer's. An L2 composition that owns a
+ * `QueueItem<I>[]` slice (`monitored-run`, `saga`, `idempotent-intake`,
+ * `fan-out`) used to import those ops by name and call them directly, so a
+ * change to the op surface — or to `QueueItem`'s fields — cascaded to every
+ * call site.
  *
- * The package is generic in the input payload `I` (audit-specific fields go
- * here in the extension host). `output` is a free-form side-channel correlation
- * token (a backend id, URL, trace id) — typed as `string` because that's its
- * only honest type. Consumers that need structured per-item data persist it in
- * their own store and put the foreign-key string in `output`.
+ * `QueueAdapter<I>` is the insulating interface: four VERBS (`enqueue` /
+ * `claim` / `markDone` / `patch`) that consumers depend on instead of the raw
+ * ops. The verbs keep the ops' pure `(queue, …) => { next, … }` contract — they
+ * are pure array transforms, no I/O, no `Date.now` (the clock is injected as
+ * `now`, exactly as the ops require it) — so a consumer folding the adapter
+ * through its reducer stays inside invariant 2 (pure transitions).
+ *
+ * `queueAdapter<I>()` is the canonical implementation, a thin binding of the
+ * blessed ops. Because the verbs are the only surface consumers touch, a
+ * `QueueItem` shape change (a new field, a renamed status, a different op
+ * signature) is now absorbed HERE — re-bind the verb once — rather than at the
+ * 4 consumer call sites. The `patch` verb deliberately takes the same
+ * `(item) => item` closure `patchItemOp` does, so the one place a `QueueItem`
+ * literal is spread stays the consumer's patch closure, never a re-rolled
+ * record.
+ *
+ * This is an INTERNAL seam (no public-API port): consumers import the adapter
+ * from this subpath the same way they imported the ops. The ops remain
+ * exported for the in-process `createQueue` adapter (`./index`) and for any
+ * call site that genuinely wants the op directly.
  */
 
-type QueueItemStatus = "pending" | "running" | "done" | "failed" | "cancelled";
 /**
- * A single queue entry. Every field is `readonly`: a persisted slice is
- * immutable, so a transition returns a NEW item (the ops always spread —
- * `{ ...item, status: … }`) rather than mutating in place. This type-enforces
- * the durability invariant the consumers already honor by convention, and
- * keeps a slice round-trippable through JSON unchanged across a reload.
+ * The verb interface over a `QueueItem<I>[]` slice. Each verb mirrors a blessed
+ * op's pure contract but speaks the consumer's lifecycle vocabulary, so the
+ * consumer never names a `*Op` function or reaches into a `QueueItem` field it
+ * did not put there.
  */
-interface QueueItem<I> {
-    readonly id: string;
-    readonly status: QueueItemStatus;
-    readonly input: I;
-    readonly enqueuedAt: number;
-    readonly startedAt?: number;
-    readonly finishedAt?: number;
-    readonly output?: string;
-    readonly error?: string;
+interface QueueAdapter<I> {
+    /** Append a new `pending` item stamped `now` under `id`. */
+    enqueue(queue: readonly QueueItem<I>[], input: I, now: number, id: string): {
+        next: QueueItem<I>[];
+        item: QueueItem<I>;
+    };
+    /**
+     * Claim the first `pending` item — flip it `running`, stamp `startedAt` to
+     * `now` — or `null` if nothing is pending.
+     */
+    claim(queue: readonly QueueItem<I>[], now: number): {
+        next: QueueItem<I>[];
+        claimed: QueueItem<I>;
+    } | null;
+    /** Drop the item `id` from the queue (completed runs leave the queue). */
+    markDone(queue: readonly QueueItem<I>[], id: string): {
+        next: QueueItem<I>[];
+        changed: boolean;
+    };
+    /**
+     * Single-item transition: replace the item `id` with `patch(item)`. The
+     * closure is the only place a `QueueItem` literal is constructed, so the
+     * field shape stays out of the consumer's hands except through this verb.
+     */
+    patch(queue: readonly QueueItem<I>[], id: string, patch: (item: QueueItem<I>) => QueueItem<I>): {
+        next: QueueItem<I>[];
+        changed: boolean;
+    };
 }
 /**
- * Caller-facing enqueue payload. Just `I` today — kept named so future
- * variants (priority, deferUntil, …) can grow without breaking callers.
+ * The canonical `QueueAdapter<I>`, binding each verb to its blessed op. Pure
+ * and stateless — call once at module scope in a consumer and fold its verbs
+ * through the reducer. A `QueueItem` shape change is absorbed by re-binding a
+ * verb here, not at the consumers.
  */
-type EnqueueInput<I> = I;
+declare function queueAdapter<I>(): QueueAdapter<I>;
+
 /**
- * Adapter that binds the pure ops to an injected `Store<QueueItem<I>[]>`.
+ * Pure queue-lifecycle ops over `QueueItem<I>[]` — the BLESSED delegation
+ * surface for this package.
+ *
+ * Each op is `(queue, ...args) => { next, result? }`. No I/O, no Date.now
+ * indirection beyond a plain call site — the adapter in `./index.ts` injects
+ * `Store<QueueItem<I>[]>` and orchestrates `load → mutate → save`.
  *
- * `load → mutate → save` is the only durability discipline this package
- * imposes. The store decides what "save" means (chrome.storage, KV, DO
- * storage, in-memory) — that decision belongs at the caller.
+ * Substrate-agnostic by construction: nothing here references chrome.storage,
+ * Cloudflare, or any concrete persistence layer. The audit-specific shape
+ * (journeyId, projectId, ...) is lifted into the caller's `I` parameter.
  *
- * Ops that don't change the queue (e.g. `markDone` on an unknown id) skip the
- * save call so the underlying store doesn't observe a write churn.
+ * Importable two ways. The `createQueue(...)` adapter in `./index.ts` binds
+ * these ops to a `Store` for in-process use (same one-shape-per-package rule
+ * as `@demlik/tea/do`). L2 compositions that own their own Model slice
+ * (`monitored-run`, `idempotent-intake`, …) instead reach these ops directly
+ * from `internal/work-queue/ops`, so a status flip is delegated
+ * here rather than re-rolled per call site.
+ */
+
+/** Append a new pending item. Returns the new queue and the created item. */
+declare function enqueueOp<I>(queue: readonly QueueItem<I>[], input: I, now: number, id: string): {
+    next: QueueItem<I>[];
+    item: QueueItem<I>;
+};
+/**
+ * Claim the first pending item by flipping it to `running` and stamping
+ * `startedAt`. Returns the new queue and the claimed item, or `null` if no
+ * pending item exists.
  */
-declare function createQueue<I>(store: Store<QueueItem<I>[]>): {
-    enqueue: (input: EnqueueInput<I>) => Promise<QueueItem<I>>;
-    claimNext: () => Promise<QueueItem<I> | null>;
-    markDone: (id: string) => Promise<void>;
-    markFailed: (id: string, error: string) => Promise<void>;
-    markCancelled: (id: string) => Promise<void>;
-    resetRunningToPending: () => Promise<void>;
-    removeItem: (id: string) => Promise<void>;
-    retryItem: (id: string) => Promise<void>;
-    bindOutput: (id: string, value: string) => Promise<void>;
-    list: () => Promise<QueueItem<I>[]>;
+declare function claimNextOp<I>(queue: readonly QueueItem<I>[], now: number): {
+    next: QueueItem<I>[];
+    claimed: QueueItem<I>;
+} | null;
+/**
+ * Done items leave the queue — completed runs live wherever the caller
+ * persists their output. Returns the new queue (or the original reference if
+ * no item matched, so the adapter can skip a save).
+ */
+declare function markDoneOp<I>(queue: readonly QueueItem<I>[], id: string): {
+    next: QueueItem<I>[];
+    changed: boolean;
+};
+/**
+ * Generic single-item status transition. Used by `markFailed`,
+ * `markCancelled`, `retryItem`, `bindOutput`. The patch closure receives the
+ * matched item and returns its replacement; returning the same reference is
+ * fine (the adapter only saves on `changed`).
+ */
+declare function patchItemOp<I>(queue: readonly QueueItem<I>[], id: string, patch: (item: QueueItem<I>) => QueueItem<I>): {
+    next: QueueItem<I>[];
+    changed: boolean;
+};
+/** Reset every `running` item back to `pending`, clearing `startedAt`. */
+declare function resetRunningOp<I>(queue: readonly QueueItem<I>[]): {
+    next: QueueItem<I>[];
+    changed: boolean;
+};
+/** Hard-delete an item regardless of status. */
+declare function removeOp<I>(queue: readonly QueueItem<I>[], id: string): {
+    next: QueueItem<I>[];
+    changed: boolean;
 };
 
-export { type EnqueueInput, type QueueItem, type QueueItemStatus, createQueue };
+export { type QueueAdapter, QueueItem, claimNextOp, enqueueOp, markDoneOp, patchItemOp, queueAdapter, removeOp, resetRunningOp };

package/dist/work-queue/index.js

@@ -1,6 +1,7 @@
-import { enqueueOp, claimNextOp, markDoneOp, patchItemOp, resetRunningOp, removeOp } from '../chunk-FV3Z5MBE.js';
+import { enqueueOp, claimNextOp, markDoneOp, patchItemOp, resetRunningOp, removeOp } from '../chunk-TXN2KFHF.js';
+export { claimNextOp, enqueueOp, markDoneOp, patchItemOp, queueAdapter, removeOp, resetRunningOp } from '../chunk-TXN2KFHF.js';
 
-// src/work-queue/index.ts
+// src/internal/work-queue/index.ts
 function genId() {
   return globalThis.crypto?.randomUUID?.() ?? `q_${Date.now()}_${Math.random().toString(36).slice(2)}`;
 }