@graphrefly/ts 0.0.0

package/dist/operators/index.d.cts

@@ -0,0 +1,308 @@
+import { L as Operator } from '../graph-s23RbbFO.cjs';
+export { D as DefineOpts, a as Definition, M as RestoreRegistryEntry, S as SettleOpts, U as TapObserver, $ as ValveOpts, a2 as catchError, a5 as define, a6 as distinctUntilChanged, a7 as elementAt, a8 as filter, aa as find, ab as first, ae as initNode, af as last, ag as map, ai as merge, ak as onFirstData, al as pairwise, am as reduce, an as rescue, ap as restoreRegistry, aq as scan, ar as settle, as as skip, au as take, aw as takeWhile, ax as tap, ay as tapFirst, aA as valve } from '../graph-s23RbbFO.cjs';
+import { N as NodeInput } from '../index-CAEmLCYF.cjs';
+import { N as Node } from '../types-bNMSWKqF.cjs';
+import '../core/index.cjs';
+import '../messages-BZqrGGm1.cjs';
+import '../codec-BB7p8fJc.cjs';
+import '../describe-Ciu8SUnN.cjs';
+
+/**
+ * Multi-source combinators + notifier-driven operators (CSP-2.7 catalog re-derive, D40 / D45).
+ *
+ * Per-language sugar (D6/D24, never in parity). Each forms topology ONLY via DECLARED deps (D45) —
+ * the frozen pure-ts reference (D41) builds these as a producer that calls `subscribeOr` on each
+ * source INSIDE the fn body, which is the D45-banned describe island (an edge `describe` cannot
+ * show). Re-derived here as static-dep nodes with `partial:true` (fire on any dep, R-first-run-gate
+ * off) + `ctx.state` (queue / phase / winner) — so every edge is a real subscription `describe`
+ * shows truthfully (D3 / R-edges-derived). Multi-source completion / error reads
+ * `depTerminal(ctx, i)` (R-deps-terminal) via `completeWhenDepsComplete:false +
+ * terminalAsRealInput:true`.
+ *
+ * Under D49 (no equals-absorption) `combine` emits a fresh tuple on EVERY contributing wave (no
+ * substrate tuple-dedup; the pure-ts `equals` tuple comparator is gone) — pair with
+ * `distinctUntilChanged` for opt-in dedup. SENTINEL ("a dep has never delivered DATA") is detected
+ * via `depLatest(ctx, i) === undefined` (R-sentinel: `undefined` is the global sentinel, `null` is a valid
+ * value).
+ *
+ * NOT re-derived in this cut (flagged): the window family (`window`/`windowCount`/`windowTime`)
+ * emits `Node<Node<T>>` nested sub-streams — the frozen reference creates child nodes inside the fn
+ * body and pushes DATA into them imperatively, which is a describe island AND an open question for
+ * how an emitted live sub-stream appears in `describe` (D45/D51). Deferred to a design pass.
+ */
+
+/**
+ * combine (alias `combineLatest`): emit a tuple of every dep's latest value whenever ANY dep
+ * delivers, once ALL deps have delivered at least one value. `partial:true`; the all-delivered gate
+ * is `depLatest(ctx, i) !== undefined` per dep. Completes when ALL deps complete (default
+ * completeWhenDepsComplete); any dep ERROR propagates (default errorWhenDepsError). Emits a fresh
+ * tuple per wave (D49 — no dedup; compose `distinctUntilChanged` to suppress unchanged tuples).
+ */
+declare function combine<T extends readonly unknown[]>(): Operator<unknown, T>;
+/** combineLatest: RxJS-named alias of {@link combine}. */
+declare const combineLatest: typeof combine;
+/**
+ * withLatestFrom: on each PRIMARY (dep 0) value, emit `[primary, latestSecondary]`; a secondary-only
+ * (dep 1) wave updates the cached secondary but emits nothing. Uses the DEFAULT first-run gate
+ * (`partial:false`), NOT partial — the frozen reference's Phase 10.5 W1 fix: with `partial:true` the
+ * primary's push-on-subscribe fires the fn BEFORE the secondary has delivered, so the initial pair
+ * is dropped. The gate holds the first run until BOTH deps settle, then fires once with both
+ * populated; subsequent waves are gate-free and fire on primary-alone. Completes when the PRIMARY
+ * completes (not the secondary) — `completeWhenDepsComplete:false + terminalAsRealInput:true` with a
+ * primary-terminal check; a secondary terminal is ignored (its last value persists).
+ */
+declare function withLatestFrom<A, B>(): Operator<unknown, readonly [A, B]>;
+/**
+ * zip: combine one value from EACH dep, in lockstep, into a tuple — buffering per-dep queues until
+ * every dep has at least one queued value, then shifting one from each. `partial:true` +
+ * `ctx.state` queues. Completes as soon as ANY dep is terminal AND its queue is empty (no further
+ * tuple can form) — `completeWhenDepsComplete:false + terminalAsRealInput:true`. Any dep ERROR
+ * propagates (default errorWhenDepsError).
+ */
+declare function zip<T extends readonly unknown[]>(): Operator<unknown, T>;
+/**
+ * concat: play ALL of dep 0, then ALL of dep 1. Dep-1 DATA arriving during phase 0 is buffered and
+ * flushed at the handoff (dep 0 COMPLETE). `partial:true` + `ctx.state` phase. Completes when dep 1
+ * completes (or when dep 0 completes and dep 1 already had). `completeWhenDepsComplete:false +
+ * terminalAsRealInput:true`; any dep ERROR propagates (default errorWhenDepsError).
+ */
+declare function concat<S>(): Operator<S, S>;
+/**
+ * race: the FIRST dep to deliver DATA wins; thereafter only the winner's messages flow (losers are
+ * dropped, including their terminals). `partial:true` + `ctx.state` winner. `errorWhenDepsError:false`
+ * (a LOSER's error must not error the race — only the winner's) + `completeWhenDepsComplete:false +
+ * terminalAsRealInput:true`. If every dep terminates before any DATA, COMPLETE.
+ */
+declare function race<S>(): Operator<S, S>;
+/**
+ * buffer: accumulate dep 0 (source) DATA; flush the buffer as an array each time dep 1 (notifier)
+ * delivers DATA. `partial:true` + `ctx.state` buffer. On source COMPLETE, flush any remainder then
+ * COMPLETE (`completeWhenDepsComplete:false + terminalAsRealInput:true`; a notifier terminal is
+ * ignored). Source/notifier ERROR propagates (default errorWhenDepsError).
+ */
+declare function buffer<S>(): Operator<unknown, S[]>;
+/**
+ * bufferCount: batch consecutive source DATA into arrays of length `count`; the remainder flushes on
+ * source COMPLETE. Single dep + `ctx.state` buffer + `completeWhenDepsComplete:false +
+ * terminalAsRealInput:true`.
+ */
+declare function bufferCount<S>(count: number): Operator<S, S[]>;
+/**
+ * sample: emit the source's (dep 0) most recent value each time the notifier (dep 1) delivers DATA.
+ * `partial:true` + `ctx.state`. The notifier completing completes the operator; the source completing
+ * stops sampling (clears the held value); an ERROR from either terminates.
+ * `completeWhenDepsComplete:false + errorWhenDepsError:false + terminalAsRealInput:true` (manual
+ * terminal handling). No flush of the held value on source COMPLETE (RxJS sample semantics).
+ */
+declare function sample<S>(): Operator<unknown, S>;
+/**
+ * takeUntil: forward dep 0 (source) DATA until dep 1 (notifier) delivers its first DATA, then
+ * COMPLETE. `partial:true` + `completeWhenDepsComplete:false + terminalAsRealInput:true`: a source
+ * COMPLETE forwards COMPLETE; a notifier DATA triggers COMPLETE. Source/notifier ERROR propagates
+ * (default errorWhenDepsError).
+ */
+declare function takeUntil<S>(): Operator<unknown, S>;
+
+/**
+ * Higher-order operators — switchMap / mergeMap / concatMap / exhaustMap / flatMap
+ * (D47 / R-rewire-deferred / CSP-2.7; per-language sugar, D6/D24, never in parity).
+ *
+ * Each projects every outer value to an INNER source and flattens the inners' emissions. The
+ * inner sources are wired as runtime DEPS via the deferred-self-rewire substrate affordance
+ * (`ctx.rewireNext`, D47) — NOT an internal subscribe (D45 bans that; it would create a describe
+ * island). Growing/shrinking the dep set is deferred to the committed wave boundary, so a fn
+ * never mutates its own topology mid-run (that is the D37 feedback-cycle ERROR). An inner that
+ * COMPLETEs is `unsubscribeDep`'d → its source `_deactivate`s + fires `onDeactivation`: that is the
+ * cancellation / abortInFlight basis (switchMap drops the superseded inner's WORK, not just its
+ * output; mergeMap bounds memory). Built on the bare `node` primitive via the {@link Operator}
+ * factory shape + the `g.initNode` funnel (D43), so the real factory name shows in describe.
+ *
+ * Lifecycle folding (D47/D81): completeWhenDepsComplete:false + terminalAsRealInput:true +
+ * errorWhenDepsError:false — the operator owns completion (emit COMPLETE only when the SOURCE is
+ * done AND no inner is live / pending), and observes source/inner ERROR so it can remove every live
+ * inner before emitting ERROR. Those removals drain after terminal via D62: terminal seals output,
+ * while helper-owned upstream work still sees unsubscribeDep->_deactivate->onDeactivation teardown.
+ *
+ * Alignment: each run issues REMOVES before ADDS so the per-node FIFO drain keeps the operator's
+ * tracked inner list aligned with the live dep order across the intermediate boundary waves (a
+ * removed dep is silent — no settle — and applies before any added dep's push-on-subscribe wave).
+ */
+
+/** Project an outer value to an inner source (a Node, Promise, (a)sync iterable, or scalar). */
+type Project<TIn, TOut> = (value: TIn) => NodeInput<TOut>;
+/** Options for {@link mergeMap}. */
+interface MergeMapOptions {
+    /**
+     * Maximum number of live inner deps at once. `undefined`/`Infinity` keeps the default
+     * unbounded mergeMap behavior; finite values queue outer values until an inner COMPLETEs.
+     */
+    readonly concurrent?: number;
+}
+/**
+ * switchMap: project each source value to an inner; on a new source value, CANCEL the in-flight
+ * inner (its source `_deactivate`s — abortInFlight) and switch to the new one. Only the current
+ * inner's emissions are forwarded.
+ */
+declare function switchMap<TIn, TOut>(project: Project<TIn, TOut>): Operator<TIn, TOut>;
+/**
+ * mergeMap (a.k.a. flatMap): project each source value to an inner and keep ALL inners live,
+ * interleaving their emissions. A completed inner is removed (memory bounding). On source/inner
+ * ERROR or projector failure, every live inner is removed before the operator emits ERROR (D81).
+ */
+declare function mergeMap<TIn, TOut>(project: Project<TIn, TOut>, opts?: MergeMapOptions): Operator<TIn, TOut>;
+/** flatMap: alias of {@link mergeMap} (RxJS naming parity). */
+declare function flatMap<TIn, TOut>(project: Project<TIn, TOut>, opts?: MergeMapOptions): Operator<TIn, TOut>;
+/**
+ * concatMap: project each source value to an inner, but run AT MOST ONE inner at a time — queue
+ * later source values (lazy projection) and activate the next only when the active inner COMPLETEs.
+ * Preserves source order.
+ */
+declare function concatMap<TIn, TOut>(project: Project<TIn, TOut>): Operator<TIn, TOut>;
+/**
+ * exhaustMap: while an inner is active, DROP new source values; project the next source value only
+ * after the active inner COMPLETEs.
+ */
+declare function exhaustMap<TIn, TOut>(project: Project<TIn, TOut>): Operator<TIn, TOut>;
+/**
+ * repeat: play a source `count` times in sequence (RxJS `repeat`). A DEPLESS self-driving operator
+ * (Operator<never, S>, instantiate via `g.initNode(repeat(factory, count), [])`) — NOT a dep-operator.
+ *
+ * It takes a `factory: () => NodeInput<S>` (a RECIPE), not a source Node, because clean-slate Nodes
+ * are HOT/shared (multicast + cache): re-subscribing the SAME node replays its cache, it does not
+ * re-RUN the source. RxJS `repeat` re-subscribes the COLD source = a fresh subscription each round;
+ * the clean-slate analogue is a fresh node per round → a factory. (A `repeat(count)`-over-a-Node
+ * shape remains deferred: D47's no-net-change-is-a-no-op makes
+ * `unsubscribeDep(S)+subscribeDep(S)` on the SAME boundary cancel out. D115 keeps the model to
+ * ordinary unsubscribe plus a later subscribe, so same-node repeat needs a separate future design.)
+ *
+ * Mechanism (reuses the D47 self-rewire substrate, like the *Map family; NOT an internal subscribe,
+ * D45): on activation it mints round 0's inner via `ctx.rewireNext.subscribeDep`; each round's inner DATA
+ * is forwarded; on the inner's COMPLETE (`completeWhenDepsComplete:false + terminalAsRealInput:true`)
+ * it unsubscribeDep's the finished inner and, if rounds remain, subscribeDep's a FRESH `factory()` inner (a
+ * distinct node → a real net change, not the no-op same-node case); after the last round it emits
+ * COMPLETE. An inner ERROR auto-forwards (errorWhenDepsError default → repeat errors). The body is
+ * SELF-CATCHING (D30) and re-supplied on every rewire. The factory MUST mint a FRESH node per call
+ * (a factory returning the same Node makes unsubscribeDep+subscribeDep a net-zero no-op → repeat wedges).
+ */
+declare function repeat<S>(factory: () => NodeInput<S>, count: number): Operator<never, S>;
+
+/**
+ * Wall-clock time operators (CSP-2.7 / D52 / B23). Authored as COMPOSITIONS over the already-active
+ * higher-order *Map machinery (D47) + the `timer` source — NO raw `setTimeout` in any operator body
+ * (R-no-raw-async / check-no-raw-async; `setTimeout` stays confined to `sources.ts`'s `timer`). The
+ * timer source's `onDeactivation` clearTimeout IS the reset/cancel: switchMap's unsubscribeDep on a new
+ * source value tears the in-flight timer down (the declarative equivalent of the frozen reference's
+ * imperative clearTimeout-then-setTimeout). Per-language (D6/D24), never in parity.
+ *
+ * Shipped this cut (clean *Map+timer):
+ *   - delay        = mergeMap(v → timer(ms)→v)   (every value delayed ms, ALL kept, order preserved)
+ *   - debounce(Time) = switchMap(v → timer(ms)→v) (cancel-and-restart; emit the latest after quiet ms)
+ *   - throttle(Time) = exhaustMap(v → [v now, alive ms]) (leading edge: emit v, ignore for ms)
+ *
+ * Behavior on source COMPLETE (per-operator, NOT a uniform DROP): debounce/debounceTime EMIT their
+ * pending trailing value — switchMap does not cancel the in-flight inner on source COMPLETE (only a
+ * superseding source value cancels it via unsubscribeDep→onDeactivation→clearTimeout), so the timer still
+ * fires at `ms`, emits the debounced value, and only THEN does the operator COMPLETE (RxJS
+ * debounceTime parity). delay emits every still-pending delayed value then COMPLETEs (mergeMap keeps
+ * all inners). throttle/throttleTime have NO trailing value (leading-edge only, RxJS default
+ * trailing:false) — an open window inner is dropped when the operator completes.
+ *
+ * B41 tail (landed 2026-05-31, the two shapes reflect WHEN the clock arms):
+ *   - audit / auditTime — VALUE-TRIGGERED trailing edge: a source value opens a duration window
+ *                        (`audit(durationSelector)` = the general/notifier form, mirroring the *Map
+ *                        `Project` idiom + D46; `auditTime(ms)` = `audit(() => timer(ms))`), emits the
+ *                        window's LATEST value at the window's close. Self-wires the notifier via
+ *                        ctx.rewireNext — a normal `g.initNode(audit(sel), [source])` operator.
+ *   - timeout / bufferTime — SUBSCRIBE-ARMED (RxJS-cold): the clock must run from activation, before
+ *                        any source value, so the timer/interval is a CONSTRUCTION-time dep (a depless
+ *                        source arms lazily on subscribe per node `_activate`). A dep-bearing operator
+ *                        body never runs at activation (only depless nodes do, node.ts), so these ship
+ *                        as graph composition HELPERS `timeout(source, ms)` / `bufferTime(source, ms)`
+ *                        returning a Node — NOT `g.initNode(op, [deps])` operators. timeout resets its
+ *                        idle timer per source value via ctx.rewireNext (ERROR on the gap); bufferTime
+ *                        is buffer-over-interval with terminal cleanup via ctx.rewireNext.
+ *
+ * NOT ported (D58): window/windowCount/windowTime — the Node<Node<T>> higher-order forms are a D45
+ *   describe island; the array forms (buffer/bufferCount/bufferTime) are the graph-first equivalent.
+ *
+ * Inspection caveat (timeout/bufferTime): the helper returns a BARE node (free initNode) self-carrying
+ * its factory for describe auto-discovery (D51), but it is NOT in a graph's _entries — so g.describe()
+ * lists it only when it is a live dep of a registered node (a first-cut limit, like the *Map inners).
+ */
+
+/**
+ * delay: shift every value by `ms`, preserving all values + order. `mergeMap` keeps every inner
+ * timer live (equal `ms`, so they fire in arrival order).
+ */
+declare function delay<S>(ms: number): Operator<S, S>;
+/**
+ * debounce (alias `debounceTime`): emit the latest value only after `ms` of quiet. `switchMap`
+ * cancels the prior timer (its onDeactivation clearTimeout) on each new source value and restarts —
+ * the declarative debounce.
+ *
+ * RxJS-7 divergence (reference rxjs@7.8, B44): RxJS `debounceTime` FLUSHES the pending value
+ * IMMEDIATELY when the source COMPLETEs (its `_complete` calls `debouncedNext()` before
+ * `complete()`). This composition instead emits the pending value when the in-flight `timer(ms)`
+ * fires — i.e. at `(last-value-time + ms)` — so if the source completes mid-window the trailing
+ * value arrives up to `ms` later than RxJS. Inherent to the `*Map`+`timer` form (the composition
+ * cannot flush early without detecting COMPLETE inside the switchMap inner); accepted, not a bug.
+ */
+declare function debounce<S>(ms: number): Operator<S, S>;
+/** debounceTime: RxJS-named alias of {@link debounce}. */
+declare function debounceTime<S>(ms: number): Operator<S, S>;
+/**
+ * throttle (alias `throttleTime`): leading-edge — emit a value immediately, then ignore the source
+ * for `ms`. `exhaustMap` drops new source values while the current window inner is alive; the
+ * window emits v at its leading edge and stays alive `ms`.
+ *
+ * Matches the RxJS-7 `throttleTime` DEFAULT (leading:true, trailing:false). The leading/trailing
+ * OPTIONS RxJS exposes are NOT provided (a capability gap, not a behavior divergence; B44) — add a
+ * trailing-window form if a consumer needs it.
+ */
+declare function throttle<S>(ms: number): Operator<S, S>;
+/** throttleTime: RxJS-named alias of {@link throttle}. */
+declare function throttleTime<S>(ms: number): Operator<S, S>;
+/**
+ * audit: VALUE-TRIGGERED trailing throttle. A source value (when no window is open) opens a duration
+ * window via `durationSelector(value)` → a notifier `NodeInput` wired as dep 1 with `ctx.rewireNext`
+ * (D47 — the *Map self-rewire idiom, NOT an internal subscribe, D45); during the window new source
+ * values only UPDATE the tracked latest (no emit); when the notifier fires (its first DATA / COMPLETE)
+ * the window closes and the LATEST value is emitted. This is throttle's trailing-edge twin
+ * (throttle emits the window's FIRST value at the leading edge; audit emits the LAST at the close).
+ *
+ * `durationSelector` is the general/notifier form (mirrors the *Map `Project` idiom + D46); the source
+ * is dep 0, the live notifier (if any) is dep 1. On source COMPLETE the pending latest is FLUSHED then
+ * COMPLETE (RxJS-7 audit flush-on-complete, B44). A source/notifier ERROR is read as a real terminal
+ * input so the live notifier can be removed before ERROR. Self-catching (D30); re-supplies its body on
+ * every rewire.
+ */
+declare function audit<S>(durationSelector: (v: S) => NodeInput<unknown>): Operator<S, S>;
+/** auditTime: the `ms`-specialization of {@link audit} — the window is a `timer(ms)`. */
+declare function auditTime<S>(ms: number): Operator<S, S>;
+/**
+ * timeout: idle watchdog — forward every source value, but ERROR if more than `ms` elapses with no
+ * value (RxJS `timeout(ms)`, `first === each === ms`). SUBSCRIBE-ARMED: the first `timer(ms)` is a
+ * CONSTRUCTION-time dep, so it arms when `timeout`'s node is subscribed/activated (a depless source
+ * runs lazily on `_activate`) — i.e. a source that never emits its FIRST value within `ms` still
+ * errors. A dep-bearing operator body never runs at activation (only depless nodes do, node.ts), which
+ * is why this is a HELPER returning a Node, not a `g.initNode(op, [source])` operator.
+ *
+ * Each source value forwards as-is and RESETS the idle timer (unsubscribeDep the current `timer(ms)`,
+ * subscribeDep a fresh one — its `onDeactivation` clearTimeout cancels the prior countdown). The timer
+ * firing (its DATA/COMPLETE) is the timeout → `[[ERROR]]`. Source COMPLETE forwards COMPLETE (no
+ * error) and removes the idle timer during the terminal wave (D62 terminal-drains-queued-rewire);
+ * a source ERROR forwards likewise. The idle timer is also torn down when the consumer unsubscribes
+ * (timeout deactivates → dep unsub → timer onDeactivation). Self-catching (D30).
+ */
+declare function timeout<S>(source: Node<S>, ms: number): Node<S>;
+/**
+ * bufferTime: buffer source values and flush them as an array every `ms` (RxJS `bufferTime(ms)`).
+ * SUBSCRIBE-ARMED: the `interval(ms)` notifier is a CONSTRUCTION-time dep (arms on subscribe), so an
+ * empty window flushes `[]` even before the first source value — matching the landed {@link buffer}
+ * (which flushes on every notifier signal). On source COMPLETE the remainder flushes then COMPLETE
+ * (B44), and D62 lets the terminal wave still drain `unsubscribeDep(interval)` so the helper-owned
+ * interval source deactivates instead of ticking forever.
+ */
+declare function bufferTime<S>(source: Node<S>, ms: number): Node<S[]>;
+
+export { type MergeMapOptions, Operator, type Project, audit, auditTime, buffer, bufferCount, bufferTime, combine, combineLatest, concat, concatMap, debounce, debounceTime, delay, exhaustMap, flatMap, mergeMap, race, repeat, sample, switchMap, takeUntil, throttle, throttleTime, timeout, withLatestFrom, zip };

package/dist/operators/index.d.ts

@@ -0,0 +1,308 @@
+import { L as Operator } from '../graph-DfdF9zy4.js';
+export { D as DefineOpts, a as Definition, M as RestoreRegistryEntry, S as SettleOpts, U as TapObserver, $ as ValveOpts, a2 as catchError, a5 as define, a6 as distinctUntilChanged, a7 as elementAt, a8 as filter, aa as find, ab as first, ae as initNode, af as last, ag as map, ai as merge, ak as onFirstData, al as pairwise, am as reduce, an as rescue, ap as restoreRegistry, aq as scan, ar as settle, as as skip, au as take, aw as takeWhile, ax as tap, ay as tapFirst, aA as valve } from '../graph-DfdF9zy4.js';
+import { N as NodeInput } from '../index-SnzZu3x7.js';
+import { N as Node } from '../types-h12mNYbq.js';
+import '../core/index.js';
+import '../messages-BZqrGGm1.js';
+import '../codec-BB7p8fJc.js';
+import '../describe-BZb7AS2y.js';
+
+/**
+ * Multi-source combinators + notifier-driven operators (CSP-2.7 catalog re-derive, D40 / D45).
+ *
+ * Per-language sugar (D6/D24, never in parity). Each forms topology ONLY via DECLARED deps (D45) —
+ * the frozen pure-ts reference (D41) builds these as a producer that calls `subscribeOr` on each
+ * source INSIDE the fn body, which is the D45-banned describe island (an edge `describe` cannot
+ * show). Re-derived here as static-dep nodes with `partial:true` (fire on any dep, R-first-run-gate
+ * off) + `ctx.state` (queue / phase / winner) — so every edge is a real subscription `describe`
+ * shows truthfully (D3 / R-edges-derived). Multi-source completion / error reads
+ * `depTerminal(ctx, i)` (R-deps-terminal) via `completeWhenDepsComplete:false +
+ * terminalAsRealInput:true`.
+ *
+ * Under D49 (no equals-absorption) `combine` emits a fresh tuple on EVERY contributing wave (no
+ * substrate tuple-dedup; the pure-ts `equals` tuple comparator is gone) — pair with
+ * `distinctUntilChanged` for opt-in dedup. SENTINEL ("a dep has never delivered DATA") is detected
+ * via `depLatest(ctx, i) === undefined` (R-sentinel: `undefined` is the global sentinel, `null` is a valid
+ * value).
+ *
+ * NOT re-derived in this cut (flagged): the window family (`window`/`windowCount`/`windowTime`)
+ * emits `Node<Node<T>>` nested sub-streams — the frozen reference creates child nodes inside the fn
+ * body and pushes DATA into them imperatively, which is a describe island AND an open question for
+ * how an emitted live sub-stream appears in `describe` (D45/D51). Deferred to a design pass.
+ */
+
+/**
+ * combine (alias `combineLatest`): emit a tuple of every dep's latest value whenever ANY dep
+ * delivers, once ALL deps have delivered at least one value. `partial:true`; the all-delivered gate
+ * is `depLatest(ctx, i) !== undefined` per dep. Completes when ALL deps complete (default
+ * completeWhenDepsComplete); any dep ERROR propagates (default errorWhenDepsError). Emits a fresh
+ * tuple per wave (D49 — no dedup; compose `distinctUntilChanged` to suppress unchanged tuples).
+ */
+declare function combine<T extends readonly unknown[]>(): Operator<unknown, T>;
+/** combineLatest: RxJS-named alias of {@link combine}. */
+declare const combineLatest: typeof combine;
+/**
+ * withLatestFrom: on each PRIMARY (dep 0) value, emit `[primary, latestSecondary]`; a secondary-only
+ * (dep 1) wave updates the cached secondary but emits nothing. Uses the DEFAULT first-run gate
+ * (`partial:false`), NOT partial — the frozen reference's Phase 10.5 W1 fix: with `partial:true` the
+ * primary's push-on-subscribe fires the fn BEFORE the secondary has delivered, so the initial pair
+ * is dropped. The gate holds the first run until BOTH deps settle, then fires once with both
+ * populated; subsequent waves are gate-free and fire on primary-alone. Completes when the PRIMARY
+ * completes (not the secondary) — `completeWhenDepsComplete:false + terminalAsRealInput:true` with a
+ * primary-terminal check; a secondary terminal is ignored (its last value persists).
+ */
+declare function withLatestFrom<A, B>(): Operator<unknown, readonly [A, B]>;
+/**
+ * zip: combine one value from EACH dep, in lockstep, into a tuple — buffering per-dep queues until
+ * every dep has at least one queued value, then shifting one from each. `partial:true` +
+ * `ctx.state` queues. Completes as soon as ANY dep is terminal AND its queue is empty (no further
+ * tuple can form) — `completeWhenDepsComplete:false + terminalAsRealInput:true`. Any dep ERROR
+ * propagates (default errorWhenDepsError).
+ */
+declare function zip<T extends readonly unknown[]>(): Operator<unknown, T>;
+/**
+ * concat: play ALL of dep 0, then ALL of dep 1. Dep-1 DATA arriving during phase 0 is buffered and
+ * flushed at the handoff (dep 0 COMPLETE). `partial:true` + `ctx.state` phase. Completes when dep 1
+ * completes (or when dep 0 completes and dep 1 already had). `completeWhenDepsComplete:false +
+ * terminalAsRealInput:true`; any dep ERROR propagates (default errorWhenDepsError).
+ */
+declare function concat<S>(): Operator<S, S>;
+/**
+ * race: the FIRST dep to deliver DATA wins; thereafter only the winner's messages flow (losers are
+ * dropped, including their terminals). `partial:true` + `ctx.state` winner. `errorWhenDepsError:false`
+ * (a LOSER's error must not error the race — only the winner's) + `completeWhenDepsComplete:false +
+ * terminalAsRealInput:true`. If every dep terminates before any DATA, COMPLETE.
+ */
+declare function race<S>(): Operator<S, S>;
+/**
+ * buffer: accumulate dep 0 (source) DATA; flush the buffer as an array each time dep 1 (notifier)
+ * delivers DATA. `partial:true` + `ctx.state` buffer. On source COMPLETE, flush any remainder then
+ * COMPLETE (`completeWhenDepsComplete:false + terminalAsRealInput:true`; a notifier terminal is
+ * ignored). Source/notifier ERROR propagates (default errorWhenDepsError).
+ */
+declare function buffer<S>(): Operator<unknown, S[]>;
+/**
+ * bufferCount: batch consecutive source DATA into arrays of length `count`; the remainder flushes on
+ * source COMPLETE. Single dep + `ctx.state` buffer + `completeWhenDepsComplete:false +
+ * terminalAsRealInput:true`.
+ */
+declare function bufferCount<S>(count: number): Operator<S, S[]>;
+/**
+ * sample: emit the source's (dep 0) most recent value each time the notifier (dep 1) delivers DATA.
+ * `partial:true` + `ctx.state`. The notifier completing completes the operator; the source completing
+ * stops sampling (clears the held value); an ERROR from either terminates.
+ * `completeWhenDepsComplete:false + errorWhenDepsError:false + terminalAsRealInput:true` (manual
+ * terminal handling). No flush of the held value on source COMPLETE (RxJS sample semantics).
+ */
+declare function sample<S>(): Operator<unknown, S>;
+/**
+ * takeUntil: forward dep 0 (source) DATA until dep 1 (notifier) delivers its first DATA, then
+ * COMPLETE. `partial:true` + `completeWhenDepsComplete:false + terminalAsRealInput:true`: a source
+ * COMPLETE forwards COMPLETE; a notifier DATA triggers COMPLETE. Source/notifier ERROR propagates
+ * (default errorWhenDepsError).
+ */
+declare function takeUntil<S>(): Operator<unknown, S>;
+
+/**
+ * Higher-order operators — switchMap / mergeMap / concatMap / exhaustMap / flatMap
+ * (D47 / R-rewire-deferred / CSP-2.7; per-language sugar, D6/D24, never in parity).
+ *
+ * Each projects every outer value to an INNER source and flattens the inners' emissions. The
+ * inner sources are wired as runtime DEPS via the deferred-self-rewire substrate affordance
+ * (`ctx.rewireNext`, D47) — NOT an internal subscribe (D45 bans that; it would create a describe
+ * island). Growing/shrinking the dep set is deferred to the committed wave boundary, so a fn
+ * never mutates its own topology mid-run (that is the D37 feedback-cycle ERROR). An inner that
+ * COMPLETEs is `unsubscribeDep`'d → its source `_deactivate`s + fires `onDeactivation`: that is the
+ * cancellation / abortInFlight basis (switchMap drops the superseded inner's WORK, not just its
+ * output; mergeMap bounds memory). Built on the bare `node` primitive via the {@link Operator}
+ * factory shape + the `g.initNode` funnel (D43), so the real factory name shows in describe.
+ *
+ * Lifecycle folding (D47/D81): completeWhenDepsComplete:false + terminalAsRealInput:true +
+ * errorWhenDepsError:false — the operator owns completion (emit COMPLETE only when the SOURCE is
+ * done AND no inner is live / pending), and observes source/inner ERROR so it can remove every live
+ * inner before emitting ERROR. Those removals drain after terminal via D62: terminal seals output,
+ * while helper-owned upstream work still sees unsubscribeDep->_deactivate->onDeactivation teardown.
+ *
+ * Alignment: each run issues REMOVES before ADDS so the per-node FIFO drain keeps the operator's
+ * tracked inner list aligned with the live dep order across the intermediate boundary waves (a
+ * removed dep is silent — no settle — and applies before any added dep's push-on-subscribe wave).
+ */
+
+/** Project an outer value to an inner source (a Node, Promise, (a)sync iterable, or scalar). */
+type Project<TIn, TOut> = (value: TIn) => NodeInput<TOut>;
+/** Options for {@link mergeMap}. */
+interface MergeMapOptions {
+    /**
+     * Maximum number of live inner deps at once. `undefined`/`Infinity` keeps the default
+     * unbounded mergeMap behavior; finite values queue outer values until an inner COMPLETEs.
+     */
+    readonly concurrent?: number;
+}
+/**
+ * switchMap: project each source value to an inner; on a new source value, CANCEL the in-flight
+ * inner (its source `_deactivate`s — abortInFlight) and switch to the new one. Only the current
+ * inner's emissions are forwarded.
+ */
+declare function switchMap<TIn, TOut>(project: Project<TIn, TOut>): Operator<TIn, TOut>;
+/**
+ * mergeMap (a.k.a. flatMap): project each source value to an inner and keep ALL inners live,
+ * interleaving their emissions. A completed inner is removed (memory bounding). On source/inner
+ * ERROR or projector failure, every live inner is removed before the operator emits ERROR (D81).
+ */
+declare function mergeMap<TIn, TOut>(project: Project<TIn, TOut>, opts?: MergeMapOptions): Operator<TIn, TOut>;
+/** flatMap: alias of {@link mergeMap} (RxJS naming parity). */
+declare function flatMap<TIn, TOut>(project: Project<TIn, TOut>, opts?: MergeMapOptions): Operator<TIn, TOut>;
+/**
+ * concatMap: project each source value to an inner, but run AT MOST ONE inner at a time — queue
+ * later source values (lazy projection) and activate the next only when the active inner COMPLETEs.
+ * Preserves source order.
+ */
+declare function concatMap<TIn, TOut>(project: Project<TIn, TOut>): Operator<TIn, TOut>;
+/**
+ * exhaustMap: while an inner is active, DROP new source values; project the next source value only
+ * after the active inner COMPLETEs.
+ */
+declare function exhaustMap<TIn, TOut>(project: Project<TIn, TOut>): Operator<TIn, TOut>;
+/**
+ * repeat: play a source `count` times in sequence (RxJS `repeat`). A DEPLESS self-driving operator
+ * (Operator<never, S>, instantiate via `g.initNode(repeat(factory, count), [])`) — NOT a dep-operator.
+ *
+ * It takes a `factory: () => NodeInput<S>` (a RECIPE), not a source Node, because clean-slate Nodes
+ * are HOT/shared (multicast + cache): re-subscribing the SAME node replays its cache, it does not
+ * re-RUN the source. RxJS `repeat` re-subscribes the COLD source = a fresh subscription each round;
+ * the clean-slate analogue is a fresh node per round → a factory. (A `repeat(count)`-over-a-Node
+ * shape remains deferred: D47's no-net-change-is-a-no-op makes
+ * `unsubscribeDep(S)+subscribeDep(S)` on the SAME boundary cancel out. D115 keeps the model to
+ * ordinary unsubscribe plus a later subscribe, so same-node repeat needs a separate future design.)
+ *
+ * Mechanism (reuses the D47 self-rewire substrate, like the *Map family; NOT an internal subscribe,
+ * D45): on activation it mints round 0's inner via `ctx.rewireNext.subscribeDep`; each round's inner DATA
+ * is forwarded; on the inner's COMPLETE (`completeWhenDepsComplete:false + terminalAsRealInput:true`)
+ * it unsubscribeDep's the finished inner and, if rounds remain, subscribeDep's a FRESH `factory()` inner (a
+ * distinct node → a real net change, not the no-op same-node case); after the last round it emits
+ * COMPLETE. An inner ERROR auto-forwards (errorWhenDepsError default → repeat errors). The body is
+ * SELF-CATCHING (D30) and re-supplied on every rewire. The factory MUST mint a FRESH node per call
+ * (a factory returning the same Node makes unsubscribeDep+subscribeDep a net-zero no-op → repeat wedges).
+ */
+declare function repeat<S>(factory: () => NodeInput<S>, count: number): Operator<never, S>;
+
+/**
+ * Wall-clock time operators (CSP-2.7 / D52 / B23). Authored as COMPOSITIONS over the already-active
+ * higher-order *Map machinery (D47) + the `timer` source — NO raw `setTimeout` in any operator body
+ * (R-no-raw-async / check-no-raw-async; `setTimeout` stays confined to `sources.ts`'s `timer`). The
+ * timer source's `onDeactivation` clearTimeout IS the reset/cancel: switchMap's unsubscribeDep on a new
+ * source value tears the in-flight timer down (the declarative equivalent of the frozen reference's
+ * imperative clearTimeout-then-setTimeout). Per-language (D6/D24), never in parity.
+ *
+ * Shipped this cut (clean *Map+timer):
+ *   - delay        = mergeMap(v → timer(ms)→v)   (every value delayed ms, ALL kept, order preserved)
+ *   - debounce(Time) = switchMap(v → timer(ms)→v) (cancel-and-restart; emit the latest after quiet ms)
+ *   - throttle(Time) = exhaustMap(v → [v now, alive ms]) (leading edge: emit v, ignore for ms)
+ *
+ * Behavior on source COMPLETE (per-operator, NOT a uniform DROP): debounce/debounceTime EMIT their
+ * pending trailing value — switchMap does not cancel the in-flight inner on source COMPLETE (only a
+ * superseding source value cancels it via unsubscribeDep→onDeactivation→clearTimeout), so the timer still
+ * fires at `ms`, emits the debounced value, and only THEN does the operator COMPLETE (RxJS
+ * debounceTime parity). delay emits every still-pending delayed value then COMPLETEs (mergeMap keeps
+ * all inners). throttle/throttleTime have NO trailing value (leading-edge only, RxJS default
+ * trailing:false) — an open window inner is dropped when the operator completes.
+ *
+ * B41 tail (landed 2026-05-31, the two shapes reflect WHEN the clock arms):
+ *   - audit / auditTime — VALUE-TRIGGERED trailing edge: a source value opens a duration window
+ *                        (`audit(durationSelector)` = the general/notifier form, mirroring the *Map
+ *                        `Project` idiom + D46; `auditTime(ms)` = `audit(() => timer(ms))`), emits the
+ *                        window's LATEST value at the window's close. Self-wires the notifier via
+ *                        ctx.rewireNext — a normal `g.initNode(audit(sel), [source])` operator.
+ *   - timeout / bufferTime — SUBSCRIBE-ARMED (RxJS-cold): the clock must run from activation, before
+ *                        any source value, so the timer/interval is a CONSTRUCTION-time dep (a depless
+ *                        source arms lazily on subscribe per node `_activate`). A dep-bearing operator
+ *                        body never runs at activation (only depless nodes do, node.ts), so these ship
+ *                        as graph composition HELPERS `timeout(source, ms)` / `bufferTime(source, ms)`
+ *                        returning a Node — NOT `g.initNode(op, [deps])` operators. timeout resets its
+ *                        idle timer per source value via ctx.rewireNext (ERROR on the gap); bufferTime
+ *                        is buffer-over-interval with terminal cleanup via ctx.rewireNext.
+ *
+ * NOT ported (D58): window/windowCount/windowTime — the Node<Node<T>> higher-order forms are a D45
+ *   describe island; the array forms (buffer/bufferCount/bufferTime) are the graph-first equivalent.
+ *
+ * Inspection caveat (timeout/bufferTime): the helper returns a BARE node (free initNode) self-carrying
+ * its factory for describe auto-discovery (D51), but it is NOT in a graph's _entries — so g.describe()
+ * lists it only when it is a live dep of a registered node (a first-cut limit, like the *Map inners).
+ */
+
+/**
+ * delay: shift every value by `ms`, preserving all values + order. `mergeMap` keeps every inner
+ * timer live (equal `ms`, so they fire in arrival order).
+ */
+declare function delay<S>(ms: number): Operator<S, S>;
+/**
+ * debounce (alias `debounceTime`): emit the latest value only after `ms` of quiet. `switchMap`
+ * cancels the prior timer (its onDeactivation clearTimeout) on each new source value and restarts —
+ * the declarative debounce.
+ *
+ * RxJS-7 divergence (reference rxjs@7.8, B44): RxJS `debounceTime` FLUSHES the pending value
+ * IMMEDIATELY when the source COMPLETEs (its `_complete` calls `debouncedNext()` before
+ * `complete()`). This composition instead emits the pending value when the in-flight `timer(ms)`
+ * fires — i.e. at `(last-value-time + ms)` — so if the source completes mid-window the trailing
+ * value arrives up to `ms` later than RxJS. Inherent to the `*Map`+`timer` form (the composition
+ * cannot flush early without detecting COMPLETE inside the switchMap inner); accepted, not a bug.
+ */
+declare function debounce<S>(ms: number): Operator<S, S>;
+/** debounceTime: RxJS-named alias of {@link debounce}. */
+declare function debounceTime<S>(ms: number): Operator<S, S>;
+/**
+ * throttle (alias `throttleTime`): leading-edge — emit a value immediately, then ignore the source
+ * for `ms`. `exhaustMap` drops new source values while the current window inner is alive; the
+ * window emits v at its leading edge and stays alive `ms`.
+ *
+ * Matches the RxJS-7 `throttleTime` DEFAULT (leading:true, trailing:false). The leading/trailing
+ * OPTIONS RxJS exposes are NOT provided (a capability gap, not a behavior divergence; B44) — add a
+ * trailing-window form if a consumer needs it.
+ */
+declare function throttle<S>(ms: number): Operator<S, S>;
+/** throttleTime: RxJS-named alias of {@link throttle}. */
+declare function throttleTime<S>(ms: number): Operator<S, S>;
+/**
+ * audit: VALUE-TRIGGERED trailing throttle. A source value (when no window is open) opens a duration
+ * window via `durationSelector(value)` → a notifier `NodeInput` wired as dep 1 with `ctx.rewireNext`
+ * (D47 — the *Map self-rewire idiom, NOT an internal subscribe, D45); during the window new source
+ * values only UPDATE the tracked latest (no emit); when the notifier fires (its first DATA / COMPLETE)
+ * the window closes and the LATEST value is emitted. This is throttle's trailing-edge twin
+ * (throttle emits the window's FIRST value at the leading edge; audit emits the LAST at the close).
+ *
+ * `durationSelector` is the general/notifier form (mirrors the *Map `Project` idiom + D46); the source
+ * is dep 0, the live notifier (if any) is dep 1. On source COMPLETE the pending latest is FLUSHED then
+ * COMPLETE (RxJS-7 audit flush-on-complete, B44). A source/notifier ERROR is read as a real terminal
+ * input so the live notifier can be removed before ERROR. Self-catching (D30); re-supplies its body on
+ * every rewire.
+ */
+declare function audit<S>(durationSelector: (v: S) => NodeInput<unknown>): Operator<S, S>;
+/** auditTime: the `ms`-specialization of {@link audit} — the window is a `timer(ms)`. */
+declare function auditTime<S>(ms: number): Operator<S, S>;
+/**
+ * timeout: idle watchdog — forward every source value, but ERROR if more than `ms` elapses with no
+ * value (RxJS `timeout(ms)`, `first === each === ms`). SUBSCRIBE-ARMED: the first `timer(ms)` is a
+ * CONSTRUCTION-time dep, so it arms when `timeout`'s node is subscribed/activated (a depless source
+ * runs lazily on `_activate`) — i.e. a source that never emits its FIRST value within `ms` still
+ * errors. A dep-bearing operator body never runs at activation (only depless nodes do, node.ts), which
+ * is why this is a HELPER returning a Node, not a `g.initNode(op, [source])` operator.
+ *
+ * Each source value forwards as-is and RESETS the idle timer (unsubscribeDep the current `timer(ms)`,
+ * subscribeDep a fresh one — its `onDeactivation` clearTimeout cancels the prior countdown). The timer
+ * firing (its DATA/COMPLETE) is the timeout → `[[ERROR]]`. Source COMPLETE forwards COMPLETE (no
+ * error) and removes the idle timer during the terminal wave (D62 terminal-drains-queued-rewire);
+ * a source ERROR forwards likewise. The idle timer is also torn down when the consumer unsubscribes
+ * (timeout deactivates → dep unsub → timer onDeactivation). Self-catching (D30).
+ */
+declare function timeout<S>(source: Node<S>, ms: number): Node<S>;
+/**
+ * bufferTime: buffer source values and flush them as an array every `ms` (RxJS `bufferTime(ms)`).
+ * SUBSCRIBE-ARMED: the `interval(ms)` notifier is a CONSTRUCTION-time dep (arms on subscribe), so an
+ * empty window flushes `[]` even before the first source value — matching the landed {@link buffer}
+ * (which flushes on every notifier signal). On source COMPLETE the remainder flushes then COMPLETE
+ * (B44), and D62 lets the terminal wave still drain `unsubscribeDep(interval)` so the helper-owned
+ * interval source deactivates instead of ticking forever.
+ */
+declare function bufferTime<S>(source: Node<S>, ms: number): Node<S[]>;
+
+export { type MergeMapOptions, Operator, type Project, audit, auditTime, buffer, bufferCount, bufferTime, combine, combineLatest, concat, concatMap, debounce, debounceTime, delay, exhaustMap, flatMap, mergeMap, race, repeat, sample, switchMap, takeUntil, throttle, throttleTime, timeout, withLatestFrom, zip };