reactor-core-ts 2.1.2 → 2.1.3

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/sinks/internal/AbstractMulticastSink.ts","../src/sinks/ReplayAllSink.ts","../src/publishers/Signal.ts","../src/publishers/internal/AbstractPipePublisher.ts","../src/schedulers/ImmediateScheduler.ts","../src/schedulers/MicroScheduler.ts","../src/schedulers/MacroScheduler.ts","../src/schedulers/DelayScheduler.ts","../src/schedulers/IntervalScheduler.ts","../src/schedulers/index.ts","../src/publishers/Flux.ts","../src/publishers/Mono.ts","../src/sinks/OneSink.ts","../src/sinks/EmptySink.ts","../src/sinks/internal/AbstractUnicastSink.ts","../src/sinks/UnicastOnBackpressureBufferSink.ts","../src/sinks/UnicastOnBackpressureErrorSink.ts","../src/sinks/MulticastDirectAllOrNothingSink.ts","../src/sinks/MulticastDirectBestEffortSink.ts","../src/sinks/MulticastOnBackpressureBufferSink.ts","../src/sinks/ReplayLatestSink.ts","../src/sinks/ReplayLatestOrDefaultSink.ts","../src/sinks/index.ts"],"sourcesContent":["export * from '@/publishers'\nexport * from '@/schedulers'\nexport * from '@/sinks'\nexport * from '@/subscriptions'","import {Sink} from \"@/sinks/Sink\";\nimport {Flux, Publisher} from \"@/publishers\";\nimport {Subscriber, Subscription} from \"@/subscriptions\";\n\n/**\n * Base class for all multicast sinks (one-to-many, Map-based subscriber tracking).\n *\n * Subclasses provide:\n *  - `createEntry()` — constructs a fresh per-subscriber state object\n *  - `next(value)`   — emission logic (differs per delivery strategy)\n *\n * Hooks (all no-ops by default, override as needed):\n *  - `shouldReplayTerminalOnSubscribe()` — when to replay terminal immediately on subscribe\n *  - `onDemandGranted(sub, entry)`       — called after demand is accumulated (e.g. drain)\n *  - `onUnsubscribed(sub, entry)`        — extra cleanup on cancel (e.g. autoCancel logic)\n *  - `onSubscribed(sub, entry)`          — called after subscriber.onSubscribe() (e.g. initial drain)\n *  - `deliverError(sub, entry)`          — how to signal error to one entry (default: direct)\n *  - `deliverComplete(sub, entry)`       — how to signal complete to one entry (default: direct)\n *  - `clearEntriesAfterComplete()`       — false for drain-based sinks (drainEntry cleans up)\n *\n * E must have at least `{ cancelled: boolean; demand: number }`.\n */\nexport abstract class AbstractMulticastSink<T, E extends { cancelled: boolean; demand: number }>\n    implements Sink<T>, Publisher<T> {\n\n    protected readonly entries = new Map<Subscriber<T>, E>();\n    protected terminated = false;\n    protected terminalError: Error | null = null;\n\n    abstract next(value: T): void;\n    protected abstract createEntry(): E;\n\n    asFlux(): Flux<T> {\n        return Flux.from(this);\n    }\n\n    // ──── Hooks ──────────────────────────────────────────────────────────────\n\n    /** True → replay terminal signal immediately when subscriber joins. */\n    protected shouldReplayTerminalOnSubscribe(): boolean {\n        return this.terminated;\n    }\n\n    /** Called after demand is accumulated in entry.demand. Default: noop. */\n    protected onDemandGranted(_sub: Subscriber<T>, _entry: E): void {}\n\n    /** Called after entry removal on unsubscribe. Default: noop. */\n    protected onUnsubscribed(_sub: Subscriber<T>, _entry: E): void {}\n\n    /** Called after subscriber.onSubscribe(sub). Default: noop. */\n    protected onSubscribed(_sub: Subscriber<T>, _entry: E): void {}\n\n    /** How to deliver error to one entry. Default: direct onError. */\n    protected deliverError(sub: Subscriber<T>, entry: E): void {\n        if (!entry.cancelled) sub.onError(this.terminalError!);\n    }\n\n    /** How to deliver complete to one entry. Default: direct onComplete. */\n    protected deliverComplete(sub: Subscriber<T>, entry: E): void {\n        if (!entry.cancelled) sub.onComplete();\n    }\n\n    /**\n     * Whether to call entries.clear() after iterating in complete().\n     * Override to false for drain-based sinks — drainEntry deletes entries individually.\n     */\n    protected clearEntriesAfterComplete(): boolean {\n        return true;\n    }\n\n    // ──── Terminal signal ─────────────────────────────────────────────────────\n\n    error(error: Error): void {\n        if (this.terminated) return;\n        this.terminated = true;\n        this.terminalError = error;\n        for (const [sub, entry] of this.entries) {\n            this.deliverError(sub, entry);\n        }\n        this.entries.clear();\n    }\n\n    complete(): void {\n        if (this.terminated) return;\n        this.terminated = true;\n        for (const [sub, entry] of this.entries) {\n            this.deliverComplete(sub, entry);\n        }\n        if (this.clearEntriesAfterComplete()) this.entries.clear();\n    }\n\n    // ──── Subscribe ───────────────────────────────────────────────────────────\n\n    subscribe(subscriber: Subscriber<T>): Subscription {\n        if (this.shouldReplayTerminalOnSubscribe()) {\n            const sub = { request() {}, unsubscribe() {} };\n            subscriber.onSubscribe(sub);\n            this.terminalError\n                ? subscriber.onError(this.terminalError)\n                : subscriber.onComplete();\n            return sub;\n        }\n\n        const entry = this.createEntry();\n        this.entries.set(subscriber, entry);\n\n        const sub = {\n            request: (n: number) => {\n                if (entry.cancelled) return;\n                // Rule 3.9: request(n ≤ 0) MUST signal onError\n                if (n <= 0) {\n                    entry.cancelled = true;\n                    this.entries.delete(subscriber);\n                    subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                    return;\n                }\n                entry.demand = Math.min(entry.demand + n, Number.MAX_SAFE_INTEGER);\n                this.onDemandGranted(subscriber, entry);\n            },\n            unsubscribe: () => {\n                entry.cancelled = true;\n                this.entries.delete(subscriber);\n                this.onUnsubscribed(subscriber, entry);\n            }\n        };\n\n        subscriber.onSubscribe(sub);\n        this.onSubscribed(subscriber, entry);\n        return sub;\n    }\n}\n","import {AbstractMulticastSink} from \"@/sinks/internal/AbstractMulticastSink\";\nimport {Subscriber} from \"@/subscriptions\";\n\n// Rule 3.16: draining flag prevents re-entrant drain (onNext → request → drain)\ntype Entry = { position: number; demand: number; cancelled: boolean; draining: boolean };\n\nexport default class ReplayAllSink<T> extends AbstractMulticastSink<T, Entry> {\n\n    private readonly history: T[] = [];\n\n    // ──── AbstractMulticastSink hooks ─────────────────────────────────────────\n\n    protected createEntry(): Entry {\n        return { position: 0, demand: 0, cancelled: false, draining: false };\n    }\n\n    /** Only replay terminal immediately if there's nothing in history to deliver. */\n    protected shouldReplayTerminalOnSubscribe(): boolean {\n        return this.terminated && this.history.length === 0;\n    }\n\n    /** Drain buffered history first, then signal error. */\n    protected deliverError(sub: Subscriber<T>, entry: Entry): void {\n        this.drainEntry(sub, entry);\n        if (!entry.cancelled) sub.onError(this.terminalError!);\n    }\n\n    /** Drain buffered history — drainEntry signals complete when done. */\n    protected deliverComplete(sub: Subscriber<T>, entry: Entry): void {\n        if (!entry.cancelled) this.drainEntry(sub, entry);\n    }\n\n    protected clearEntriesAfterComplete(): boolean {\n        return false;\n    }\n\n    protected onDemandGranted(sub: Subscriber<T>, entry: Entry): void {\n        this.drainEntry(sub, entry);\n    }\n\n    // ──── Sink.next ───────────────────────────────────────────────────────────\n\n    next(value: T): void {\n        if (this.terminated) return;\n        this.history.push(value);\n        for (const [sub, entry] of this.entries) {\n            if (!entry.cancelled) this.drainEntry(sub, entry);\n        }\n    }\n\n    // ──── Internal drain ──────────────────────────────────────────────────────\n\n    private drainEntry(sub: Subscriber<T>, entry: Entry): void {\n        if (entry.cancelled || entry.draining) return;\n        entry.draining = true;\n        try {\n            while (entry.demand > 0 && entry.position < this.history.length) {\n                entry.demand--;\n                sub.onNext(this.history[entry.position++]);\n                if (entry.cancelled) return;\n            }\n            if (entry.position >= this.history.length && this.terminated) {\n                this.entries.delete(sub);\n                this.terminalError ? sub.onError(this.terminalError) : sub.onComplete();\n            }\n        } finally {\n            entry.draining = false;\n        }\n    }\n}\n","/**\n * Represents a reactive signal — one of the three events that can be emitted\n * by a {@link Publisher}: a value (`next`), a terminal error (`error`), or\n * a normal completion (`complete`).\n *\n * `Signal` is the type used by {@link Flux#materialize} /\n * {@link Flux#dematerialize} to pass reactive events as plain data values.\n *\n * @typeParam T - The type of the value carried by a `next` signal.\n */\nexport type Signal<T> =\n    | { readonly kind: 'next'; readonly value: T }\n    | { readonly kind: 'error'; readonly error: Error }\n    | { readonly kind: 'complete' };\n\n/**\n * Namespace of factory helpers for creating {@link Signal} instances.\n */\nexport const Signal = {\n    /**\n     * Creates a `next` signal carrying `value`.\n     * @param value - The item to wrap.\n     */\n    next<T>(value: T): Signal<T> { return { kind: 'next', value }; },\n\n    /**\n     * Creates an `error` signal carrying `error`.\n     * @param error - The error to wrap.\n     */\n    error<T>(error: Error): Signal<T> { return { kind: 'error', error }; },\n\n    /**\n     * Creates a `complete` signal.\n     */\n    complete<T>(): Signal<T> { return { kind: 'complete' }; },\n};\n","import {Publisher} from \"@/publishers/Publisher\";\nimport {Subscriber} from \"@/subscriptions/Subscriber\";\nimport {Subscription} from \"@/subscriptions/Subscription\";\nimport {Scheduler} from \"@/schedulers/Scheduler\";\nimport {Signal} from \"@/publishers/Signal\";\n\n/**\n * Base class for Flux and Mono providing the common operator implementations\n * that are identical across both types. Operators that preserve T use the\n * abstract `wrapSource` factory so that subclasses always return their own\n * concrete type (Flux → Flux, Mono → Mono) without any unsafe casts at\n * call-sites.\n *\n * Operators NOT included here (different semantics or change the type):\n *  - filter / filterWhen  — demand-replenishment differs between Flux and Mono\n *  - doFinally            — Flux also fires fn on cancel; Mono does not\n *  - map / flatMap / cast / pipe / mapNotNull — change the type T → R\n */\nexport abstract class AbstractPipePublisher<T, Self> implements Publisher<T> {\n\n    protected constructor(protected readonly source: Publisher<T>) {}\n\n    /**\n     * Default demand issued in the auto-request onSubscribe when using the\n     * convenience subscribe() overloads (no explicit Subscriber provided).\n     * Mono overrides this to 1; Flux overrides it to Number.MAX_SAFE_INTEGER.\n     */\n    protected abstract defaultDemand(): number;\n\n    /**\n     * Subscribe with a full Subscriber (existing contract — full demand control).\n     */\n    subscribe(subscriber: Subscriber<T>): Subscription;\n\n    /**\n     * Convenience overload — any combination of callbacks may be omitted.\n     * An auto-request of `defaultDemand()` is issued on subscribe so items\n     * start flowing immediately without a manual request() call.\n     *\n     * If `onError` is not provided, unhandled errors are re-thrown so they\n     * surface as uncaught exceptions rather than being silently swallowed.\n     *\n     * @example\n     * // Mono — requests 1 automatically\n     * Mono.just(42).subscribe(v => console.log(v));\n     *\n     * // Flux — requests unbounded automatically\n     * Flux.range(0, 5).subscribe(v => console.log(v), err => console.error(err));\n     */\n    subscribe(onNext?: (value: T) => void, onError?: (error: Error) => void, onComplete?: () => void): Subscription;\n\n    subscribe(\n        subscriberOrOnNext?: Subscriber<T> | ((value: T) => void),\n        onError?: (error: Error) => void,\n        onComplete?: () => void,\n    ): Subscription {\n        // Full Subscriber object — delegate unchanged (caller owns demand).\n        if (subscriberOrOnNext !== undefined && typeof subscriberOrOnNext === 'object') {\n            return this.source.subscribe(subscriberOrOnNext);\n        }\n\n        // Convenience path: wrap callbacks in a LambdaSubscriber that auto-requests.\n        const onNext = subscriberOrOnNext as ((value: T) => void) | undefined;\n        const demand = this.defaultDemand();\n        return this.source.subscribe({\n            onSubscribe(s) { s.request(demand); },\n            onNext:     onNext   ?? (() => {}),\n            onError:    onError  ?? ((e) => { throw e; }),\n            onComplete: onComplete ?? (() => {}),\n        });\n    }\n\n    /**\n     * Wraps a publisher in the concrete subclass type.\n     * Called internally by every operator that preserves T.\n     */\n    protected abstract wrapSource(source: Publisher<T>): Self;\n\n    // ──────────────────────── Error handling ────────────────────────────────\n\n    /**\n     * Falls back to `alternative` if this source completes without emitting any items.\n     *\n     * If the source emits at least one item, `alternative` is never subscribed to.\n     * If the source errors, the error is forwarded and `alternative` is not subscribed to.\n     *\n     * @param alternative - Publisher to subscribe to if the source is empty.\n     * @returns A publisher that uses `alternative` when the source is empty.\n     */\n    public switchIfEmpty(alternative: Publisher<T>): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let primarySub: Subscription = { request() {}, unsubscribe() {} };\n                let altSub: Subscription | null = null;\n                let hasValue = false;\n                let cancelled = false;\n                let demand = 0;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (altSub) altSub.request(n); else primarySub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; primarySub.unsubscribe(); altSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(sourceSub: Subscription) {\n                        primarySub = sourceSub;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v) { hasValue = true; subscriber.onNext(v); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() {\n                        if (hasValue || cancelled) { subscriber.onComplete(); return; }\n                        altSub = alternative.subscribe({\n                            onSubscribe(altSourceSub: Subscription) {\n                                altSub = altSourceSub;\n                                if (demand > 0) altSub.request(demand);\n                            },\n                            onNext(v) { subscriber.onNext(v); },\n                            onError(e) { subscriber.onError(e); },\n                            onComplete() { subscriber.onComplete(); }\n                        });\n                    }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Substitutes the error signal with items from `replacement`.\n     *\n     * When the source signals `onError`, `replacement` is subscribed to and its items are\n     * forwarded downstream as if they came from the original source.\n     * If `replacement` itself errors, that error is forwarded.\n     *\n     * @param replacement - Publisher whose items replace the error.\n     * @returns A publisher that recovers from errors by switching to `replacement`.\n     */\n    public onErrorReturn(replacement: Publisher<T>): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let primarySub: Subscription = { request() {}, unsubscribe() {} };\n                let altSub: Subscription | null = null;\n                let cancelled = false;\n                let demand = 0;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (altSub) altSub.request(n); else primarySub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; primarySub.unsubscribe(); altSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(sourceSub: Subscription) {\n                        primarySub = sourceSub;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(_e) {\n                        if (cancelled) return;\n                        altSub = replacement.subscribe({\n                            onSubscribe(altSourceSub: Subscription) {\n                                altSub = altSourceSub;\n                                if (demand > 0) altSub.request(demand);\n                            },\n                            onNext(v) { subscriber.onNext(v); },\n                            onError(e) { subscriber.onError(e); },\n                            onComplete() { subscriber.onComplete(); }\n                        });\n                    },\n                    onComplete() { subscriber.onComplete(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Handles errors selectively: if `predicate(error)` returns `true`, the error is\n     * swallowed and the stream completes normally; otherwise the error is forwarded.\n     *\n     * @param predicate - Receives the error and returns `true` to suppress it.\n     * @returns A publisher that converts matching errors into normal completions.\n     */\n    public onErrorContinue(predicate: (error: Error) => boolean): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) {\n                        if (predicate(e)) subscriber.onComplete();\n                        else subscriber.onError(e);\n                    },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    // ──────────────────────── Side effects ──────────────────────────────────\n\n    /**\n     * Executes a side-effect `fn` on the **first** item emitted by the source.\n     *\n     * Subsequent items pass through unchanged. Any exception thrown by `fn` is silently swallowed.\n     *\n     * @param fn - Side-effect to run on the very first item.\n     * @returns A publisher with the side effect attached to the first item.\n     */\n    public doFirst(fn: () => void): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let first = true;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        if (first) { first = false; try { fn(); } catch (_) {} }\n                        subscriber.onNext(v);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Executes a side-effect `fn` for every item emitted by the source, before\n     * forwarding the item downstream.\n     *\n     * Any exception thrown by `fn` is silently swallowed; the item is still forwarded.\n     *\n     * @param fn - Side-effect called for each item.\n     * @returns A publisher with the side effect attached to each item.\n     */\n    public doOnNext(fn: (value: T) => void): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { try { fn(v); } catch (_) {} subscriber.onNext(v); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Executes a side-effect `fn` when the source signals an error, before\n     * forwarding the error downstream.\n     *\n     * Any exception thrown by `fn` is silently swallowed; the original error is still forwarded.\n     *\n     * @param fn - Side-effect called with the error.\n     * @returns A publisher with the side effect attached to the error signal.\n     */\n    public doOnError(fn: (error: Error) => void): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) { try { fn(e); } catch (_) {} subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Executes a side-effect `fn` when the source calls `onSubscribe`, passing the\n     * resulting {@link Subscription} to the callback.\n     *\n     * Any exception thrown by `fn` is silently swallowed.\n     *\n     * @param fn - Side-effect called with the subscription object.\n     * @returns A publisher with the side effect attached to the subscribe event.\n     */\n    public doOnSubscribe(fn: (subscription: Subscription) => void): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                try { fn(sub); } catch (_) {}\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    // ──────────────────────── Scheduling ────────────────────────────────────\n\n    /**\n     * Shifts item delivery to the given `scheduler`.\n     *\n     * Each `onNext`, `onError`, and `onComplete` callback is scheduled on `scheduler`\n     * instead of being called inline. The source is still subscribed to on the\n     * calling thread; only the *delivery* of signals is redirected.\n     *\n     * @param scheduler - The scheduler on which downstream signals are delivered.\n     * @returns A publisher that delivers signals on the given scheduler.\n     */\n    public publishOn(scheduler: Scheduler): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { scheduler.schedule(() => subscriber.onNext(v)); },\n                    onError(e) { scheduler.schedule(() => subscriber.onError(e)); },\n                    onComplete() { scheduler.schedule(() => subscriber.onComplete()); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    // ──────────────────────── Error recovery ────────────────────────────────\n\n    /**\n     * Falls back to a publisher produced by `fn` when the source signals an error.\n     *\n     * Unlike {@link onErrorReturn} (which takes a static replacement), this operator\n     * calls `fn` with the actual error, allowing dynamic recovery based on the error type.\n     *\n     * @param fn - Called with the error; returns the replacement publisher.\n     * @returns A publisher that recovers from errors dynamically.\n     *\n     * @example\n     * ```typescript\n     * Flux.error(new Error('not found'))\n     *   .onErrorResume(e => e.message === 'not found' ? Flux.just('default') : Flux.error(e))\n     *   .subscribe(v => console.log(v)); // 'default'\n     * ```\n     */\n    public onErrorResume(fn: (error: Error) => Publisher<T>): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let primarySub: Subscription = { request() {}, unsubscribe() {} };\n                let altSub: Subscription | null = null;\n                let cancelled = false;\n                let demand = 0;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (altSub) altSub.request(n); else primarySub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; primarySub.unsubscribe(); altSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) { primarySub = s; subscriber.onSubscribe(operatorSub); },\n                    onNext(v: T) { subscriber.onNext(v); },\n                    onError(e: Error) {\n                        if (cancelled) return;\n                        let alt: Publisher<T>;\n                        try { alt = fn(e); }\n                        catch (fnErr) { subscriber.onError(fnErr instanceof Error ? fnErr : new Error(String(fnErr))); return; }\n                        altSub = alt.subscribe({\n                            onSubscribe(s: Subscription) { altSub = s; if (demand > 0) s.request(demand); },\n                            onNext(v: T) { subscriber.onNext(v); },\n                            onError(e2: Error) { subscriber.onError(e2); },\n                            onComplete() { subscriber.onComplete(); }\n                        });\n                    },\n                    onComplete() { subscriber.onComplete(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Transforms the error signal using `fn` before forwarding it downstream.\n     *\n     * Useful for converting low-level errors into domain-specific error types.\n     *\n     * @param fn - Receives the original error and returns a replacement error.\n     * @returns A publisher that transforms errors before propagating them.\n     *\n     * @example\n     * ```typescript\n     * Flux.error(new Error('HTTP 404'))\n     *   .onErrorMap(e => new Error(`NotFound: ${e.message}`))\n     *   .subscribe(null, e => console.error(e.message)); // NotFound: HTTP 404\n     * ```\n     */\n    public onErrorMap(fn: (error: Error) => Error): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v: T) { subscriber.onNext(v); },\n                    onError(e: Error) {\n                        try { subscriber.onError(fn(e)); }\n                        catch (fnErr) { subscriber.onError(fnErr instanceof Error ? fnErr : new Error(String(fnErr))); }\n                    },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    // ──────────────────────── Timing ────────────────────────────────────────\n\n    /**\n     * Emits a `TimeoutError` (or switches to `fallback`) if no item is received\n     * within `ms` milliseconds of the previous item (or of subscription).\n     *\n     * The timer resets on each received item, so it measures **inter-item** idle time.\n     *\n     * @param ms - Timeout duration in milliseconds.\n     * @param fallback - Optional publisher to switch to on timeout instead of erroring.\n     * @returns A publisher that errors or falls back when no item arrives in time.\n     *\n     * @example\n     * ```typescript\n     * Flux.never<number>()\n     *   .timeout(100)\n     *   .subscribe(null, e => console.error(e.message)); // TimeoutError after 100ms\n     * ```\n     */\n    public timeout(ms: number, fallback?: Publisher<T>): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let sourceSub: Subscription = { request() {}, unsubscribe() {} };\n                let altSub: Subscription | null = null;\n                let cancelled = false;\n                let sourceDone = false;\n                let terminated = false;\n                let demand = 0;\n                let timer: ReturnType<typeof setTimeout> | null = null;\n\n                const clearTimer = () => { if (timer !== null) { clearTimeout(timer); timer = null; } };\n\n                const startTimer = () => {\n                    clearTimer();\n                    timer = setTimeout(() => {\n                        if (cancelled || terminated) return;\n                        sourceDone = true;\n                        sourceSub.unsubscribe();\n                        if (fallback) {\n                            altSub = fallback.subscribe({\n                                onSubscribe(s: Subscription) { altSub = s; if (demand > 0) s.request(demand); },\n                                onNext(v: T) { if (!cancelled && !terminated) subscriber.onNext(v); },\n                                onError(e: Error) { if (!cancelled && !terminated) { terminated = true; subscriber.onError(e); } },\n                                onComplete() { if (!cancelled && !terminated) { terminated = true; subscriber.onComplete(); } }\n                            });\n                        } else {\n                            terminated = true;\n                            subscriber.onError(new Error(`TimeoutError: no item within ${ms}ms`));\n                        }\n                    }, ms);\n                };\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (altSub) altSub.request(n); else sourceSub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; clearTimer(); sourceSub.unsubscribe(); altSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) { sourceSub = s; subscriber.onSubscribe(operatorSub); startTimer(); },\n                    onNext(v: T) {\n                        if (cancelled || sourceDone) return;\n                        startTimer();\n                        subscriber.onNext(v);\n                    },\n                    onError(e: Error) {\n                        clearTimer();\n                        if (!cancelled && !terminated) { terminated = true; subscriber.onError(e); }\n                    },\n                    onComplete() {\n                        clearTimer();\n                        if (!cancelled && !terminated) { terminated = true; subscriber.onComplete(); }\n                    }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Delays the subscription to the upstream source by `ms` milliseconds.\n     *\n     * `onSubscribe` is delivered immediately with a proxy `Subscription`.\n     * Any `request(n)` calls before the delay elapses are accumulated and\n     * forwarded once the actual subscription starts.\n     *\n     * @param ms - Delay in milliseconds before subscribing to the source.\n     * @returns A publisher whose upstream subscription is deferred.\n     */\n    public delaySubscription(ms: number): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let sourceSub: Subscription | null = null;\n                let cancelled = false;\n                let demand = 0;\n\n                const proxy: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (sourceSub) sourceSub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; sourceSub?.unsubscribe(); }\n                };\n\n                subscriber.onSubscribe(proxy);\n\n                const timerId = setTimeout(() => {\n                    if (cancelled) return;\n                    this.source.subscribe({\n                        onSubscribe(s: Subscription) {\n                            sourceSub = s;\n                            if (demand > 0) s.request(demand);\n                        },\n                        onNext(v: T) { if (!cancelled) subscriber.onNext(v); },\n                        onError(e: Error) { if (!cancelled) subscriber.onError(e); },\n                        onComplete() { if (!cancelled) subscriber.onComplete(); }\n                    });\n                }, ms);\n\n                // Override unsubscribe to also clear the timer\n                const originalUnsub = proxy.unsubscribe.bind(proxy);\n                (proxy as { unsubscribe: () => void }).unsubscribe = () => { clearTimeout(timerId); originalUnsub(); };\n\n                return proxy;\n            }\n        });\n    }\n\n    // ──────────────────────── Observability ─────────────────────────────────\n\n    /**\n     * Logs each reactive signal to the console for debugging.\n     *\n     * Prints `onSubscribe`, `request(n)`, `onNext(value)`, `onError`, `onComplete`,\n     * and `cancel` with an optional label prefix.\n     *\n     * @param label - Optional label prepended to each log line (default: `'reactor'`).\n     * @returns A publisher with logging side effects attached.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2).log('source').subscribe(v => console.log(v));\n     * // [source] onSubscribe\n     * // [source] request(9007199254740991)\n     * // [source] onNext(1)\n     * // ...\n     * ```\n     */\n    public log(label: string = 'reactor'): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const tag = `[${label}]`;\n                let wrappedSub!: Subscription;\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        console.log(`${tag} onSubscribe`);\n                        wrappedSub = {\n                            request(n: number) { console.log(`${tag} request(${n})`); s.request(n); },\n                            unsubscribe() { console.log(`${tag} cancel`); s.unsubscribe(); }\n                        };\n                        subscriber.onSubscribe(wrappedSub);\n                    },\n                    onNext(v: T) { console.log(`${tag} onNext(${JSON.stringify(v)})`); subscriber.onNext(v); },\n                    onError(e: Error) { console.error(`${tag} onError: ${e.message}`); subscriber.onError(e); },\n                    onComplete() { console.log(`${tag} onComplete`); subscriber.onComplete(); }\n                });\n                return wrappedSub;\n            }\n        });\n    }\n\n    /**\n     * Executes a side-effect `fn` whenever the downstream subscriber issues a `request(n)`.\n     *\n     * Useful for debugging backpressure — see exactly how much demand is flowing upstream.\n     * Any exception thrown by `fn` is silently swallowed.\n     *\n     * @param fn - Called with the requested count `n`.\n     * @returns A publisher with the side effect attached to the request signal.\n     */\n    public doOnRequest(fn: (n: number) => void): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v: T) { subscriber.onNext(v); },\n                    onError(e: Error) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                const wrappedSub: Subscription = {\n                    request(n: number) { try { fn(n); } catch (_) {} sub.request(n); },\n                    unsubscribe() { sub.unsubscribe(); }\n                };\n                subscriber.onSubscribe(wrappedSub);\n                return wrappedSub;\n            }\n        });\n    }\n\n    /**\n     * Executes a side-effect `fn` for every reactive signal (next, error, complete).\n     *\n     * The {@link Signal} discriminated union lets you inspect the kind and payload\n     * of each event in a single callback.\n     *\n     * @param fn - Called for every signal with a {@link Signal} wrapper.\n     * @returns A publisher with the side effect attached to all signals.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2)\n     *   .doOnEach(s => { if (s.kind === 'next') console.log('item:', s.value); })\n     *   .subscribe();\n     * ```\n     */\n    public doOnEach(fn: (signal: Signal<T>) => void): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v: T) { try { fn(Signal.next(v)); } catch (_) {} subscriber.onNext(v); },\n                    onError(e: Error) { try { fn(Signal.error<T>(e)); } catch (_) {} subscriber.onError(e); },\n                    onComplete() { try { fn(Signal.complete<T>()); } catch (_) {} subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Shifts the *subscription* (and source execution) to the given `scheduler`.\n     *\n     * The actual call to `this.source.subscribe(...)` is deferred and run on `scheduler`.\n     * Downstream `onSubscribe` is delivered immediately on the calling thread with a proxy\n     * `Subscription` that buffers `request(n)` calls until the source subscription is ready.\n     *\n     * Use this for cold sources that do their work synchronously on subscribe — it moves\n     * that work to a different thread/context.\n     *\n     * @param scheduler - The scheduler on which the source is subscribed to and runs.\n     * @returns A publisher whose source execution runs on the given scheduler.\n     */\n    public subscribeOn(scheduler: Scheduler): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let sub: Subscription | null = null;\n                let pending = 0;\n                let cancelled = false;\n\n                const proxy: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        if (sub) sub.request(n); else pending = Math.min(pending + n, Number.MAX_SAFE_INTEGER);\n                    },\n                    unsubscribe() { cancelled = true; sub?.unsubscribe(); }\n                };\n\n                subscriber.onSubscribe(proxy);\n\n                scheduler.schedule(() => {\n                    if (cancelled) return;\n                    sub = this.source.subscribe({\n                        onSubscribe(_s) {},\n                        onNext(v) { subscriber.onNext(v); },\n                        onError(e) { subscriber.onError(e); },\n                        onComplete() { subscriber.onComplete(); }\n                    });\n                    if (pending > 0) sub.request(pending);\n                });\n\n                return proxy;\n            }\n        });\n    }\n}\n","import {Scheduler} from '@/schedulers/Scheduler'\n\n/**\n * A scheduler that immediately executes tasks.\n * Implements the `Scheduler` interface to execute tasks without any delay.\n */\n\nexport class ImmediateScheduler implements Scheduler {\n    /**\n     * Schedules a task to be executed immediately.\n     * @param {Function} task - The task function to be executed.\n     */\n    public schedule(task: () => void): void {\n        task()\n    }\n}\n","import {Scheduler} from \"@/schedulers/Scheduler\";\n\n/**\n * A scheduler that executes tasks asynchronously using the microtask queue.\n * Implements the `Scheduler` interface and schedules tasks using `Promise.resolve().then(...)`.\n */\nexport class MicroScheduler implements Scheduler {\n    /**\n     * Schedules a task to be executed asynchronously as a microtask.\n     * Uses `Promise.resolve().then(task)` to place the task in the microtask queue.\n     * @param {Function} task - The task function to be executed.\n     */\n    public schedule(task: () => void): void {\n        Promise.resolve().then(task)\n    }\n}\n","import {Scheduler} from \"@/schedulers/Scheduler\";\n\n/**\n * A scheduler that executes tasks asynchronously using the macro task queue.\n * Implements the `Scheduler` interface and schedules tasks using `setTimeout` with a delay of `0`.\n */\nexport class MacroScheduler implements Scheduler {\n    /**\n     * Schedules a task to be executed asynchronously.\n     * Uses `setTimeout` with a delay of `0` to place the task in the macro task queue.\n     * @param {Function} task - The task function to be executed.\n     */\n    public schedule(task: () => void): void {\n        setTimeout(task, 0)\n    }\n}\n","import {CancellableScheduler} from \"@/schedulers/Scheduler\";\n\n/**\n * A scheduler that executes tasks after a specified delay.\n * Implements the `CancellableScheduler` interface, allowing scheduled tasks to be canceled.\n */\nexport class DelayScheduler implements CancellableScheduler {\n    private readonly delay: number\n\n    /**\n     * Creates a new DelayScheduler.\n     * @param {number} delay - The delay duration in milliseconds.\n     */\n    constructor(delay: number) {\n        this.delay = delay\n    }\n\n    /**\n     * Schedules a task to be executed after the specified delay.\n     * Returns an object with a cancel method to clear the timeout.\n     * @param {Function} task - The task function to be executed.\n     * @returns {Object} An object with a `cancel` method to stop the execution.\n     */\n    public schedule(task: () => void): { cancel: () => void } {\n        const id = setTimeout(task, this.delay)\n        return {\n            /**\n             * Cancels the scheduled task.\n             */\n            cancel: () => clearTimeout(id)\n        }\n    }\n}\n","import {CancellableScheduler} from \"@/schedulers/Scheduler\";\n\n/**\n * A scheduler that executes tasks multiple times with a specified interval.\n * Implements the `CancellableScheduler` interface, allowing scheduled tasks to be canceled.\n */\nexport class IntervalScheduler implements CancellableScheduler {\n    private readonly interval: number\n\n    /**\n     * Creates a new IntervalScheduler.\n     * @param {number} delay - The interval duration in milliseconds.\n     */\n    constructor(delay: number) {\n        this.interval = delay\n    }\n\n    /**\n     * Schedules a task to be executed multiple times with a specified interval.\n     * Returns an object with a cancel method to clear the timeout.\n     * @param {Function} task - The task function to be executed.\n     * @returns {Object} An object with a `cancel` method to stop the execution.\n     */\n    public schedule(task: () => void): { cancel: () => void } {\n        const id = setInterval(task, this.interval)\n        return {\n            /**\n             * Cancels the scheduled task.\n             */\n            cancel: () => clearInterval(id)\n        }\n    }\n}\n","import {ImmediateScheduler} from \"@/schedulers/ImmediateScheduler\";\nimport {MicroScheduler} from \"@/schedulers/MicroScheduler\";\nimport {MacroScheduler} from \"@/schedulers/MacroScheduler\";\nimport {DelayScheduler} from \"@/schedulers/DelayScheduler\";\nimport {IntervalScheduler} from \"@/schedulers/IntervalScheduler\";\n\nexport * from '@/schedulers/Scheduler'\n\n/**\n * A collection of commonly used schedulers for task execution.\n * Provides methods to create instances of various scheduler types.\n */\nexport const Schedulers = {\n    /**\n     * Creates an instance of `ImmediateScheduler`.\n     * Executes tasks immediately without any delay.\n     * @returns {ImmediateScheduler} An instance of ImmediateScheduler.\n     */\n    immediate: (): ImmediateScheduler => new ImmediateScheduler(),\n    /**\n     * Creates an instance of `MicroScheduler`.\n     * Executes tasks asynchronously using the microtask queue.\n     * @returns {MicroScheduler} An instance of MicroScheduler.\n     */\n    micro: (): MicroScheduler => new MicroScheduler(),\n    /**\n     * Creates an instance of `MacroScheduler`.\n     * Executes tasks asynchronously using the macro task queue (via `setTimeout`).\n     * @returns {MacroScheduler} An instance of MacroScheduler.\n     */\n    macro: (): MacroScheduler => new MacroScheduler(),\n    /**\n     * Creates an instance of `DelayScheduler` with a specified delay.\n     * Executes tasks after a given delay using `setTimeout`.\n     * @param {number} ms - The delay in milliseconds before executing the task.\n     * @returns {DelayScheduler} An instance of DelayScheduler.\n     */\n    delay: (ms: number): DelayScheduler => new DelayScheduler(ms),\n    /**\n     * Creates an instance of `IntervalScheduler` with a specified interval.\n     * Executes tasks multiple times with a given interval using `setInterval`.\n     * @param {number} ms - The interval in milliseconds between task executing.\n     * @returns {IntervalScheduler} An instance of IntervalScheduler.\n     */\n    interval: (ms: number): IntervalScheduler => new IntervalScheduler(ms)\n}","import {PipePublisher} from \"@/publishers/PipePublisher\";\nimport {Publisher} from \"@/publishers/Publisher\";\nimport {Sink} from \"@/sinks/Sink\";\nimport {Mono} from \"@/publishers/Mono\";\nimport {Subscriber} from \"@/subscriptions/Subscriber\";\nimport {Subscription} from \"@/subscriptions/Subscription\";\nimport ReplayAllSink from \"@/sinks/ReplayAllSink\";\nimport {AbstractPipePublisher} from \"@/publishers/internal/AbstractPipePublisher\";\nimport {Schedulers} from \"@/schedulers\";\nimport {Signal} from \"@/publishers/Signal\";\nimport {FluxSink} from \"@/publishers/FluxSink\";\n\n/**\n * A cold publisher of 0 to N items with full backpressure support.\n *\n * Items flow only when the downstream {@link Subscription} issues `request(n)`.\n * The convenience `subscribe(onNext, onError, onComplete)` overloads\n * automatically request `Number.MAX_SAFE_INTEGER` so items start arriving\n * without extra ceremony.\n *\n * Each `subscribe()` call creates an **independent** run of the pipeline\n * (\"cold\" semantics). Use {@link Flux.cache} or {@link Sinks} to share a\n * single run across multiple subscribers.\n *\n * @typeParam T - The type of items emitted by this Flux.\n *\n * @example\n * ```typescript\n * Flux.just(1, 2, 3)\n *   .map(n => n * 2)\n *   .filter(n => n > 2)\n *   .subscribe(v => console.log(v));\n * // 4  6\n * ```\n */\nexport class Flux<T> extends AbstractPipePublisher<T, Flux<T>> implements PipePublisher<T> {\n\n    protected constructor(source: Publisher<T>) { super(source); }\n\n    protected defaultDemand(): number { return Number.MAX_SAFE_INTEGER; }\n\n    protected wrapSource(source: Publisher<T>): Flux<T> {\n        return new Flux<T>(source);\n    }\n\n    // ─────────────────────────── Static factories ────────────────────────────\n\n    /**\n     * Wraps an existing {@link Publisher} as a `Flux`.\n     *\n     * @param publisher - Any `Publisher<T>` to adapt.\n     * @returns A `Flux<T>` backed by the given publisher.\n     */\n    public static from<T>(publisher: Publisher<T>): Flux<T> {\n        return new Flux<T>(publisher);\n    }\n\n    /**\n     * Creates a `Flux` from a generator function that pushes values imperatively.\n     *\n     * The generator receives a {@link Sink} and may call `sink.next(v)` any number\n     * of times, then `sink.complete()` or `sink.error(e)`.  Delivery is\n     * **backpressure-aware**: items pushed when demand is zero are buffered and\n     * delivered as downstream issues `request(n)`.\n     *\n     * Rule 1.3 is respected — `onSubscribe` is delivered to the subscriber\n     * **before** the generator runs.\n     *\n     * @param generator - Function that pushes items via the provided `Sink<T>`.\n     * @returns A cold `Flux<T>`.\n     *\n     * @example\n     * ```typescript\n     * Flux.generate<number>(sink => {\n     *   sink.next(1);\n     *   sink.next(2);\n     *   sink.complete();\n     * }).subscribe(v => console.log(v)); // 1  2\n     * ```\n     */\n    public static generate<T>(generator: (sink: Sink<T>) => void): Flux<T> {\n        return new Flux<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                const buffer: T[] = [];\n                let demand = 0;\n                let terminated = false;\n                let terminalDelivered = false;\n                let terminalError: Error | null = null;\n                let cancelled = false;\n                let draining = false;\n\n                const drain = () => {\n                    if (draining || cancelled) return;\n                    draining = true;\n                    try {\n                        while (demand > 0 && buffer.length > 0) {\n                            demand--;\n                            subscriber.onNext(buffer.shift()!);\n                            if (cancelled) return;\n                        }\n                        if (!terminalDelivered && buffer.length === 0 && terminated) {\n                            terminalDelivered = true;\n                            terminalError\n                                ? subscriber.onError(terminalError)\n                                : subscriber.onComplete();\n                        }\n                    } finally {\n                        draining = false;\n                    }\n                };\n\n                const sink: Sink<T> = {\n                    next(v: T) {\n                        if (terminated || cancelled) return;\n                        if (demand > 0) { demand--; subscriber.onNext(v); }\n                        else buffer.push(v);\n                    },\n                    error(err: Error) {\n                        if (terminated || cancelled) return;\n                        terminated = true;\n                        terminalError = err;\n                        drain();\n                    },\n                    complete() {\n                        if (terminated || cancelled) return;\n                        terminated = true;\n                        drain();\n                    }\n                };\n\n                const subscription: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) {\n                            subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                            return;\n                        }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        drain();\n                    },\n                    unsubscribe() {\n                        cancelled = true;\n                        buffer.length = 0;\n                    }\n                };\n\n                // Rule 1.3: onSubscribe MUST be the first signal — call it before the generator.\n                subscriber.onSubscribe(subscription);\n\n                try { generator(sink); }\n                catch (e) {\n                    if (!terminated) {\n                        terminated = true;\n                        terminalError = e instanceof Error ? e : new Error(String(e));\n                        drain();\n                    }\n                }\n\n                return subscription;\n            }\n        });\n    }\n\n    /**\n     * Creates a `Flux` that emits every element of an `Iterable` in order, then completes.\n     *\n     * @param iterable - Any `Iterable<T>` (Array, Set, Map, generator, etc.).\n     * @returns A cold `Flux<T>`.\n     *\n     * @example\n     * ```typescript\n     * Flux.fromIterable(['a', 'b', 'c']).subscribe(v => console.log(v));\n     * // a  b  c\n     * ```\n     */\n    public static fromIterable<T>(iterable: Iterable<T>): Flux<T> {\n        return Flux.generate<T>(sink => {\n            for (const item of iterable) sink.next(item);\n            sink.complete();\n        });\n    }\n\n    /**\n     * Creates a `Flux` that emits `count` sequential integers starting at `start`.\n     *\n     * @param start - First integer to emit.\n     * @param count - Number of integers to emit.\n     * @returns A cold `Flux<number>` emitting `[start, start + count)`.\n     *\n     * @example\n     * ```typescript\n     * Flux.range(0, 5).subscribe(v => console.log(v)); // 0 1 2 3 4\n     * ```\n     */\n    public static range(start: number, count: number): Flux<number> {\n        return Flux.generate<number>(sink => {\n            for (let i = 0; i < count; i++) sink.next(start + i);\n            sink.complete();\n        });\n    }\n\n    /**\n     * Creates a `Flux` that completes immediately without emitting any items.\n     *\n     * @returns An empty, completed `Flux<T>`.\n     */\n    public static empty<T = never>(): Flux<T> {\n        return new Flux<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                const sub = { request() {}, unsubscribe() {} };\n                subscriber.onSubscribe(sub);\n                subscriber.onComplete();\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Lazily creates a new `Flux` per subscription by calling `factory`.\n     *\n     * Useful when the source depends on mutable state that should be captured\n     * at subscribe time rather than at assembly time.\n     *\n     * @param factory - Called once per subscription to produce the actual `Flux<T>`.\n     * @returns A lazy `Flux<T>`.\n     */\n    public static defer<T>(factory: () => Flux<T>): Flux<T> {\n        return new Flux<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                return factory().subscribe(subscriber);\n            }\n        });\n    }\n\n    /**\n     * Creates a `Flux` that emits the provided items in order, then completes.\n     *\n     * @param items - Zero or more items to emit.\n     * @returns A cold `Flux<T>`.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3).subscribe(v => console.log(v)); // 1  2  3\n     * ```\n     */\n    public static just<T>(...items: T[]): Flux<T> {\n        return Flux.fromIterable(items);\n    }\n\n    /**\n     * Creates a `Flux` that signals `onError` immediately upon subscription.\n     *\n     * @param error - The error to signal.\n     * @returns An errored `Flux<T>`.\n     */\n    public static error<T = never>(error: Error): Flux<T> {\n        return new Flux<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                const sub = { request() {}, unsubscribe() {} };\n                subscriber.onSubscribe(sub);\n                subscriber.onError(error);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Creates a `Flux` that never emits any signal — no items, no error, no completion.\n     * Useful as a placeholder or to represent an infinite, empty stream.\n     *\n     * @returns A `Flux<T>` that stays subscribed forever.\n     */\n    public static never<T = never>(): Flux<T> {\n        return new Flux<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                const sub = { request() {}, unsubscribe() {} };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Creates a `Flux` from a generator function that **pushes** values imperatively\n     * via a {@link FluxSink}.\n     *\n     * Unlike {@link Flux.generate} (which is request-pull), `create` is designed for\n     * **push-based** sources (EventEmitter, WebSocket, DOM events, Node.js streams).\n     * Items pushed when downstream demand is zero are **buffered** and delivered as demand\n     * becomes available.\n     *\n     * Register `onRequest`, `onCancel`, and `onDispose` callbacks on the sink to respond\n     * to downstream lifecycle events.\n     *\n     * @param emitter - Called once per subscription; receives a `FluxSink<T>` for pushing values.\n     * @returns A cold `Flux<T>`.\n     *\n     * @example\n     * ```typescript\n     * const emitter = new EventEmitter();\n     * const flux = Flux.create<string>(sink => {\n     *   emitter.on('data', v => sink.next(v));\n     *   emitter.on('end',  () => sink.complete());\n     *   sink.onCancel(() => emitter.removeAllListeners());\n     * });\n     * ```\n     */\n    public static create<T>(emitter: (sink: FluxSink<T>) => void): Flux<T> {\n        return new Flux<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                const buffer: T[] = [];\n                let demand = 0;\n                let cancelled = false;\n                let terminated = false;\n                let terminalError: Error | null = null;\n                let draining = false;\n\n                const requestCbs: Array<(n: number) => void> = [];\n                const cancelCbs: Array<() => void> = [];\n                const disposeCbs: Array<() => void> = [];\n\n                const fireDispose = () => { for (const fn of disposeCbs) try { fn(); } catch (_) {} };\n\n                const drain = () => {\n                    if (draining || cancelled) return;\n                    draining = true;\n                    try {\n                        while (demand > 0 && buffer.length > 0 && !cancelled) {\n                            demand--;\n                            subscriber.onNext(buffer.shift()!);\n                        }\n                        if (terminated && buffer.length === 0 && !cancelled) {\n                            if (terminalError) subscriber.onError(terminalError);\n                            else subscriber.onComplete();\n                        }\n                    } finally { draining = false; }\n                };\n\n                const sink: FluxSink<T> = {\n                    next(value: T) {\n                        if (cancelled || terminated) return;\n                        buffer.push(value);\n                        drain();\n                    },\n                    error(error: Error) {\n                        if (cancelled || terminated) return;\n                        terminated = true;\n                        terminalError = error;\n                        fireDispose();\n                        drain();\n                    },\n                    complete() {\n                        if (cancelled || terminated) return;\n                        terminated = true;\n                        fireDispose();\n                        drain();\n                    },\n                    get requested() { return demand; },\n                    onRequest(fn) { requestCbs.push(fn); return sink; },\n                    onCancel(fn) { cancelCbs.push(fn); return sink; },\n                    onDispose(fn) { disposeCbs.push(fn); return sink; }\n                };\n\n                const sub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || (terminated && buffer.length === 0)) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        for (const fn of requestCbs) try { fn(n); } catch (_) {}\n                        drain();\n                    },\n                    unsubscribe() {\n                        if (cancelled) return;\n                        cancelled = true;\n                        buffer.length = 0;\n                        for (const fn of cancelCbs) try { fn(); } catch (_) {}\n                        fireDispose();\n                    }\n                };\n\n                // Rule 1.3: onSubscribe is the first signal delivered to the subscriber.\n                subscriber.onSubscribe(sub);\n                try { emitter(sink); }\n                catch (e) { if (!terminated && !cancelled) sink.error(e instanceof Error ? e : new Error(String(e))); }\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Creates a `Flux` that acquires a resource, uses it to build a source publisher,\n     * and guarantees the resource is cleaned up when the stream terminates or is cancelled.\n     *\n     * The cleanup runs after `onComplete`, `onError`, or `unsubscribe()` — whichever\n     * happens first.\n     *\n     * @param resourceSupplier - Called once per subscription to acquire the resource.\n     * @param sourceFactory - Builds the source publisher from the resource.\n     * @param cleanup - Called with the resource after the stream terminates.\n     * @returns A `Flux<T>` with guaranteed resource cleanup.\n     *\n     * @example\n     * ```typescript\n     * Flux.using(\n     *   () => openFile('data.txt'),\n     *   file => Flux.fromIterable(file.readLines()),\n     *   file => file.close()\n     * ).subscribe(line => console.log(line));\n     * ```\n     */\n    public static using<T, R>(\n        resourceSupplier: () => R,\n        sourceFactory: (resource: R) => Publisher<T>,\n        cleanup: (resource: R) => void\n    ): Flux<T> {\n        return Flux.defer(() => {\n            const resource = resourceSupplier();\n            return Flux.from(sourceFactory(resource))\n                .doFinally(() => { try { cleanup(resource); } catch (_) {} });\n        });\n    }\n\n    /**\n     * Merges N publishers by subscribing to all of them concurrently and interleaving\n     * their items as they arrive.\n     *\n     * The stream completes when **all** sources complete.\n     * Any error from any source terminates the merged stream immediately.\n     *\n     * @param sources - Publishers to merge.\n     * @returns A `Flux<T>` that emits items from all sources concurrently.\n     *\n     * @example\n     * ```typescript\n     * Flux.merge(Flux.just(1, 2), Flux.just(3, 4)).subscribe(v => console.log(v));\n     * // 1 2 3 4 (order may vary for async sources)\n     * ```\n     */\n    public static merge<T>(...sources: Publisher<T>[]): Flux<T> {\n        if (sources.length === 0) return Flux.empty<T>();\n        if (sources.length === 1) return Flux.from(sources[0]);\n        return new Flux<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                const n = sources.length;\n                let doneCount = 0;\n                let cancelled = false;\n                let terminated = false;\n                // Populated synchronously before onSubscribe is called (RS 1.9 guarantees\n                // that Publisher.subscribe calls onSubscribe synchronously).\n                const subs: Subscription[] = new Array(n);\n\n                const terminate = (err?: Error) => {\n                    if (terminated) return;\n                    terminated = true;\n                    for (const s of subs) s?.unsubscribe();\n                    if (err) subscriber.onError(err);\n                    else subscriber.onComplete();\n                };\n\n                const operatorSub: Subscription = {\n                    request(count: number) {\n                        if (cancelled || terminated) return;\n                        if (count <= 0) { terminate(new Error(`request must be > 0, but was ${count}`)); return; }\n                        for (const s of subs) s.request(count);\n                    },\n                    unsubscribe() { cancelled = true; for (const s of subs) s?.unsubscribe(); }\n                };\n\n                // Subscribe to all sources first so subs[] is fully populated before\n                // subscriber.onSubscribe is called — this prevents losing demand that\n                // the subscriber issues immediately inside onSubscribe (RS rule 2.7 /\n                // convenience overloads call request() from onSubscribe).\n                for (let i = 0; i < n; i++) {\n                    let inner!: Subscription;\n                    sources[i].subscribe({\n                        onSubscribe(s: Subscription) { inner = s; },\n                        onNext(v: T) { if (!cancelled && !terminated) subscriber.onNext(v); },\n                        onError(e: Error) { terminate(e); },\n                        onComplete() { if (++doneCount === n) terminate(); }\n                    });\n                    subs[i] = inner;\n                }\n\n                subscriber.onSubscribe(operatorSub);\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Subscribes to all `sources` concurrently and emits the **first value** produced\n     * by any of them. All other subscriptions are cancelled immediately after the winner emits.\n     *\n     * If all sources complete without emitting a value, the result completes empty.\n     * Errors from non-winning sources are ignored once a winner is found.\n     *\n     * @param sources - Publishers to race.\n     * @returns A `Flux<T>` that emits the first value from any source.\n     *\n     * @example\n     * ```typescript\n     * // Take whichever request responds first\n     * Flux.firstWithValue(fetchFromCDN(), fetchFromOrigin())\n     *   .subscribe(data => console.log(data));\n     * ```\n     */\n    public static firstWithValue<T>(...sources: Publisher<T>[]): Flux<T> {\n        return new Flux<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                if (sources.length === 0) {\n                    const sub = { request() {}, unsubscribe() {} };\n                    subscriber.onSubscribe(sub);\n                    subscriber.onComplete();\n                    return sub;\n                }\n\n                const n = sources.length;\n                let won = false;\n                let cancelled = false;\n                let finished = 0;\n                let lastError: Error | null = null;\n                const subs: Subscription[] = new Array(n);\n\n                const operatorSub: Subscription = {\n                    request(count: number) { if (!cancelled) for (const s of subs) s.request(count); },\n                    unsubscribe() { cancelled = true; for (const s of subs) s?.unsubscribe(); }\n                };\n\n                // Collect all subscriptions before calling subscriber.onSubscribe so that\n                // demand issued inside onSubscribe reaches every source.\n                for (let i = 0; i < n; i++) {\n                    const idx = i;\n                    let inner!: Subscription;\n                    sources[idx].subscribe({\n                        onSubscribe(s: Subscription) { inner = s; },\n                        onNext(v: T) {\n                            if (cancelled || won) return;\n                            won = true;\n                            for (let j = 0; j < n; j++) { if (j !== idx) subs[j]?.unsubscribe(); }\n                            subscriber.onNext(v);\n                            subscriber.onComplete();\n                        },\n                        onError(e: Error) {\n                            if (cancelled || won) return;\n                            lastError = e;\n                            if (++finished === n) subscriber.onError(lastError!);\n                        },\n                        onComplete() {\n                            if (cancelled || won) return;\n                            if (++finished === n) subscriber.onComplete();\n                        }\n                    });\n                    subs[idx] = inner;\n                }\n\n                subscriber.onSubscribe(operatorSub);\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Emits an ever-incrementing counter (0, 1, 2, …) at a fixed `ms` rate.\n     *\n     * Items are **dropped** when downstream has no outstanding demand (rather than\n     * buffered), matching Reactor's `Flux.interval` drop-on-overflow behaviour.\n     * The stream never completes on its own — cancel the subscription to stop it.\n     *\n     * @param ms - Interval duration in milliseconds.\n     * @returns An infinite `Flux<number>`.\n     *\n     * @example\n     * ```typescript\n     * Flux.interval(1000).take(3).subscribe(n => console.log(n)); // 0  1  2\n     * ```\n     */\n    public static interval(ms: number): Flux<number> {\n        return new Flux<number>({\n            subscribe(subscriber: Subscriber<number>): Subscription {\n                let demand = 0;\n                let counter = 0;\n                let cancelled = false;\n                const id = setInterval(() => {\n                    if (cancelled) return;\n                    if (demand > 0) {\n                        demand--;\n                        subscriber.onNext(counter++);\n                    }\n                    // demand === 0 → drop the tick (matches Reactor's interval behaviour)\n                }, ms);\n                const sub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                    },\n                    unsubscribe() { cancelled = true; clearInterval(id); }\n                };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Combines items from 2 sources positionally via `combiner`.\n     * Emits one combined value for each position; stops when the shorter source exhausts.\n     */\n    public static zip<A, B, R>(\n        sources: [Publisher<A>, Publisher<B>],\n        combiner: (a: A, b: B) => R\n    ): Flux<R>;\n\n    /**\n     * Combines items from 3 sources positionally via `combiner`.\n     */\n    public static zip<A, B, C, R>(\n        sources: [Publisher<A>, Publisher<B>, Publisher<C>],\n        combiner: (a: A, b: B, c: C) => R\n    ): Flux<R>;\n\n    /**\n     * Combines items from 4 sources positionally via `combiner`.\n     */\n    public static zip<A, B, C, D, R>(\n        sources: [Publisher<A>, Publisher<B>, Publisher<C>, Publisher<D>],\n        combiner: (a: A, b: B, c: C, d: D) => R\n    ): Flux<R>;\n\n    /**\n     * General N-source positional zip.\n     *\n     * Subscribes to each source concurrently, using a prefetch of 1 per source.\n     * Once every source has provided one item for a given position, `combiner` is\n     * called with those items and the result is emitted downstream.  The stream\n     * completes when any source completes and has no buffered items left.\n     *\n     * @param sources - Publishers to zip.\n     * @param combiner - Combines one item from each source at the same position.\n     * @returns A `Flux<R>` of combined values.\n     *\n     * @example\n     * ```typescript\n     * Flux.zip([Flux.just(1, 2), Flux.just('a', 'b')], (n, s) => `${n}${s}`)\n     *   .subscribe(v => console.log(v)); // '1a'  '2b'\n     * ```\n     */\n    public static zip<T, R>(\n        sources: Publisher<T>[],\n        combiner: (...args: T[]) => R\n    ): Flux<R>;\n\n    public static zip(\n        sources: Publisher<unknown>[],\n        combiner: (...args: unknown[]) => unknown\n    ): Flux<unknown> {\n        if (sources.length === 0) return Flux.empty();\n        return new Flux<unknown>({\n            subscribe(subscriber: Subscriber<unknown>): Subscription {\n                const n = sources.length;\n                let demand = 0;\n                let cancelled = false;\n                let terminated = false;\n                const queues: unknown[][] = Array.from({ length: n }, () => []);\n                const completed: boolean[] = new Array(n).fill(false);\n                const subs: Subscription[] = new Array(n);\n\n                const tryEmit = () => {\n                    while (!cancelled && !terminated && demand > 0 && queues.every(q => q.length > 0)) {\n                        demand--;\n                        const args = queues.map(q => q.shift()!);\n                        let result: unknown;\n                        try { result = combiner(...args); }\n                        catch (e) {\n                            terminated = true;\n                            for (const s of subs) s?.unsubscribe();\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                            return;\n                        }\n                        subscriber.onNext(result);\n                        // Re-fetch 1 from each source that just provided an item\n                        for (let i = 0; i < n; i++) {\n                            if (!completed[i]) subs[i].request(1);\n                        }\n                    }\n                    // Complete when any source is exhausted (queue empty + completed)\n                    if (!terminated && completed.some((done, i) => done && queues[i].length === 0)) {\n                        terminated = true;\n                        for (const s of subs) s?.unsubscribe();\n                        subscriber.onComplete();\n                    }\n                };\n\n                const operatorSub: Subscription = {\n                    request(count: number) {\n                        if (cancelled || terminated) return;\n                        if (count <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${count}`)); return; }\n                        demand = Math.min(demand + count, Number.MAX_SAFE_INTEGER);\n                        tryEmit();\n                    },\n                    unsubscribe() { cancelled = true; for (const s of subs) s?.unsubscribe(); }\n                };\n\n                for (let i = 0; i < n; i++) {\n                    const idx = i;\n                    let inner!: Subscription;\n                    sources[idx].subscribe({\n                        onSubscribe(s: Subscription) { inner = s; },\n                        onNext(v: unknown) {\n                            if (cancelled || terminated) return;\n                            queues[idx].push(v);\n                            tryEmit();\n                        },\n                        onError(e: Error) {\n                            if (cancelled || terminated) return;\n                            terminated = true;\n                            for (const s of subs) s?.unsubscribe();\n                            subscriber.onError(e);\n                        },\n                        onComplete() {\n                            if (cancelled || terminated) return;\n                            completed[idx] = true;\n                            tryEmit(); // triggers completion check\n                        }\n                    });\n                    subs[idx] = inner;\n                }\n\n                subscriber.onSubscribe(operatorSub);\n                // Prefetch 1 from each source\n                for (let i = 0; i < n; i++) subs[i].request(1);\n                return operatorSub;\n            }\n        }) as Flux<unknown>;\n    }\n\n    /**\n     * Combines the **latest** value from each source whenever any source emits.\n     *\n     * Does not emit until all sources have produced at least one value.\n     * Continues emitting with each new item from any source, using the latest values\n     * from all others.  Sources run at unbounded speed; downstream demand controls delivery.\n     *\n     * @param sources - Publishers to combine.\n     * @param combiner - Called with the latest value from each source.\n     * @returns A `Flux<R>` of combined values.\n     *\n     * @example\n     * ```typescript\n     * Flux.combineLatest([Flux.just(1, 2), Flux.just('a', 'b')], (n, s) => `${n}${s}`)\n     *   .subscribe(v => console.log(v)); // '1a'  '2a'  '2b'  (order depends on timing)\n     * ```\n     */\n    public static combineLatest<A, B, R>(\n        sources: [Publisher<A>, Publisher<B>],\n        combiner: (a: A, b: B) => R\n    ): Flux<R>;\n\n    public static combineLatest<A, B, C, R>(\n        sources: [Publisher<A>, Publisher<B>, Publisher<C>],\n        combiner: (a: A, b: B, c: C) => R\n    ): Flux<R>;\n\n    public static combineLatest<A, B, C, D, R>(\n        sources: [Publisher<A>, Publisher<B>, Publisher<C>, Publisher<D>],\n        combiner: (a: A, b: B, c: C, d: D) => R\n    ): Flux<R>;\n\n    public static combineLatest<T, R>(\n        sources: Publisher<T>[],\n        combiner: (...args: T[]) => R\n    ): Flux<R>;\n\n    public static combineLatest(\n        sources: Publisher<unknown>[],\n        combiner: (...args: unknown[]) => unknown\n    ): Flux<unknown> {\n        if (sources.length === 0) return Flux.empty();\n        return new Flux<unknown>({\n            subscribe(subscriber: Subscriber<unknown>): Subscription {\n                const n = sources.length;\n                let demand = 0;\n                let cancelled = false;\n                let terminated = false;\n                const pending: unknown[] = [];\n                const latest: unknown[] = new Array(n).fill(undefined);\n                const hasValue: boolean[] = new Array(n).fill(false);\n                const completed: boolean[] = new Array(n).fill(false);\n                const subs: Subscription[] = new Array(n);\n\n                const flush = () => {\n                    while (!cancelled && !terminated && demand > 0 && pending.length > 0) {\n                        demand--;\n                        subscriber.onNext(pending.shift()!);\n                    }\n                    if (!terminated && completed.every(Boolean) && pending.length === 0) {\n                        terminated = true;\n                        subscriber.onComplete();\n                    }\n                };\n\n                const operatorSub: Subscription = {\n                    request(count: number) {\n                        if (cancelled || terminated) return;\n                        if (count <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${count}`)); return; }\n                        demand = Math.min(demand + count, Number.MAX_SAFE_INTEGER);\n                        flush();\n                    },\n                    unsubscribe() { cancelled = true; for (const s of subs) s?.unsubscribe(); }\n                };\n\n                for (let i = 0; i < n; i++) {\n                    const idx = i;\n                    let inner!: Subscription;\n                    sources[idx].subscribe({\n                        onSubscribe(s: Subscription) { inner = s; },\n                        onNext(v: unknown) {\n                            if (cancelled || terminated) return;\n                            latest[idx] = v;\n                            hasValue[idx] = true;\n                            if (hasValue.every(Boolean)) {\n                                let result: unknown;\n                                try { result = combiner(...latest); }\n                                catch (e) {\n                                    terminated = true;\n                                    for (const s of subs) s?.unsubscribe();\n                                    subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                                    return;\n                                }\n                                pending.push(result);\n                                flush();\n                            }\n                        },\n                        onError(e: Error) {\n                            if (cancelled || terminated) return;\n                            terminated = true;\n                            for (const s of subs) s?.unsubscribe();\n                            subscriber.onError(e);\n                        },\n                        onComplete() {\n                            if (cancelled || terminated) return;\n                            completed[idx] = true;\n                            flush(); // may trigger completion if all done\n                        }\n                    });\n                    subs[idx] = inner;\n                }\n\n                subscriber.onSubscribe(operatorSub);\n                // Sources run unbounded; combined output is buffered by pending[] and\n                // released as downstream demand arrives.\n                for (let i = 0; i < n; i++) subs[i].request(Number.MAX_SAFE_INTEGER);\n                return operatorSub;\n            }\n        }) as Flux<unknown>;\n    }\n\n    // ─────────────────── PipePublisher operators ──────────────────\n\n    /**\n     * Transforms each item using `fn`, producing a `Flux<R>`.\n     *\n     * If `fn` throws, the exception is forwarded to `onError` and the stream terminates.\n     *\n     * @param fn - Mapping function applied to every item.\n     * @returns A new `Flux<R>`.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3).map(n => n * 10).subscribe(v => console.log(v));\n     * // 10  20  30\n     * ```\n     */\n    public map<R>(fn: (value: T) => R): Flux<R> {\n        return new Flux<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        try { subscriber.onNext(fn(v)); }\n                        catch (e) { subscriber.onError(e instanceof Error ? e : new Error(String(e))); }\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Transforms each item with `fn`, silently discarding `null`/`undefined` results.\n     *\n     * When an item is discarded, upstream demand is replenished by 1 so the\n     * downstream demand accounting stays correct.\n     *\n     * @param fn - Mapping function; returning `null` or `undefined` skips the item.\n     * @returns A `Flux<NonNullable<R>>` with nulls filtered out.\n     *\n     * @example\n     * ```typescript\n     * Flux.just('hello', '', 'world')\n     *   .mapNotNull(s => s.length > 0 ? s : null)\n     *   .subscribe(v => console.log(v));\n     * // hello  world\n     * ```\n     */\n    public mapNotNull<R>(fn: (value: T) => R | null | undefined): Flux<NonNullable<R>> {\n        return new Flux<NonNullable<R>>({\n            subscribe: (subscriber: Subscriber<NonNullable<R>>): Subscription => {\n                let sourceSub!: Subscription;\n                const sub = this.source.subscribe({\n                    onSubscribe(s) { sourceSub = s; },\n                    onNext(v) {\n                        try {\n                            const r = fn(v);\n                            if (r != null) subscriber.onNext(r as NonNullable<R>);\n                            else sourceSub.request(1); // replenish: null item skipped\n                        } catch (e) {\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                        }\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Fine-grained per-item transform: the `handler` receives each item together with\n     * a {@link Sink} and may emit **0 or 1** result items.\n     *\n     * - Calling `sink.next(r)` once emits `r` downstream.\n     * - Calling `sink.next(r)` more than once is silently ignored (0-or-1 semantics).\n     * - Calling `sink.complete()` or `sink.error(e)` terminates the stream early.\n     * - If the handler emits nothing (0 items), upstream demand is replenished by 1.\n     *\n     * This is the Flux equivalent of `reactor-core`'s `handle(BiConsumer<T, SynchronousSink<R>>)`.\n     *\n     * @param handler - Called for each upstream item with the item and an output `Sink<R>`.\n     * @returns A `Flux<R>`.\n     *\n     * @example\n     * ```typescript\n     * // Convert strings to numbers, skip non-numeric entries\n     * Flux.just('1', 'two', '3').handle<number>((s, sink) => {\n     *   const n = parseInt(s);\n     *   if (!isNaN(n)) sink.next(n);\n     * }).subscribe(v => console.log(v));\n     * // 1  3\n     * ```\n     */\n    public handle<R>(handler: (value: T, sink: Sink<R>) => void): Flux<R> {\n        return new Flux<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                let sourceSub!: Subscription;\n                let done = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(s) { sourceSub = s; },\n                    onNext(v) {\n                        if (done) return;\n                        let emitted = false;\n                        const sinkWrapper: Sink<R> = {\n                            next(r) {\n                                if (!emitted && !done) { emitted = true; subscriber.onNext(r); }\n                            },\n                            error(e) { if (!done) { done = true; subscriber.onError(e); } },\n                            complete() { if (!done) { done = true; subscriber.onComplete(); } }\n                        };\n                        try { handler(v, sinkWrapper); }\n                        catch (e) { if (!done) { done = true; subscriber.onError(e instanceof Error ? e : new Error(String(e))); } }\n                        // Replenish: item was skipped (0 emissions) — request one more from upstream\n                        if (!done && !emitted) sourceSub.request(1);\n                    },\n                    onError(e) { if (!done) subscriber.onError(e); },\n                    onComplete() { if (!done) subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Maps each item to an inner publisher and merges all inner publishers concurrently\n     * into a single `Flux<R>` (**merge** semantics).\n     *\n     * Inner publishers are subscribed to as soon as their corresponding outer item arrives.\n     * Items from different inner publishers can interleave. The resulting stream completes\n     * when the outer source completes **and** all inner publishers complete. Any error\n     * (from outer or any inner) immediately terminates the stream.\n     *\n     * @param fn - Maps each item to a `Flux<R>`, `Mono<R>`, or any `Publisher<R>`.\n     * @returns A merged `Flux<R>`.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3)\n     *   .flatMap(n => Mono.just(n * 10))\n     *   .subscribe(v => console.log(v));\n     * // 10  20  30  (order may vary with async inner publishers)\n     * ```\n     */\n    public flatMap<R>(fn: (value: T) => Flux<R>): Flux<R>;\n    public flatMap<R>(fn: (value: T) => Mono<R>): Flux<R>;\n    public flatMap<R>(fn: (value: T) => Publisher<R>): Flux<R>;\n    public flatMap<R>(fn: (value: T) => Publisher<R>): Flux<R> {\n        return new Flux<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                let outerSub: Subscription = { request() {}, unsubscribe() {} };\n                const innerSubs = new Set<Subscription>();\n                let cancelled = false;\n                let terminated = false;\n                let outerDone = false;\n                let demand = 0;\n\n                // Cancel all upstream sources and signal terminal to downstream exactly once.\n                const terminate = (err?: Error) => {\n                    if (terminated) return;\n                    terminated = true;\n                    outerSub.unsubscribe();\n                    for (const s of innerSubs) s.unsubscribe();\n                    innerSubs.clear();\n                    if (err) subscriber.onError(err);\n                    else subscriber.onComplete();\n                };\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { terminate(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        for (const s of innerSubs) s.request(n);\n                    },\n                    unsubscribe() {\n                        cancelled = true;\n                        outerSub.unsubscribe();\n                        for (const s of innerSubs) s.unsubscribe();\n                        innerSubs.clear();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(sourceSub: Subscription) {\n                        outerSub = sourceSub;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (cancelled || terminated) return;\n                        let inner: Publisher<R>;\n                        try { inner = fn(v); }\n                        catch (e) { terminate(e instanceof Error ? e : new Error(String(e))); return; }\n                        const innerSub = inner.subscribe({\n                            onSubscribe(_s) {},\n                            onNext(r) { if (!cancelled && !terminated) subscriber.onNext(r); },\n                            onError(e) { terminate(e); },\n                            onComplete() {\n                                innerSubs.delete(innerSub);\n                                if (!terminated && outerDone && innerSubs.size === 0) terminate();\n                            }\n                        });\n                        innerSubs.add(innerSub);\n                        if (demand > 0) innerSub.request(demand);\n                    },\n                    onError(e) { terminate(e); },\n                    onComplete() {\n                        outerDone = true;\n                        if (!terminated && innerSubs.size === 0) terminate();\n                    }\n                });\n                outerSub.request(Number.MAX_SAFE_INTEGER);\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Maps each item to an inner publisher and subscribes to them **sequentially**,\n     * preserving order (**concat** semantics).\n     *\n     * The next inner publisher is subscribed to only after the previous one completes.\n     * This guarantees item ordering but has no concurrency.\n     *\n     * @param fn - Maps each item to a `Flux<R>`, `Mono<R>`, or any `Publisher<R>`.\n     * @returns An ordered, sequential `Flux<R>`.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3)\n     *   .concatMap(n => Mono.just(`item-${n}`))\n     *   .subscribe(v => console.log(v));\n     * // item-1  item-2  item-3\n     * ```\n     */\n    public concatMap<R>(fn: (value: T) => Flux<R>): Flux<R>;\n    public concatMap<R>(fn: (value: T) => Mono<R>): Flux<R>;\n    public concatMap<R>(fn: (value: T) => Publisher<R>): Flux<R>;\n    public concatMap<R>(fn: (value: T) => Publisher<R>): Flux<R> {\n        return new Flux<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                let outerSub!: Subscription;\n                let innerSub: Subscription | null = null;\n                let cancelled = false;\n                let terminated = false;\n                let outerDone = false;\n\n                const terminate = (err?: Error) => {\n                    if (terminated) return;\n                    terminated = true;\n                    outerSub?.unsubscribe();\n                    innerSub?.unsubscribe();\n                    innerSub = null;\n                    if (err) subscriber.onError(err);\n                    else subscriber.onComplete();\n                };\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { terminate(new Error(`request must be > 0, but was ${n}`)); return; }\n                        if (innerSub) innerSub.request(n);\n                        else outerSub.request(1);\n                    },\n                    unsubscribe() { cancelled = true; outerSub?.unsubscribe(); innerSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        outerSub = s;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (cancelled || terminated) return;\n                        let inner: Publisher<R>;\n                        try { inner = fn(v); }\n                        catch (e) { terminate(e instanceof Error ? e : new Error(String(e))); return; }\n                        inner.subscribe({\n                            onSubscribe(s) { innerSub = s; s.request(Number.MAX_SAFE_INTEGER); },\n                            onNext(r) { if (!cancelled && !terminated) subscriber.onNext(r); },\n                            onError(e) { terminate(e); },\n                            onComplete() {\n                                if (cancelled || terminated) return;\n                                innerSub = null;\n                                if (outerDone) terminate();\n                                else outerSub.request(1);\n                            }\n                        });\n                    },\n                    onError(e) { terminate(e); },\n                    onComplete() {\n                        outerDone = true;\n                        if (innerSub === null) terminate();\n                    }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Maps each item to an inner publisher, **cancelling** the previous inner subscription\n     * whenever a new outer item arrives (**switch** semantics).\n     *\n     * Only the most recently started inner publisher is active at any point. This is\n     * useful for patterns like \"search as you type\" where stale results should be\n     * discarded when a newer request supersedes them.\n     *\n     * @param fn - Maps each item to a `Flux<R>`, `Mono<R>`, or any `Publisher<R>`.\n     * @returns A `Flux<R>` that tracks only the latest inner publisher.\n     */\n    public switchMap<R>(fn: (value: T) => Flux<R>): Flux<R>;\n    public switchMap<R>(fn: (value: T) => Mono<R>): Flux<R>;\n    public switchMap<R>(fn: (value: T) => Publisher<R>): Flux<R>;\n    public switchMap<R>(fn: (value: T) => Publisher<R>): Flux<R> {\n        return new Flux<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                let outerSub!: Subscription;\n                let innerSub: Subscription | null = null;\n                let cancelled = false;\n                let terminated = false;\n                let outerDone = false;\n                let demand = 0;\n                let generation = 0;\n\n                const terminate = (err?: Error) => {\n                    if (terminated) return;\n                    terminated = true;\n                    outerSub?.unsubscribe();\n                    innerSub?.unsubscribe();\n                    innerSub = null;\n                    if (err) subscriber.onError(err);\n                    else subscriber.onComplete();\n                };\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { terminate(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (innerSub) innerSub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; outerSub?.unsubscribe(); innerSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        outerSub = s;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (cancelled || terminated) return;\n                        innerSub?.unsubscribe();\n                        innerSub = null;\n                        const myGen = ++generation;\n                        let inner: Publisher<R>;\n                        try { inner = fn(v); }\n                        catch (e) { terminate(e instanceof Error ? e : new Error(String(e))); return; }\n                        inner.subscribe({\n                            onSubscribe(s) {\n                                if (generation !== myGen || cancelled || terminated) { s.unsubscribe(); return; }\n                                innerSub = s;\n                                if (demand > 0) s.request(demand);\n                            },\n                            onNext(r) { if (generation === myGen && !cancelled && !terminated) subscriber.onNext(r); },\n                            onError(e) { if (generation === myGen) terminate(e); },\n                            onComplete() {\n                                if (generation !== myGen || cancelled || terminated) return;\n                                innerSub = null;\n                                if (outerDone) terminate();\n                            }\n                        });\n                    },\n                    onError(e) { terminate(e); },\n                    onComplete() {\n                        outerDone = true;\n                        if (innerSub === null) terminate();\n                    }\n                });\n                outerSub.request(Number.MAX_SAFE_INTEGER);\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Passes only items for which `predicate` returns `true`.\n     *\n     * Each dropped item replenishes upstream demand by 1 to keep the total\n     * outstanding demand accurate.\n     *\n     * @param predicate - Synchronous test applied to each item.\n     * @returns A filtered `Flux<T>`.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3, 4).filter(n => n % 2 === 0).subscribe(v => console.log(v));\n     * // 2  4\n     * ```\n     */\n    public filter(predicate: (value: T) => boolean): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let sourceSub!: Subscription;\n                const sub = this.source.subscribe({\n                    onSubscribe(s) { sourceSub = s; },\n                    onNext(v) {\n                        try {\n                            if (predicate(v)) subscriber.onNext(v);\n                            else sourceSub.request(1); // replenish: item skipped\n                        } catch (e) { subscriber.onError(e instanceof Error ? e : new Error(String(e))); }\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Asynchronous filter: for each item, subscribes to `predicate(item)` and forwards\n     * the item downstream only if the predicate publisher emits `true`.\n     *\n     * Implemented via {@link concatMap} — predicates run sequentially.\n     *\n     * @param predicate - Returns a `Publisher<boolean>` for each item.\n     * @returns A filtered `Flux<T>`.\n     */\n    public filterWhen(predicate: (value: T) => Publisher<boolean>): Flux<T> {\n        return this.concatMap(v =>\n            Flux.from(predicate(v))\n                .filter(pass => pass)\n                .map(() => v)\n        );\n    }\n\n    /**\n     * Unsafe type cast — changes the declared element type to `R` without any\n     * runtime conversion.  Use only when you are certain the actual runtime\n     * type is compatible.\n     *\n     * @typeParam R - The target element type.\n     * @returns This `Flux` re-typed as `Flux<R>`.\n     */\n    public cast<R>(): Flux<R> { return new Flux<R>(this.source as unknown as Publisher<R>); }\n\n    /**\n     * Emits at most `n` items, then cancels the upstream subscription and completes.\n     *\n     * If `n ≤ 0`, returns an empty `Flux` immediately.\n     *\n     * @param n - Maximum number of items to emit.\n     * @returns A bounded `Flux<T>`.\n     */\n    public take(n: number): Flux<T> {\n        if (n <= 0) return Flux.empty<T>();\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let sourceSub!: Subscription;\n                let count = 0;\n                let done = false;\n\n                const operatorSub: Subscription = {\n                    request(r: number) { if (!done) sourceSub?.request(r); },\n                    unsubscribe() { done = true; sourceSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        sourceSub = s;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (done) return;\n                        subscriber.onNext(v);\n                        if (++count >= n) {\n                            done = true;\n                            sourceSub.unsubscribe();\n                            subscriber.onComplete();\n                        }\n                    },\n                    onError(e: Error) { if (!done) subscriber.onError(e); },\n                    onComplete() { if (!done) subscriber.onComplete(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Emits items while `predicate(item)` returns `true`.\n     * Completes (and cancels upstream) on the first item for which it returns `false`.\n     *\n     * @param predicate - Tested synchronously for each item.\n     * @returns A `Flux<T>` that stops on the first `false`.\n     */\n    public takeWhile(predicate: (value: T) => boolean): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let sourceSub!: Subscription;\n                let done = false;\n\n                const operatorSub: Subscription = {\n                    request(n: number) { if (!done) sourceSub?.request(n); },\n                    unsubscribe() { done = true; sourceSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        sourceSub = s;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (done) return;\n                        try {\n                            if (predicate(v)) {\n                                subscriber.onNext(v);\n                            } else {\n                                done = true;\n                                sourceSub.unsubscribe();\n                                subscriber.onComplete();\n                            }\n                        } catch (e) {\n                            done = true;\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                        }\n                    },\n                    onError(e: Error) { if (!done) subscriber.onError(e); },\n                    onComplete() { if (!done) subscriber.onComplete(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Forwards items from this `Flux` until `trigger` emits its first item (or completes),\n     * then cancels the source and completes downstream.\n     *\n     * If `trigger` signals an error, that error is forwarded to the subscriber.\n     *\n     * @param trigger - A `Publisher` whose first emission ends this stream.\n     * @returns A `Flux<T>` that stops when the trigger fires.\n     */\n    public takeUntilOther(trigger: Publisher<unknown>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let sourceSub!: Subscription;\n                let triggerSub: Subscription;\n                let done = false;\n\n                const operatorSub: Subscription = {\n                    request(n: number) { if (!done) sourceSub?.request(n); },\n                    unsubscribe() { done = true; sourceSub?.unsubscribe(); triggerSub?.unsubscribe(); }\n                };\n\n                triggerSub = trigger.subscribe({\n                    onSubscribe(s) { triggerSub = s; s.request(1); },\n                    onNext(_v) {\n                        if (done) return;\n                        done = true;\n                        sourceSub?.unsubscribe();\n                        subscriber.onComplete();\n                    },\n                    onError(e) { if (!done) { done = true; subscriber.onError(e); } },\n                    onComplete() {}\n                });\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        sourceSub = s;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) { if (!done) subscriber.onNext(v); },\n                    onError(e: Error) { if (!done) subscriber.onError(e); },\n                    onComplete() { if (!done) { done = true; triggerSub?.unsubscribe(); subscriber.onComplete(); } }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /** Emit defaultValue if source completes without emitting any item. */\n    /**\n     * Emits `value` if the source completes without having emitted any items,\n     * then completes.  If the source does emit items, they pass through unchanged.\n     *\n     * @param value - Fallback item to emit when the source is empty.\n     * @returns A `Flux<T>` that is never empty.\n     */\n    public defaultIfEmpty(value: T): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let hasValue = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { hasValue = true; subscriber.onNext(v); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() {\n                        if (!hasValue) subscriber.onNext(value);\n                        subscriber.onComplete();\n                    }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Re-subscribes to the source on `onError`, up to `maxRetries` times.\n     *\n     * Accumulated downstream demand from previous attempts is preserved across retries.\n     * If the error persists after all retries are exhausted, it is forwarded to downstream.\n     *\n     * @param maxRetries - Maximum number of retry attempts (default: `Number.MAX_SAFE_INTEGER`).\n     * @returns A `Flux<T>` with automatic retry on error.\n     */\n    public retry(maxRetries: number = Number.MAX_SAFE_INTEGER): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let currentSub: Subscription = { request() {}, unsubscribe() {} };\n                let demand = 0;\n                let cancelled = false;\n                let retries = 0;\n                // Generation counter prevents stale onSubscribe callbacks (from earlier failed\n                // attempts) from overwriting currentSub after recursive attempt() calls return.\n                let generation = 0;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        currentSub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; currentSub.unsubscribe(); }\n                };\n\n                const attempt = () => {\n                    const myGen = ++generation;\n                    this.source.subscribe({\n                        onSubscribe(s: Subscription) {\n                            // Only accept if this is still the active attempt\n                            if (myGen !== generation) { s.unsubscribe(); return; }\n                            currentSub = s;\n                            if (demand > 0) s.request(demand);\n                        },\n                        onNext(v: T) { if (!cancelled && myGen === generation) subscriber.onNext(v); },\n                        onError(e: Error) {\n                            if (cancelled || myGen !== generation) return;\n                            if (retries < maxRetries) { retries++; attempt(); }\n                            else subscriber.onError(e);\n                        },\n                        onComplete() { if (!cancelled && myGen === generation) subscriber.onComplete(); }\n                    });\n                };\n\n                subscriber.onSubscribe(operatorSub);\n                attempt();\n\n                return operatorSub;\n            }\n        });\n    }\n\n    // ──────────────────── Scan / Zip ────────────────────────────────\n\n    /**\n     * Emits a running accumulation of the stream.\n     *\n     * The first item is emitted as-is and becomes the initial accumulator.\n     * Each subsequent item is combined with the running accumulator using `reducer`,\n     * and the result is emitted downstream.\n     *\n     * @param reducer - Combines the running accumulator with the next item.\n     * @returns A `Flux<T>` of intermediate accumulation results.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3, 4).scan((acc, n) => acc + n).subscribe(v => console.log(v));\n     * // 1  3  6  10\n     * ```\n     */\n    public scan(reducer: (acc: T, next: T) => T): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let acc: T | undefined;\n                let hasAcc = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        acc = hasAcc ? reducer(acc as T, v) : v;\n                        hasAcc = true;\n                        subscriber.onNext(acc);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Emits a running accumulation of the stream with an explicit seed value.\n     *\n     * `seedFactory` is called once per subscription to produce the initial accumulator.\n     * Each upstream item is folded into the accumulator and the intermediate result is\n     * emitted downstream.\n     *\n     * @param seedFactory - Called per subscription to produce the initial accumulator of type `A`.\n     * @param reducer - Combines the current accumulator with the next item.\n     * @returns A `Flux<A>` of intermediate accumulation results.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3).scanWith(() => 0, (acc, n) => acc + n).subscribe(v => console.log(v));\n     * // 1  3  6\n     * ```\n     */\n    public scanWith<A>(seedFactory: () => A, reducer: (acc: A, next: T) => A): Flux<A> {\n        return new Flux<A>({\n            subscribe: (subscriber: Subscriber<A>): Subscription => {\n                let acc = seedFactory();\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { acc = reducer(acc, v); subscriber.onNext(acc); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Pair-wise combines items from this `Flux` and `other` using `combiner`.\n     *\n     * Items are matched by position: the first item from each source is combined, then the second, etc.\n     * The stream completes when either source completes. If either source errors, the error is forwarded.\n     *\n     * @param other - The second publisher to zip with.\n     * @param combiner - Combines one item from each source into a result item.\n     * @returns A `Flux<V>` of combined pairs.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3)\n     *   .zipWith(Flux.just('a', 'b', 'c'), (n, s) => `${n}${s}`)\n     *   .subscribe(v => console.log(v));\n     * // 1a  2b  3c\n     * ```\n     */\n    public zipWith<R, V>(other: Publisher<R>, combiner: (a: T, b: R) => V): Flux<V> {\n        return new Flux<V>({\n            subscribe: (subscriber: Subscriber<V>): Subscription => {\n                const leftQueue: T[] = [];\n                const rightQueue: R[] = [];\n                let leftDone = false;\n                let rightDone = false;\n                let cancelled = false;\n                let terminated = false;\n\n                let leftSub: Subscription = { request() {}, unsubscribe() {} };\n                let rightSub: Subscription = { request() {}, unsubscribe() {} };\n\n                const terminate = (err?: Error) => {\n                    if (terminated) return;\n                    terminated = true;\n                    leftSub.unsubscribe();\n                    rightSub.unsubscribe();\n                    if (err) subscriber.onError(err);\n                    else subscriber.onComplete();\n                };\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { terminate(new Error(`request must be > 0, but was ${n}`)); return; }\n                        leftSub.request(n);\n                        rightSub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; leftSub.unsubscribe(); rightSub.unsubscribe(); }\n                };\n\n                const tryEmit = () => {\n                    while (leftQueue.length > 0 && rightQueue.length > 0) {\n                        if (cancelled || terminated) return;\n                        const l = leftQueue.shift()!;\n                        const r = rightQueue.shift()!;\n                        try { subscriber.onNext(combiner(l, r)); }\n                        catch (e) { terminate(e instanceof Error ? e : new Error(String(e))); return; }\n                    }\n                    if ((leftDone && leftQueue.length === 0) || (rightDone && rightQueue.length === 0)) {\n                        terminate();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        leftSub = s;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) { if (!cancelled && !terminated) { leftQueue.push(v); tryEmit(); } },\n                    onError(e: Error) { terminate(e); },\n                    onComplete() { if (!cancelled && !terminated) { leftDone = true; tryEmit(); } }\n                });\n\n                rightSub = other.subscribe({\n                    onSubscribe(s: Subscription) { rightSub = s; },\n                    onNext(v: R) { if (!cancelled && !terminated) { rightQueue.push(v); tryEmit(); } },\n                    onError(e: Error) { terminate(e); },\n                    onComplete() { if (!cancelled && !terminated) { rightDone = true; tryEmit(); } }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    // ──────────────────── Side effects ───────────────────────────────\n\n    /**\n     * Executes a side-effect function when the source completes normally.\n     *\n     * The function runs just before `onComplete` is forwarded to the downstream subscriber.\n     * Any exception thrown by `fn` is silently swallowed.\n     *\n     * @param fn - Side-effect to run on normal completion.\n     * @returns A `Flux<T>` with the side effect attached.\n     */\n    public doOnComplete(fn: () => void): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { try { fn(); } catch (_) {} subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Executes a side-effect function when the source terminates — either normally (`onComplete`)\n     * or with an error (`onError`).\n     *\n     * The function runs before the terminal signal is forwarded downstream.\n     * Any exception thrown by `fn` is silently swallowed.\n     *\n     * @param fn - Side-effect to run on any terminal signal.\n     * @returns A `Flux<T>` with the side effect attached.\n     */\n    public doOnTerminate(fn: () => void): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) { try { fn(); } catch (_) {} subscriber.onError(e); },\n                    onComplete() { try { fn(); } catch (_) {} subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Executes a side-effect function when the downstream subscriber cancels\n     * (calls `unsubscribe()`).\n     *\n     * Any exception thrown by `fn` is silently swallowed.\n     *\n     * @param fn - Side-effect to run on cancellation.\n     * @returns A `Flux<T>` with the side effect attached.\n     */\n    public doOnCancel(fn: () => void): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const inner = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                const sub: Subscription = {\n                    request(n) { inner.request(n); },\n                    unsubscribe() { try { fn(); } catch (_) {} inner.unsubscribe(); }\n                };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Executes a side-effect function after the stream ends for **any** reason —\n     * normal completion, error, or cancellation.\n     *\n     * Any exception thrown by `fn` is silently swallowed.\n     *\n     * @param fn - Side-effect to run after any terminal event or cancellation.\n     * @returns A `Flux<T>` with the side effect attached.\n     */\n    public doFinally(fn: () => void): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const inner = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) { try { fn(); } catch (_) {} subscriber.onError(e); },\n                    onComplete() { try { fn(); } catch (_) {} subscriber.onComplete(); }\n                });\n                const sub: Subscription = {\n                    request(n) { inner.request(n); },\n                    unsubscribe() { try { fn(); } catch (_) {} inner.unsubscribe(); }\n                };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    // ──────────────────── Scheduling ────────────────────────────────\n\n    /**\n     * Low-level escape hatch for bridging imperative push-based sources.\n     *\n     * The `producer` receives three callbacks and must call them to drive the stream.\n     * `onRequest` and `onUnsubscribe` let the caller respond to downstream demand and\n     * cancellation respectively.\n     *\n     * @param producer - Callback that receives `(onNext, onError, onComplete)` and drives the stream.\n     * @param onRequest - Called when the downstream subscriber requests `n` more items.\n     * @param onUnsubscribe - Called when the downstream subscriber cancels.\n     * @returns A `Flux<R>` backed by the imperative producer.\n     */\n    public pipe<R>(\n        producer: (onNext: (value: R) => void, onError: (error: Error) => void, onComplete: () => void) => void,\n        onRequest: (request: number) => void,\n        onUnsubscribe: () => void\n    ): Flux<R> {\n        return new Flux<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                producer(v => subscriber.onNext(v), e => subscriber.onError(e), () => subscriber.onComplete());\n                const sub = { request: onRequest, unsubscribe: onUnsubscribe };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    // ──────────────────── Flux-specific operators ────────────────────────\n\n    /**\n     * Returns the first item of this `Flux` as a `Mono`.\n     *\n     * If the source is empty, the resulting `Mono` completes without emitting a value.\n     * The source subscription is cancelled immediately after the first item is received.\n     *\n     * @returns A `Mono<T>` that emits the first item, or completes empty.\n     */\n    public first(): Mono<T> {\n        return Mono.generate<T>(sink => {\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) { sub.unsubscribe(); sink.next(v); },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.complete(); }\n            });\n            sub.request(1);\n        });\n    }\n\n    /**\n     * Returns the last item of this `Flux` as a `Mono`.\n     *\n     * The source is fully consumed before the value is emitted.\n     * If the source is empty, the resulting `Mono` completes without emitting a value.\n     *\n     * @returns A `Mono<T>` that emits the last item, or completes empty.\n     */\n    public last(): Mono<T> {\n        return Mono.generate<T>(sink => {\n            let last: T | undefined;\n            let hasValue = false;\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) { last = v; hasValue = true; },\n                onError(e) { sink.error(e); },\n                onComplete() {\n                    if (hasValue) sink.next(last as T);\n                    else sink.complete();\n                }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Counts all items emitted by this `Flux` and emits the total as a `Mono<number>`.\n     *\n     * The source is fully consumed before the count is emitted.\n     *\n     * @returns A `Mono<number>` emitting the number of items.\n     */\n    public count(): Mono<number> {\n        return Mono.generate<number>(sink => {\n            let n = 0;\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(_v) { n++; },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.next(n); }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Emits `true` if this `Flux` emits at least one item, `false` if it completes empty.\n     *\n     * The source subscription is cancelled as soon as the first item is observed.\n     *\n     * @returns A `Mono<boolean>`.\n     */\n    public hasElements(): Mono<boolean> {\n        return Mono.generate<boolean>(sink => {\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(_v) { sub.unsubscribe(); sink.next(true); },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.next(false); }\n            });\n            sub.request(1);\n        });\n    }\n\n    /**\n     * Emits `true` if any item matches `predicate`, `false` if none do.\n     *\n     * Short-circuits: cancels the source and emits `true` on the first matching item.\n     * If `predicate` throws, the error is forwarded to the subscriber.\n     *\n     * @param predicate - Test applied to each item.\n     * @returns A `Mono<boolean>`.\n     */\n    public any(predicate: (value: T) => boolean): Mono<boolean> {\n        return Mono.generate<boolean>(sink => {\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) {\n                    try {\n                        if (predicate(v)) { sub.unsubscribe(); sink.next(true); }\n                    } catch (e) { sink.error(e instanceof Error ? e : new Error(String(e))); }\n                },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.next(false); }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Emits `true` if every item matches `predicate`, `false` if any item does not.\n     *\n     * Short-circuits: cancels the source and emits `false` on the first non-matching item.\n     * If `predicate` throws, the error is forwarded to the subscriber.\n     *\n     * @param predicate - Test applied to each item.\n     * @returns A `Mono<boolean>`.\n     */\n    public all(predicate: (value: T) => boolean): Mono<boolean> {\n        return Mono.generate<boolean>(sink => {\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) {\n                    try {\n                        if (!predicate(v)) { sub.unsubscribe(); sink.next(false); }\n                    } catch (e) { sink.error(e instanceof Error ? e : new Error(String(e))); }\n                },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.next(true); }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Emits `true` if no item matches `predicate`, `false` if any item does.\n     *\n     * This is the logical negation of {@link any}.\n     *\n     * @param predicate - Test applied to each item.\n     * @returns A `Mono<boolean>`.\n     */\n    public none(predicate: (value: T) => boolean): Mono<boolean> {\n        return this.any(predicate).map(v => !v);\n    }\n\n    /**\n     * Returns the item at zero-based `index` as a `Mono<T>`.\n     *\n     * If the source completes before reaching `index`, emits `defaultValue` if provided,\n     * otherwise completes empty.\n     *\n     * @param index - Zero-based position of the desired item.\n     * @param defaultValue - Optional fallback value emitted if the index is out of range.\n     * @returns A `Mono<T>`.\n     */\n    public elementAt(index: number, defaultValue?: T): Mono<T> {\n        return Mono.generate<T>(sink => {\n            let i = 0;\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) {\n                    if (i++ === index) { sub.unsubscribe(); sink.next(v); }\n                },\n                onError(e) { sink.error(e); },\n                onComplete() {\n                    if (defaultValue !== undefined) sink.next(defaultValue);\n                    else sink.complete();\n                }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Collects all items into an array and emits the complete array as a `Mono<T[]>`.\n     *\n     * The source is fully consumed before the array is emitted.\n     *\n     * @returns A `Mono<T[]>` containing all emitted items.\n     */\n    public collect(_force: boolean = false): Mono<T[]> {\n        return Mono.generate<T[]>(sink => {\n            const items: T[] = [];\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) { items.push(v); },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.next(items); }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Alias for {@link collect}.\n     *\n     * @returns A `Mono<T[]>` containing all emitted items.\n     */\n    public collectList(): Mono<T[]> {\n        return this.collect();\n    }\n\n    /**\n     * Collects all items, sorts them, and re-emits them as a `Flux<T>`.\n     *\n     * Uses the native `Array.sort` algorithm. When no `comparator` is provided the\n     * default lexicographic sort order is used.\n     *\n     * @param comparator - Optional comparison function (same signature as `Array.sort`).\n     * @returns A `Flux<T>` that emits items in sorted order after the source completes.\n     */\n    public sort(comparator?: (a: T, b: T) => number): Flux<T> {\n        return Flux.defer(() =>\n            Flux.from(this.collect().map(arr => {\n                arr.sort(comparator);\n                return arr;\n            }).flatMapMany(arr => Flux.fromIterable(arr)))\n        );\n    }\n\n    /**\n     * Collects items into fixed-size arrays and emits each batch as a `T[]`.\n     *\n     * A batch is emitted as soon as it reaches `maxSize` items.\n     * The final (potentially partial) batch is emitted when the source completes.\n     *\n     * @param maxSize - Maximum number of items per batch.\n     * @returns A `Flux<T[]>` of item batches.\n     *\n     * @example\n     * ```typescript\n     * Flux.range(1, 5).buffer(2).subscribe(v => console.log(v));\n     * // [1, 2]  [3, 4]  [5]\n     * ```\n     */\n    public buffer(maxSize: number): Flux<T[]> {\n        return new Flux<T[]>({\n            subscribe: (subscriber: Subscriber<T[]>): Subscription => {\n                let batch: T[] = [];\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        batch.push(v);\n                        if (batch.length >= maxSize) {\n                            subscriber.onNext(batch);\n                            batch = [];\n                        }\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() {\n                        if (batch.length > 0) subscriber.onNext(batch);\n                        subscriber.onComplete();\n                    }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Caches all emitted items and replays them to each new subscriber.\n     *\n     * The source is subscribed to on the **first** downstream subscription (lazy connect).\n     * Subsequent subscribers receive a replay of all previously emitted items from the cache.\n     *\n     * @returns A cached, replayable `Flux<T>`.\n     */\n    public cache(): Flux<T> {\n        const sink = new ReplayAllSink<T>();\n        let connected = false;\n\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                if (!connected) {\n                    connected = true;\n                    this.source.subscribe({\n                        onSubscribe(s) { s.request(Number.MAX_SAFE_INTEGER); },\n                        onNext(v) { sink.next(v); },\n                        onError(e) { sink.error(e); },\n                        onComplete() { sink.complete(); }\n                    });\n                }\n                return sink.subscribe(subscriber);\n            }\n        });\n    }\n\n    /**\n     * Multicasts this `Flux` to all current subscribers using a refCounting strategy.\n     *\n     * The upstream is subscribed to when the **first** subscriber joins and cancelled\n     * when the **last** subscriber leaves. If a new subscriber arrives after all others\n     * have cancelled, a fresh upstream subscription is created.\n     *\n     * Items are delivered on a best-effort basis: a subscriber that has no outstanding\n     * demand when an item arrives simply misses that item (no buffering). Once the upstream\n     * terminates (complete or error), the terminal signal is replayed to any future subscriber.\n     *\n     * @returns A hot `Flux<T>` that shares a single upstream subscription.\n     *\n     * @example\n     * ```typescript\n     * const shared = Flux.interval(100).share();\n     * shared.subscribe(v => console.log('A', v));\n     * setTimeout(() => shared.subscribe(v => console.log('B', v)), 250);\n     * // A 0, A 1, A 2, B 2, A 3, B 3 ...\n     * ```\n     */\n    public share(): Flux<T> {\n        type Entry = { demand: number; cancelled: boolean };\n        const entries = new Map<Subscriber<T>, Entry>();\n        let upstreamSub: Subscription | null = null;\n        let terminated = false;\n        let terminalError: Error | null = null;\n\n        const source = this.source;\n\n        const connect = () => {\n            terminated = false;\n            terminalError = null;\n            source.subscribe({\n                onSubscribe(s) {\n                    upstreamSub = s;\n                    s.request(Number.MAX_SAFE_INTEGER);\n                },\n                onNext(v: T) {\n                    for (const [sub, entry] of entries) {\n                        if (!entry.cancelled && entry.demand > 0) {\n                            entry.demand--;\n                            sub.onNext(v);\n                        }\n                    }\n                },\n                onError(e: Error) {\n                    terminated = true;\n                    terminalError = e;\n                    upstreamSub = null;\n                    for (const [sub, entry] of entries) {\n                        if (!entry.cancelled) sub.onError(e);\n                    }\n                    entries.clear();\n                },\n                onComplete() {\n                    terminated = true;\n                    upstreamSub = null;\n                    for (const [sub, entry] of entries) {\n                        if (!entry.cancelled) sub.onComplete();\n                    }\n                    entries.clear();\n                }\n            });\n        };\n\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                if (terminated) {\n                    const sub = { request() {}, unsubscribe() {} };\n                    subscriber.onSubscribe(sub);\n                    terminalError ? subscriber.onError(terminalError) : subscriber.onComplete();\n                    return sub;\n                }\n\n                const entry: Entry = { demand: 0, cancelled: false };\n                entries.set(subscriber, entry);\n\n                const sub: Subscription = {\n                    request(n: number) {\n                        if (entry.cancelled) return;\n                        if (n <= 0) {\n                            entry.cancelled = true;\n                            entries.delete(subscriber);\n                            subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                            return;\n                        }\n                        entry.demand = Math.min(entry.demand + n, Number.MAX_SAFE_INTEGER);\n                        if (!upstreamSub && !terminated) {\n                            connect();\n                        }\n                    },\n                    unsubscribe() {\n                        if (entry.cancelled) return;\n                        entry.cancelled = true;\n                        entries.delete(subscriber);\n                        if (entries.size === 0 && upstreamSub) {\n                            upstreamSub.unsubscribe();\n                            upstreamSub = null;\n                        }\n                    }\n                };\n\n                subscriber.onSubscribe(sub);\n\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Pairs each item with its zero-based index, emitting `[index, item]` tuples.\n     *\n     * @returns A `Flux<[number, T]>` where the first element is the zero-based index.\n     *\n     * @example\n     * ```typescript\n     * Flux.just('a', 'b', 'c').indexed().subscribe(([i, v]) => console.log(i, v));\n     * // 0 a  1 b  2 c\n     * ```\n     */\n    public indexed(): Flux<[number, T]> {\n        return new Flux<[number, T]>({\n            subscribe: (subscriber: Subscriber<[number, T]>): Subscription => {\n                let index = 0;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext([index++, v]); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Skips the first `n` items from the source, then forwards the rest.\n     *\n     * Skipped items replenish upstream demand so the overall demand accounting stays correct.\n     *\n     * @param n - Number of leading items to skip.\n     * @returns A `Flux<T>` without the first `n` items.\n     */\n    public skip(n: number): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let skipped = 0;\n                let sourceSub!: Subscription;\n                const sub = this.source.subscribe({\n                    onSubscribe(s) { sourceSub = s; },\n                    onNext(v) {\n                        if (skipped++ < n) sourceSub.request(1); // replenish: item skipped\n                        else subscriber.onNext(v);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Skips items while `predicate` returns `true`, then forwards all subsequent items\n     * regardless of the predicate.\n     *\n     * Skipped items replenish upstream demand. Once the predicate returns `false`, it is\n     * never evaluated again.\n     *\n     * @param predicate - Tested against each item until it returns `false`.\n     * @returns A `Flux<T>` that starts forwarding items after the first predicate failure.\n     */\n    public skipWhile(predicate: (value: T) => boolean): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let skipping = true;\n                let sourceSub!: Subscription;\n                const sub = this.source.subscribe({\n                    onSubscribe(s) { sourceSub = s; },\n                    onNext(v) {\n                        if (skipping && predicate(v)) { sourceSub.request(1); return; }\n                        skipping = false;\n                        subscriber.onNext(v);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Gates items from this `Flux` until `other` emits its first item.\n     *\n     * Items arriving before the gate opens are silently dropped (demand is replenished).\n     * If `other` signals an error, the error is forwarded to downstream.\n     *\n     * @param other - A `Publisher` whose first emission opens the gate.\n     * @returns A `Flux<T>` that starts forwarding items once `other` emits.\n     */\n    public skipUntil(other: Publisher<unknown>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let gating = true;\n                let primarySub: Subscription;\n                const triggerSub = other.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(_v) { gating = false; triggerSub.unsubscribe(); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() {}\n                });\n                triggerSub.request(1);\n                primarySub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { if (!gating) subscriber.onNext(v); else primarySub.request(1); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe({\n                    request(n) { primarySub.request(n); },\n                    unsubscribe() { primarySub.unsubscribe(); triggerSub.unsubscribe(); }\n                });\n                return { request(n) { primarySub.request(n); }, unsubscribe() { primarySub.unsubscribe(); triggerSub.unsubscribe(); } };\n            }\n        });\n    }\n\n    /**\n     * Filters out duplicate items, forwarding only items not seen before.\n     *\n     * Uses a `Set` with reference equality (`===`) to track seen values.\n     * Duplicates replenish upstream demand.\n     *\n     * @returns A `Flux<T>` with all duplicate items removed.\n     */\n    public distinct(): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const seen = new Set<T>();\n                let sourceSub!: Subscription;\n                const sub = this.source.subscribe({\n                    onSubscribe(s) { sourceSub = s; },\n                    onNext(v) { if (!seen.has(v)) { seen.add(v); subscriber.onNext(v); } else sourceSub.request(1); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Suppresses consecutive duplicate items.\n     *\n     * An item is forwarded only when it is different from the immediately preceding item\n     * as determined by `comparator`. The default comparator uses `!==`.\n     * Suppressed items replenish upstream demand.\n     *\n     * @param comparator - Returns `true` when two consecutive items are considered different\n     *                     (default: `(a, b) => a !== b`).\n     * @returns A `Flux<T>` without consecutive duplicates.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 1, 2, 2, 3).distinctUntilChanged().subscribe(v => console.log(v));\n     * // 1  2  3\n     * ```\n     */\n    public distinctUntilChanged(comparator: (a: T, b: T) => boolean = (a, b) => a !== b): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let prev: T | undefined;\n                let first = true;\n                let sourceSub!: Subscription;\n                const sub = this.source.subscribe({\n                    onSubscribe(s) { sourceSub = s; },\n                    onNext(v) {\n                        if (first || comparator(prev as T, v)) {\n                            first = false;\n                            prev = v;\n                            subscriber.onNext(v);\n                        } else sourceSub.request(1);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Delays the delivery of each item by `ms` milliseconds.\n     *\n     * Items are processed **one at a time**: the next item is requested from the source\n     * only after the previous delayed item has been delivered downstream.  This guarantees\n     * items are spaced at least `ms` apart and that `onComplete` fires only after the last\n     * delayed item has been delivered.\n     *\n     * Errors are forwarded immediately without delay, cancelling any pending timer.\n     *\n     * @param ms - Delay in milliseconds between consecutive item deliveries.\n     * @returns A `Flux<T>` where each item is delayed by `ms` before being forwarded.\n     */\n    public delayElements(ms: number): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let sourceSub: Subscription = { request() {}, unsubscribe() {} };\n                let pending: { cancel(): void } | null = null;\n                let cancelled = false;\n                let demand = 0;\n                let sourceCompleted = false;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        const wasZero = demand === 0;\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        // Only pull from source if no item is currently in-flight (timer pending).\n                        if (wasZero && pending === null) sourceSub.request(1);\n                    },\n                    unsubscribe() {\n                        cancelled = true;\n                        pending?.cancel();\n                        pending = null;\n                        sourceSub.unsubscribe();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        sourceSub = s;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        pending = Schedulers.delay(ms).schedule(() => {\n                            pending = null;\n                            if (cancelled) return;\n                            demand--;\n                            subscriber.onNext(v);\n                            if (cancelled) return;\n                            if (sourceCompleted) {\n                                subscriber.onComplete();\n                            } else if (demand > 0) {\n                                sourceSub.request(1);\n                            }\n                        });\n                    },\n                    onError(e: Error) {\n                        pending?.cancel();\n                        pending = null;\n                        subscriber.onError(e);\n                    },\n                    onComplete() {\n                        sourceCompleted = true;\n                        // If no item is in-flight, complete immediately.\n                        // Otherwise the pending timer will deliver the last item and then complete.\n                        if (pending === null && !cancelled) subscriber.onComplete();\n                    }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Appends `other` to this `Flux`, subscribing to `other` only after this source completes.\n     *\n     * Items from this source are emitted first, in order.  Once this source completes,\n     * items from `other` are emitted.  If either source errors, the error is forwarded\n     * and `other` is not subscribed to.\n     *\n     * @param other - The publisher to concatenate after this source.\n     * @returns A `Flux<T>` that emits items from both sources sequentially.\n     */\n    public concatWith(other: Publisher<T>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let primarySub: Subscription = { request() {}, unsubscribe() {} };\n                let otherSub: Subscription | null = null;\n                let cancelled = false;\n                let demand = 0;\n\n                const operatorSub: Subscription = {\n                    request(n) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (otherSub) otherSub.request(n); else primarySub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; primarySub.unsubscribe(); otherSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(sourceSub: Subscription) {\n                        primarySub = sourceSub;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() {\n                        if (cancelled) return;\n                        otherSub = other.subscribe({\n                            onSubscribe(otherSourceSub: Subscription) {\n                                otherSub = otherSourceSub;\n                                if (demand > 0) otherSub.request(demand);\n                            },\n                            onNext(v) { subscriber.onNext(v); },\n                            onError(e) { subscriber.onError(e); },\n                            onComplete() { subscriber.onComplete(); }\n                        });\n                    }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Merges this `Flux` with `other`, subscribing to both concurrently.\n     *\n     * Items from both sources are interleaved as they arrive. The resulting stream\n     * completes when **both** sources complete. Any error from either source terminates\n     * the merged stream immediately.\n     *\n     * @param other - The publisher to merge with this source.\n     * @returns A `Flux<T>` that emits items from both sources concurrently.\n     */\n    public mergeWith(other: Publisher<T>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let doneCount = 0;\n                let cancelled = false;\n                let terminated = false;\n\n                let primarySub: Subscription = { request() {}, unsubscribe() {} };\n                let otherSubRef: Subscription = { request() {}, unsubscribe() {} };\n\n                const terminate = (err?: Error) => {\n                    if (terminated) return;\n                    terminated = true;\n                    primarySub.unsubscribe();\n                    otherSubRef.unsubscribe();\n                    if (err) subscriber.onError(err);\n                    else subscriber.onComplete();\n                };\n\n                const done = () => { if (!terminated && ++doneCount === 2) terminate(); };\n\n                const operatorSub: Subscription = {\n                    request(n) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { terminate(new Error(`request must be > 0, but was ${n}`)); return; }\n                        primarySub.request(n);\n                        otherSubRef.request(n);\n                    },\n                    unsubscribe() { cancelled = true; primarySub.unsubscribe(); otherSubRef.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(sourceSub: Subscription) {\n                        primarySub = sourceSub;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v) { if (!cancelled && !terminated) subscriber.onNext(v); },\n                    onError(e) { terminate(e); },\n                    onComplete() { done(); }\n                });\n\n                otherSubRef = other.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { if (!cancelled && !terminated) subscriber.onNext(v); },\n                    onError(e) { terminate(e); },\n                    onComplete() { done(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Reduces the stream to a single value using `reducer`, emitting the final result as a `Mono<T>`.\n     *\n     * The first item becomes the initial accumulator. If the source is empty, the resulting\n     * `Mono` completes without emitting a value.\n     *\n     * @param reducer - Combines the running accumulator with the next item.\n     * @returns A `Mono<T>` emitting the final reduced value.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3, 4).reduce((acc, n) => acc + n).subscribe(v => console.log(v));\n     * // 10\n     * ```\n     */\n    public reduce(reducer: (acc: T, next: T) => T): Mono<T> {\n        return Mono.generate<T>(sink => {\n            let acc: T | undefined;\n            let hasValue = false;\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) { acc = hasValue ? reducer(acc as T, v) : v; hasValue = true; },\n                onError(e) { sink.error(e); },\n                onComplete() {\n                    if (hasValue) sink.next(acc as T);\n                    else sink.complete();\n                }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Reduces the stream to a single value of type `A`, using an explicit seed, and emits it as `Mono<A>`.\n     *\n     * `seedFactory` is called once per subscription to produce the initial accumulator.\n     * Unlike {@link reduce}, this always emits a value even if the source is empty (the seed).\n     *\n     * @param seedFactory - Produces the initial accumulator value per subscription.\n     * @param reducer - Combines the running accumulator with the next item.\n     * @returns A `Mono<A>` emitting the final reduced value.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3)\n     *   .reduceWith(() => '', (acc, n) => acc + n)\n     *   .subscribe(v => console.log(v)); // '123'\n     * ```\n     */\n    public reduceWith<A>(seedFactory: () => A, reducer: (acc: A, next: T) => A): Mono<A> {\n        return Mono.generate<A>(sink => {\n            let acc = seedFactory();\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) { acc = reducer(acc, v); },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.next(acc); }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Ignores all items from this `Flux` and emits a single `void` value on completion.\n     *\n     * Useful when you care only about the completion signal, not about the emitted items.\n     * If the source errors, the error is forwarded.\n     *\n     * @returns A `Mono<void>` that signals when this `Flux` completes.\n     */\n    public then(): Mono<void> {\n        return Mono.generate<void>(sink => {\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(_v) {},\n                onError(e) { sink.error(e); },\n                onComplete() { sink.next(undefined); }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Ignores all items from this `Flux`, then subscribes to `other` after this source completes,\n     * draining `other` completely and returning a `Mono<void>`.\n     *\n     * If this source or `other` errors, the error is forwarded.\n     *\n     * @param other - A `Publisher` to subscribe to after this source completes.\n     * @returns A `Mono<void>` that completes once `other` completes.\n     */\n    public thenEmpty(other: Publisher<unknown>): Mono<void> {\n        return this.then().flatMap(() => Mono.from<void>({\n            subscribe(subscriber: Subscriber<void>): Subscription {\n                const sub = other.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(_v) {},\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onNext(undefined); subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        }));\n    }\n\n    // ──────────────────── Advanced / Flux-specific operators ─────────────────\n\n    /**\n     * Re-subscribes to the source when the publisher returned by `fn` emits,\n     * enabling controlled retry with strategies like exponential back-off.\n     *\n     * `fn` receives a `Flux<Error>` — the stream of errors emitted by each failed attempt.\n     * Each emission from the returned publisher triggers a retry.\n     * When the returned publisher completes or errors, the retry loop stops.\n     *\n     * @param fn - Receives an error stream and returns a control publisher.\n     * @returns A `Flux<T>` with dynamic retry behaviour.\n     *\n     * @example\n     * ```typescript\n     * // Exponential back-off: wait 2^n × 100ms between retries, max 3 retries\n     * flux.retryWhen(errors =>\n     *   errors.zipWith(Flux.range(1, 3), (_, n) => n)\n     *         .flatMap(n => Mono.delay(n * 100))\n     * );\n     * ```\n     */\n    public retryWhen(fn: (errors: Flux<Error>) => Publisher<unknown>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const errBuf: Error[] = [];\n                let errSub: Subscriber<Error> | null = null;\n                let errDemand = 0;\n\n                const pushErr = (e: Error) => {\n                    errBuf.push(e);\n                    drainErrs();\n                };\n                const drainErrs = () => {\n                    while (errDemand > 0 && errBuf.length > 0 && errSub) {\n                        errDemand--;\n                        errSub.onNext(errBuf.shift()!);\n                    }\n                };\n\n                const errorFlux = new Flux<Error>({\n                    subscribe(sub: Subscriber<Error>): Subscription {\n                        errSub = sub;\n                        const relay: Subscription = {\n                            request(n) { errDemand = Math.min(errDemand + n, Number.MAX_SAFE_INTEGER); drainErrs(); },\n                            unsubscribe() { errSub = null; }\n                        };\n                        sub.onSubscribe(relay);\n                        return relay;\n                    }\n                });\n\n                let currentSub: Subscription = { request() {}, unsubscribe() {} };\n                let demand = 0;\n                let cancelled = false;\n                let terminated = false;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        currentSub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; currentSub.unsubscribe(); }\n                };\n\n                const attempt = () => {\n                    this.source.subscribe({\n                        onSubscribe(s: Subscription) { currentSub = s; if (demand > 0) s.request(demand); },\n                        onNext(v: T) { if (!cancelled && !terminated) subscriber.onNext(v); },\n                        onError(e: Error) { if (!cancelled && !terminated) pushErr(e); },\n                        onComplete() {\n                            if (!cancelled && !terminated) {\n                                terminated = true;\n                                errSub?.onComplete();\n                                subscriber.onComplete();\n                            }\n                        }\n                    });\n                };\n\n                fn(errorFlux).subscribe({\n                    onSubscribe(s) { s.request(Number.MAX_SAFE_INTEGER); },\n                    onNext(_v) { if (!cancelled && !terminated) { currentSub.unsubscribe(); attempt(); } },\n                    onError(e: Error) { if (!cancelled && !terminated) { terminated = true; subscriber.onError(e); } },\n                    onComplete() { if (!cancelled && !terminated) { terminated = true; subscriber.onComplete(); } }\n                });\n\n                subscriber.onSubscribe(operatorSub);\n                attempt();\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Re-subscribes to the source each time it completes normally, as controlled by\n     * the publisher returned by `fn` (**polling** semantics).\n     *\n     * `fn` receives a `Flux<void>` — one emission per completion. Each emission triggers\n     * a repeat. When the control publisher completes or errors, the loop stops.\n     *\n     * @param fn - Receives a completion-signal stream and returns a control publisher.\n     * @returns A `Flux<T>` that repeats under the control of `fn`.\n     *\n     * @example\n     * ```typescript\n     * // Poll every second, stop after 5 times\n     * fetchLatest()\n     *   .toFlux()\n     *   .repeatWhen(completes => completes.zipWith(Flux.range(1, 5), (_, n) => n)\n     *                                     .flatMap(() => Mono.delay(1000)));\n     * ```\n     */\n    public repeatWhen(fn: (completes: Flux<void>) => Publisher<unknown>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const compBuf: void[] = [];\n                let compSub: Subscriber<void> | null = null;\n                let compDemand = 0;\n                let drainingComps = false;\n\n                const drainComps = () => {\n                    if (drainingComps) return;\n                    drainingComps = true;\n                    try {\n                        while (!terminated && !cancelled && compDemand > 0 && compBuf.length > 0 && compSub) {\n                            compDemand--;\n                            compSub.onNext(compBuf.shift()!);\n                        }\n                    } finally { drainingComps = false; }\n                };\n\n                const pushComp = () => {\n                    compBuf.push(undefined);\n                    drainComps();\n                };\n\n                const completeFlux = new Flux<void>({\n                    subscribe(sub: Subscriber<void>): Subscription {\n                        compSub = sub;\n                        const relay: Subscription = {\n                            request(n) { compDemand = Math.min(compDemand + n, Number.MAX_SAFE_INTEGER); drainComps(); },\n                            unsubscribe() { compSub = null; }\n                        };\n                        sub.onSubscribe(relay);\n                        return relay;\n                    }\n                });\n\n                let currentSub: Subscription = { request() {}, unsubscribe() {} };\n                let demand = 0;\n                let cancelled = false;\n                let terminated = false;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        currentSub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; currentSub.unsubscribe(); }\n                };\n\n                const attempt = () => {\n                    this.source.subscribe({\n                        onSubscribe(s: Subscription) { currentSub = s; if (demand > 0) s.request(demand); },\n                        onNext(v: T) { if (!cancelled && !terminated) subscriber.onNext(v); },\n                        onError(e: Error) { if (!cancelled && !terminated) { terminated = true; subscriber.onError(e); } },\n                        onComplete() { if (!cancelled && !terminated) pushComp(); }\n                    });\n                };\n\n                fn(completeFlux).subscribe({\n                    onSubscribe(s) { s.request(Number.MAX_SAFE_INTEGER); },\n                    onNext(_v) { if (!cancelled && !terminated) { currentSub.unsubscribe(); attempt(); } },\n                    onError(e: Error) { if (!cancelled && !terminated) { terminated = true; subscriber.onError(e); } },\n                    onComplete() { if (!cancelled && !terminated) { terminated = true; subscriber.onComplete(); } }\n                });\n\n                subscriber.onSubscribe(operatorSub);\n                attempt();\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Groups items by a key derived from `keyFn`, emitting a {@link GroupedFlux} per\n     * unique key. Each `GroupedFlux` is itself a `Flux<T>` exposing the group `key`.\n     *\n     * The source is consumed at full speed. Items are routed to the corresponding group's\n     * buffer and replayed to any subscriber of that group.\n     *\n     * @param keyFn - Extracts the group key from each item.\n     * @returns A `Flux<GroupedFlux<K, T>>` emitting one group per unique key.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3, 4, 5)\n     *   .groupBy(n => n % 2 === 0 ? 'even' : 'odd')\n     *   .flatMap(group => group.collectList().map(items => ({ key: group.key, items })))\n     *   .subscribe(v => console.log(v));\n     * // { key: 'odd', items: [1, 3, 5] }\n     * // { key: 'even', items: [2, 4] }\n     * ```\n     */\n    public groupBy<K>(keyFn: (value: T) => K): Flux<GroupedFlux<K, T>> {\n        return new Flux<GroupedFlux<K, T>>({\n            subscribe: (subscriber: Subscriber<GroupedFlux<K, T>>): Subscription => {\n                const groups = new Map<K, ReplayAllSink<T>>();\n                let cancelled = false;\n                let sourceSub: Subscription = { request() {}, unsubscribe() {} };\n\n                const operatorSub: Subscription = {\n                    request(_n: number) { /* source runs at full speed */ },\n                    unsubscribe() { cancelled = true; sourceSub.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        sourceSub = s;\n                        s.request(Number.MAX_SAFE_INTEGER);\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        let key: K;\n                        try { key = keyFn(v); }\n                        catch (e) { subscriber.onError(e instanceof Error ? e : new Error(String(e))); return; }\n                        let sink = groups.get(key);\n                        if (!sink) {\n                            sink = new ReplayAllSink<T>();\n                            groups.set(key, sink);\n                            subscriber.onNext(Object.assign(Flux.from<T>(sink), { key }) as GroupedFlux<K, T>);\n                        }\n                        sink.next(v);\n                    },\n                    onError(e: Error) {\n                        if (cancelled) return;\n                        for (const g of groups.values()) g.error(e);\n                        subscriber.onError(e);\n                    },\n                    onComplete() {\n                        if (cancelled) return;\n                        for (const g of groups.values()) g.complete();\n                        subscriber.onComplete();\n                    }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Buffers items into arrays emitted when either `maxSize` items accumulate\n     * **or** `ms` milliseconds elapse since the last flush — whichever comes first.\n     *\n     * @param maxSize - Maximum items per batch.\n     * @param ms - Maximum time (ms) to wait before flushing a partial batch.\n     * @returns A `Flux<T[]>` of batches.\n     *\n     * @example\n     * ```typescript\n     * // Batch up to 10 items or flush every 500ms\n     * eventStream.bufferTimeout(10, 500).subscribe(batch => sendBatch(batch));\n     * ```\n     */\n    public bufferTimeout(maxSize: number, ms: number): Flux<T[]> {\n        return new Flux<T[]>({\n            subscribe: (subscriber: Subscriber<T[]>): Subscription => {\n                let batch: T[] = [];\n                let timer: ReturnType<typeof setTimeout> | null = null;\n                let cancelled = false;\n\n                const flush = () => {\n                    if (timer !== null) { clearTimeout(timer); timer = null; }\n                    if (batch.length > 0 && !cancelled) {\n                        const toEmit = batch;\n                        batch = [];\n                        subscriber.onNext(toEmit);\n                    }\n                };\n\n                const resetTimer = () => {\n                    if (timer !== null) clearTimeout(timer);\n                    timer = setTimeout(() => { if (!cancelled) flush(); }, ms);\n                };\n\n                const sourceSub = this.source.subscribe({\n                    onSubscribe(s: Subscription) { s.request(Number.MAX_SAFE_INTEGER); },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        batch.push(v);\n                        if (batch.length >= maxSize) flush();\n                        else resetTimer();\n                    },\n                    onError(e: Error) {\n                        if (!cancelled) { if (timer !== null) clearTimeout(timer); subscriber.onError(e); }\n                    },\n                    onComplete() {\n                        if (!cancelled) {\n                            if (timer !== null) { clearTimeout(timer); timer = null; }\n                            if (batch.length > 0) subscriber.onNext(batch);\n                            subscriber.onComplete();\n                        }\n                    }\n                });\n\n                const sub: Subscription = {\n                    request(n: number) { sourceSub.request(n); },\n                    unsubscribe() { cancelled = true; if (timer !== null) clearTimeout(timer); sourceSub.unsubscribe(); }\n                };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Samples this `Flux`, emitting the **most recent** item whenever `trigger` emits.\n     *\n     * If no item has arrived since the last sample, the trigger emission is ignored.\n     * Useful for rate-limiting with external signals (scroll, resize, `requestAnimationFrame`).\n     *\n     * @param trigger - Controls when to sample; its value is ignored.\n     * @returns A `Flux<T>` emitting the latest value at each trigger tick.\n     */\n    public sample(trigger: Publisher<unknown>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let latest: T | undefined;\n                let hasValue = false;\n                let cancelled = false;\n                let sourceSub: Subscription = { request() {}, unsubscribe() {} };\n                let triggerSub: Subscription = { request() {}, unsubscribe() {} };\n\n                const operatorSub: Subscription = {\n                    request(n: number) { if (!cancelled) sourceSub.request(n); },\n                    unsubscribe() { cancelled = true; sourceSub.unsubscribe(); triggerSub.unsubscribe(); }\n                };\n\n                triggerSub = trigger.subscribe({\n                    onSubscribe(s: Subscription) { triggerSub = s; s.request(Number.MAX_SAFE_INTEGER); },\n                    onNext(_v) {\n                        if (cancelled || !hasValue) return;\n                        const val = latest!;\n                        hasValue = false;\n                        latest = undefined;\n                        subscriber.onNext(val);\n                    },\n                    onError(e: Error) { if (!cancelled) subscriber.onError(e); },\n                    onComplete() {}\n                });\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) { sourceSub = s; subscriber.onSubscribe(operatorSub); },\n                    onNext(v: T) { if (!cancelled) { latest = v; hasValue = true; } },\n                    onError(e: Error) { if (!cancelled) subscriber.onError(e); },\n                    onComplete() { if (!cancelled) subscriber.onComplete(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * For each item, subscribes to `triggerFn(item)` and waits for it to emit or complete\n     * before forwarding the item downstream (**delayUntil** semantics).\n     *\n     * Triggers are executed sequentially (concatMap semantics). The trigger's value\n     * is ignored — only its timing matters.\n     *\n     * @param triggerFn - Returns a publisher whose first signal releases the item.\n     * @returns A `Flux<T>` where each item is held until its trigger fires.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3)\n     *   .delayUntil(() => Mono.delay(100))\n     *   .subscribe(v => console.log(v)); // each item delayed 100ms\n     * ```\n     */\n    public delayUntil(triggerFn: (value: T) => Publisher<unknown>): Flux<T> {\n        return this.concatMap(v =>\n            Flux.from<T>({\n                subscribe(subscriber: Subscriber<T>): Subscription {\n                    let done = false;\n                    let innerSub: Subscription = { request() {}, unsubscribe() {} };\n                    innerSub = triggerFn(v).subscribe({\n                        onSubscribe(s: Subscription) { innerSub = s; s.request(Number.MAX_SAFE_INTEGER); },\n                        onNext(_r) {\n                            if (!done) {\n                                done = true;\n                                innerSub.unsubscribe();\n                                subscriber.onNext(v);\n                                subscriber.onComplete();\n                            }\n                        },\n                        onError(e: Error) { if (!done) { done = true; subscriber.onError(e); } },\n                        onComplete() {\n                            if (!done) { done = true; subscriber.onNext(v); subscriber.onComplete(); }\n                        }\n                    });\n                    subscriber.onSubscribe(innerSub);\n                    return innerSub;\n                }\n            })\n        );\n    }\n\n    /**\n     * Recursively expands each item using `fn`, emitting both the original items and\n     * all items produced by the expansion (**breadth-first** order).\n     *\n     * Useful for **pagination**: call `fn` with the current page to fetch the next,\n     * until `fn` returns empty.\n     *\n     * @param fn - Receives an item; returns a publisher of zero or more new items to expand.\n     * @returns A `Flux<T>` of all original and expanded items.\n     *\n     * @example\n     * ```typescript\n     * // Fetch all pages recursively\n     * fetchPage(1)\n     *   .toFlux()\n     *   .expand(page => page.hasNext ? fetchPage(page.nextId).toFlux() : Flux.empty())\n     *   .subscribe(page => process(page));\n     * ```\n     */\n    public expand(fn: (value: T) => Publisher<T>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const pending: T[] = [];\n                let active = false;\n                let sourceDone = false;\n                let cancelled = false;\n                let terminated = false;\n                let demand = 0;\n\n                const terminate = (err?: Error) => {\n                    if (terminated) return;\n                    terminated = true;\n                    if (err) subscriber.onError(err);\n                    else subscriber.onComplete();\n                };\n\n                const drain = () => {\n                    if (active || cancelled || terminated) return;\n                    if (demand <= 0 || pending.length === 0) {\n                        if (sourceDone && pending.length === 0) terminate();\n                        return;\n                    }\n                    active = true;\n                    const v = pending.shift()!;\n                    demand--;\n                    subscriber.onNext(v);\n                    if (cancelled || terminated) { active = false; return; }\n\n                    let inner: Publisher<T>;\n                    try { inner = fn(v); }\n                    catch (e) { active = false; terminate(e instanceof Error ? e : new Error(String(e))); return; }\n\n                    inner.subscribe({\n                        onSubscribe(s: Subscription) { s.request(Number.MAX_SAFE_INTEGER); },\n                        onNext(r: T) { if (!cancelled && !terminated) pending.push(r); },\n                        onError(e: Error) { active = false; terminate(e); },\n                        onComplete() { active = false; drain(); }\n                    });\n                };\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { terminate(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        drain();\n                    },\n                    unsubscribe() { cancelled = true; }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        s.request(Number.MAX_SAFE_INTEGER);\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) { if (!cancelled && !terminated) { pending.push(v); drain(); } },\n                    onError(e: Error) { terminate(e); },\n                    onComplete() { sourceDone = true; if (!active && pending.length === 0) terminate(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Recursively expands each item using `fn`, emitting both the original items and\n     * all items produced by the expansion (**depth-first** order).\n     *\n     * Unlike {@link expand} (breadth-first), each item's children are emitted immediately\n     * after the item itself, before any sibling items are processed. This mirrors a\n     * recursive pre-order tree traversal.\n     *\n     * @param fn - Receives an item; returns a publisher of zero or more new items to expand.\n     * @returns A `Flux<T>` of all original and expanded items in depth-first order.\n     *\n     * @example\n     * ```typescript\n     * // Tree: 1 → [2, 3], 2 → [4, 5], others → empty\n     * Flux.just(1)\n     *   .expandDeep(n =>\n     *     n === 1 ? Flux.just(2, 3) :\n     *     n === 2 ? Flux.just(4, 5) :\n     *     Flux.empty()\n     *   )\n     *   .subscribe(v => console.log(v));\n     * // 1 2 4 5 3  (depth-first pre-order)\n     * ```\n     */\n    public expandDeep(fn: (value: T) => Publisher<T>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const pending: T[] = [];\n                let active = false;\n                let sourceDone = false;\n                let cancelled = false;\n                let terminated = false;\n                let demand = 0;\n\n                const terminate = (err?: Error) => {\n                    if (terminated) return;\n                    terminated = true;\n                    if (err) subscriber.onError(err);\n                    else subscriber.onComplete();\n                };\n\n                const drain = () => {\n                    if (active || cancelled || terminated) return;\n                    if (demand <= 0 || pending.length === 0) {\n                        if (sourceDone && pending.length === 0) terminate();\n                        return;\n                    }\n                    active = true;\n                    const v = pending.shift()!;\n                    demand--;\n                    subscriber.onNext(v);\n                    if (cancelled || terminated) { active = false; return; }\n\n                    let inner: Publisher<T>;\n                    try { inner = fn(v); }\n                    catch (e) { active = false; terminate(e instanceof Error ? e : new Error(String(e))); return; }\n\n                    const children: T[] = [];\n                    inner.subscribe({\n                        onSubscribe(s: Subscription) { s.request(Number.MAX_SAFE_INTEGER); },\n                        onNext(r: T) { if (!cancelled && !terminated) children.push(r); },\n                        onError(e: Error) { active = false; terminate(e); },\n                        onComplete() {\n                            // Depth-first: prepend children so they are processed before siblings.\n                            if (!cancelled && !terminated) pending.unshift(...children);\n                            active = false;\n                            drain();\n                        }\n                    });\n                };\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { terminate(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        drain();\n                    },\n                    unsubscribe() { cancelled = true; }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        s.request(Number.MAX_SAFE_INTEGER);\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) { if (!cancelled && !terminated) { pending.push(v); drain(); } },\n                    onError(e: Error) { terminate(e); },\n                    onComplete() { sourceDone = true; if (!active && pending.length === 0) terminate(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Pairs each item with the time elapsed (in ms) since the **previous** item\n     * (or since subscription for the first item).\n     *\n     * @returns A `Flux<[number, T]>` where the first element is elapsed milliseconds.\n     *\n     * @example\n     * ```typescript\n     * Flux.interval(100).take(3).elapsed().subscribe(([ms, n]) => console.log(ms, n));\n     * // ~100 0   ~100 1   ~100 2\n     * ```\n     */\n    public elapsed(): Flux<[number, T]> {\n        return new Flux<[number, T]>({\n            subscribe: (subscriber: Subscriber<[number, T]>): Subscription => {\n                let lastTime = Date.now();\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) { lastTime = Date.now(); },\n                    onNext(v: T) {\n                        const now = Date.now();\n                        const ms = now - lastTime;\n                        lastTime = now;\n                        subscriber.onNext([ms, v]);\n                    },\n                    onError(e: Error) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Attaches a `Date.now()` timestamp (in ms since epoch) to each item.\n     *\n     * @returns A `Flux<[number, T]>` where the first element is the Unix timestamp in ms.\n     */\n    public timestamp(): Flux<[number, T]> {\n        return this.map(v => [Date.now(), v] as [number, T]);\n    }\n\n    /**\n     * Wraps each signal (next, error, complete) into a {@link Signal} data object,\n     * emitting them all as `onNext` items on a `Flux<Signal<T>>`.\n     *\n     * After materializing, the resulting `Flux` always completes normally (errors become\n     * `Signal.error` items rather than `onError` signals).\n     * Use {@link dematerialize} to convert back.\n     *\n     * @returns A `Flux<Signal<T>>` where every event is represented as a data item.\n     */\n    public materialize(): Flux<Signal<T>> {\n        return new Flux<Signal<T>>({\n            subscribe: (subscriber: Subscriber<Signal<T>>): Subscription => {\n                let done = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v: T) { if (!done) subscriber.onNext(Signal.next(v)); },\n                    onError(e: Error) {\n                        if (done) return;\n                        done = true;\n                        subscriber.onNext(Signal.error<T>(e));\n                        subscriber.onComplete();\n                    },\n                    onComplete() {\n                        if (done) return;\n                        done = true;\n                        subscriber.onNext(Signal.complete<T>());\n                        subscriber.onComplete();\n                    }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Unwraps a `Flux<Signal<R>>` back into a regular `Flux<R>`, restoring\n     * `error` and `complete` signals from their materialized form.\n     *\n     * This is the inverse of {@link materialize}.\n     *\n     * @returns A `Flux<R>` with signals restored from the `Signal` wrappers.\n     */\n    public dematerialize<R>(this: Flux<Signal<R>>): Flux<R> {\n        return new Flux<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                let done = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(signal: Signal<R>) {\n                        if (done) return;\n                        if (signal.kind === 'next') subscriber.onNext(signal.value);\n                        else if (signal.kind === 'error') { done = true; subscriber.onError(signal.error); }\n                        else { done = true; subscriber.onComplete(); }\n                    },\n                    onError(e: Error) { if (!done) { done = true; subscriber.onError(e); } },\n                    onComplete() { if (!done) { done = true; subscriber.onComplete(); } }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Buffers all upstream items regardless of downstream demand, delivering them\n     * when demand becomes available.\n     *\n     * If `maxSize` is exceeded, an overflow error is signalled downstream.\n     *\n     * @param maxSize - Maximum buffer capacity (default: unbounded).\n     * @returns A `Flux<T>` with explicit backpressure buffering.\n     */\n    public onBackpressureBuffer(maxSize: number = Number.MAX_SAFE_INTEGER): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const buffer: T[] = [];\n                let demand = 0;\n                let cancelled = false;\n                let terminated = false;\n                let terminalError: Error | null = null;\n                let draining = false;\n\n                const drain = () => {\n                    if (draining || cancelled) return;\n                    draining = true;\n                    try {\n                        while (demand > 0 && buffer.length > 0 && !cancelled) {\n                            demand--;\n                            subscriber.onNext(buffer.shift()!);\n                        }\n                        if (terminated && buffer.length === 0 && !cancelled) {\n                            if (terminalError) subscriber.onError(terminalError);\n                            else subscriber.onComplete();\n                        }\n                    } finally { draining = false; }\n                };\n\n                const sourceSub = this.source.subscribe({\n                    onSubscribe(s: Subscription) { s.request(Number.MAX_SAFE_INTEGER); },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        if (buffer.length >= maxSize) {\n                            subscriber.onError(new Error(`onBackpressureBuffer overflow (maxSize=${maxSize})`));\n                            return;\n                        }\n                        buffer.push(v);\n                        drain();\n                    },\n                    onError(e: Error) { if (!cancelled) { terminated = true; terminalError = e; drain(); } },\n                    onComplete() { if (!cancelled) { terminated = true; drain(); } }\n                });\n\n                const sub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || (terminated && buffer.length === 0)) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        drain();\n                    },\n                    unsubscribe() { cancelled = true; buffer.length = 0; sourceSub.unsubscribe(); }\n                };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Drops upstream items that arrive when downstream has no outstanding demand.\n     *\n     * An optional `onDrop` callback is invoked for each dropped item.\n     *\n     * @param onDrop - Optional callback called with each dropped item.\n     * @returns A `Flux<T>` with drop backpressure strategy.\n     */\n    public onBackpressureDrop(onDrop?: (value: T) => void): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let demand = 0;\n                let cancelled = false;\n\n                const sourceSub = this.source.subscribe({\n                    onSubscribe(s: Subscription) { s.request(Number.MAX_SAFE_INTEGER); },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        if (demand > 0) { demand--; subscriber.onNext(v); }\n                        else { try { onDrop?.(v); } catch (_) {} }\n                    },\n                    onError(e: Error) { if (!cancelled) subscriber.onError(e); },\n                    onComplete() { if (!cancelled) subscriber.onComplete(); }\n                });\n\n                const sub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                    },\n                    unsubscribe() { cancelled = true; sourceSub.unsubscribe(); }\n                };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Keeps only the **latest** upstream item when downstream has no demand;\n     * older buffered items are overwritten as new ones arrive.\n     *\n     * @returns A `Flux<T>` with latest-value backpressure strategy.\n     */\n    public onBackpressureLatest(): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let latest: T | undefined;\n                let hasLatest = false;\n                let demand = 0;\n                let cancelled = false;\n                let terminated = false;\n                let terminalError: Error | null = null;\n\n                const drain = () => {\n                    if (cancelled) return;\n                    if (demand > 0 && hasLatest) {\n                        demand--;\n                        const v = latest!;\n                        hasLatest = false;\n                        latest = undefined;\n                        subscriber.onNext(v);\n                    }\n                    if (terminated && !hasLatest && !cancelled) {\n                        if (terminalError) subscriber.onError(terminalError);\n                        else subscriber.onComplete();\n                    }\n                };\n\n                const sourceSub = this.source.subscribe({\n                    onSubscribe(s: Subscription) { s.request(Number.MAX_SAFE_INTEGER); },\n                    onNext(v: T) { if (!cancelled) { latest = v; hasLatest = true; drain(); } },\n                    onError(e: Error) { if (!cancelled) { terminated = true; terminalError = e; drain(); } },\n                    onComplete() { if (!cancelled) { terminated = true; drain(); } }\n                });\n\n                const sub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || (terminated && !hasLatest)) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        drain();\n                    },\n                    unsubscribe() { cancelled = true; sourceSub.unsubscribe(); }\n                };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Requests items from upstream in batches of `n`, replenishing when 75% of\n     * the batch has been consumed (**prefetch** / **limitRate** semantics).\n     *\n     * Prevents requesting all items at once from expensive sources.\n     *\n     * @param n - Prefetch batch size.\n     * @returns A `Flux<T>` with controlled upstream demand.\n     */\n    public limitRate(n: number): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const prefetch = Math.max(1, n);\n                const replenish = Math.max(1, Math.floor(prefetch * 0.75));\n                let sourceSub!: Subscription;\n                let pending = 0;\n                let consumed = 0;\n                let cancelled = false;\n\n                const requestMore = () => {\n                    const toRequest = prefetch - pending;\n                    if (toRequest > 0) { pending += toRequest; sourceSub.request(toRequest); }\n                };\n\n                const operatorSub: Subscription = {\n                    request(count: number) {\n                        if (cancelled) return;\n                        if (count <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${count}`)); return; }\n                        requestMore();\n                    },\n                    unsubscribe() { cancelled = true; sourceSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) { sourceSub = s; subscriber.onSubscribe(operatorSub); },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        pending = Math.max(0, pending - 1);\n                        consumed++;\n                        subscriber.onNext(v);\n                        if (consumed >= replenish) { consumed = 0; requestMore(); }\n                    },\n                    onError(e: Error) { if (!cancelled) subscriber.onError(e); },\n                    onComplete() { if (!cancelled) subscriber.onComplete(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Filters items by runtime type, passing only items that are instances of `constructor`.\n     *\n     * @typeParam R - The target subtype.\n     * @param constructor - The class/constructor to filter by.\n     * @returns A `Flux<R>` containing only items that pass `instanceof`.\n     *\n     * @example\n     * ```typescript\n     * class Cat { meow() {} }\n     * class Dog { bark() {} }\n     * Flux.just(new Cat(), new Dog(), new Cat())\n     *   .ofType(Cat)\n     *   .subscribe(cat => cat.meow());\n     * ```\n     */\n    public ofType<R extends T>(constructor: new (...args: unknown[]) => R): Flux<R> {\n        return this.filter((v): v is R => v instanceof constructor).cast<R>();\n    }\n\n    /**\n     * Applies a reusable operator function `fn` to this `Flux`, deferred per subscription.\n     *\n     * `fn` receives this `Flux<T>` (as a `Publisher<T>`) and returns a new `Publisher<R>`.\n     * The transformation is re-evaluated on each `subscribe()` call (deferred assembly).\n     *\n     * @param fn - Operator function to apply.\n     * @returns A `Flux<R>` produced by `fn`.\n     *\n     * @example\n     * ```typescript\n     * const retryThrice = <T>(source: Publisher<T>) => Flux.from(source).retry(3);\n     * Flux.just(1, 2).transformDeferred(retryThrice).subscribe(v => console.log(v));\n     * ```\n     */\n    public transformDeferred<R>(fn: (flux: Publisher<T>) => Publisher<R>): Flux<R> {\n        return Flux.defer(() => Flux.from(fn(this)));\n    }\n}\n\n// ────────────────────────── GroupedFlux ──────────────────────────────────────\n\n/**\n * A `Flux<T>` tagged with a group `key`.\n *\n * Produced by {@link Flux#groupBy} — subscribe to it exactly like any `Flux<T>`;\n * the extra `key` property identifies which group this stream belongs to.\n *\n * Implemented as a plain type intersection rather than a subclass: the runtime\n * object is an ordinary `Flux<T>` with a `key` property attached via\n * `Object.assign`, so no extra prototype chain is required.\n *\n * @typeParam K - The type of the group key.\n * @typeParam T - The type of items in the group.\n */\nexport type GroupedFlux<K, T> = Flux<T> & { readonly key: K };\n","import {Publisher} from \"@/publishers/Publisher\";\nimport {Sink} from \"@/sinks/Sink\";\nimport {Flux} from \"@/publishers/Flux\";\nimport {PipePublisher} from \"@/publishers/PipePublisher\";\nimport {Subscriber} from \"@/subscriptions/Subscriber\";\nimport {Subscription} from \"@/subscriptions/Subscription\";\nimport {AbstractPipePublisher} from \"@/publishers/internal/AbstractPipePublisher\";\n\n/**\n * A cold publisher of 0 or 1 items with full backpressure support.\n *\n * A `Mono` emits at most one value followed by `onComplete`, or signals `onError`.\n * Items flow only when the downstream {@link Subscription} issues `request(n)`.\n * The convenience `subscribe(onNext, onError, onComplete)` overloads automatically\n * request `1` so the value starts flowing without extra ceremony.\n *\n * Each `subscribe()` call creates an **independent** run of the pipeline (\"cold\" semantics).\n *\n * @typeParam T - The type of the single item emitted by this Mono.\n *\n * @example\n * ```typescript\n * Mono.just(42)\n *   .map(n => n * 2)\n *   .subscribe(v => console.log(v));\n * // 84\n * ```\n */\nexport class Mono<T> extends AbstractPipePublisher<T, Mono<T>> implements PipePublisher<T> {\n\n    protected constructor(source: Publisher<T>) { super(source); }\n\n    protected defaultDemand(): number { return 1; }\n\n    protected wrapSource(source: Publisher<T>): Mono<T> {\n        return new Mono<T>(source);\n    }\n\n    // ─────────────────────────── Static factories ────────────────────────────\n\n    /**\n     * Creates a `Mono` from a generator function that pushes a value imperatively.\n     *\n     * The generator receives a {@link Sink} and should call exactly one of:\n     * - `sink.next(value)` — emits the value and completes.\n     * - `sink.error(err)` — terminates with an error.\n     * - `sink.complete()` — completes without emitting a value (empty `Mono`).\n     *\n     * Delivery is deferred until the downstream subscriber issues `request(n)`.\n     * Rule 1.3 is respected — `onSubscribe` is delivered before the generator runs.\n     *\n     * @param generator - Function that drives the `Mono` via the provided `Sink<T>`.\n     * @returns A cold `Mono<T>`.\n     *\n     * @example\n     * ```typescript\n     * Mono.generate<number>(sink => sink.next(42)).subscribe(v => console.log(v)); // 42\n     * ```\n     */\n    public static generate<T>(generator: (sink: Sink<T>) => void): Mono<T> {\n        return new Mono<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                let cancelled = false;\n                let demanded = false;\n                let terminated = false;\n                let pending: { value: T } | null = null;\n                let pendingError: Error | null = null;\n\n                const tryDeliver = () => {\n                    if (cancelled || !demanded) return;\n                    if (pending !== null) {\n                        const v = pending.value;\n                        pending = null;\n                        subscriber.onNext(v);\n                        if (!cancelled) subscriber.onComplete();\n                    } else if (pendingError !== null) {\n                        const e = pendingError;\n                        pendingError = null;\n                        subscriber.onError(e);\n                    } else if (terminated) {\n                        subscriber.onComplete();\n                    }\n                };\n\n                const sink: Sink<T> = {\n                    next(v: T) {\n                        if (terminated || cancelled) return;\n                        terminated = true;\n                        if (demanded) {\n                            subscriber.onNext(v);\n                            if (!cancelled) subscriber.onComplete();\n                        } else {\n                            pending = { value: v };\n                        }\n                    },\n                    error(err: Error) {\n                        if (terminated || cancelled) return;\n                        terminated = true;\n                        if (demanded) {\n                            subscriber.onError(err);\n                        } else {\n                            pendingError = err;\n                        }\n                    },\n                    complete() {\n                        if (terminated || cancelled) return;\n                        terminated = true;\n                        if (demanded) subscriber.onComplete();\n                        // else: deliver onComplete on next request()\n                    }\n                };\n\n                try {\n                    generator(sink);\n                } catch (e) {\n                    if (!terminated) {\n                        terminated = true;\n                        pendingError = e instanceof Error ? e : new Error(String(e));\n                    }\n                }\n\n                const subscription: Subscription = {\n                    request(n: number) {\n                        if (cancelled || demanded) return;\n                        if (n <= 0) {\n                            subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                            return;\n                        }\n                        demanded = true;\n                        tryDeliver();\n                    },\n                    unsubscribe() { cancelled = true; }\n                };\n                subscriber.onSubscribe(subscription);\n                return subscription;\n            }\n        });\n    }\n\n    /**\n     * Wraps an existing {@link Publisher} as a `Mono`.\n     *\n     * @param publisher - Any `Publisher<T>` to adapt.\n     * @returns A `Mono<T>` backed by the given publisher.\n     */\n    public static from<T>(publisher: Publisher<T>): Mono<T> {\n        return new Mono<T>(publisher);\n    }\n\n    /**\n     * Creates a `Mono` that emits `value` then completes.\n     *\n     * @param value - The single item to emit.\n     * @returns A cold `Mono<T>`.\n     *\n     * @example\n     * ```typescript\n     * Mono.just(42).subscribe(v => console.log(v)); // 42\n     * ```\n     */\n    public static just<T>(value: T): Mono<T> {\n        return Mono.generate(sink => sink.next(value));\n    }\n\n    /**\n     * Creates a `Mono` that emits `value` if it is non-null and non-undefined,\n     * or completes empty if `value` is `null` or `undefined`.\n     *\n     * @param value - The value to emit, or `null`/`undefined` for an empty Mono.\n     * @returns A `Mono<T>` that emits the value or completes immediately.\n     */\n    public static justOrEmpty<T>(value: T | null | undefined): Mono<T> {\n        return value != null ? Mono.just(value) : Mono.empty<T>();\n    }\n\n    /**\n     * Creates a `Mono` that completes immediately without emitting any value.\n     *\n     * @returns An empty, completed `Mono<T>`.\n     */\n    public static empty<T = never>(): Mono<T> {\n        return new Mono<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                const sub = { request() {}, unsubscribe() {} };\n                subscriber.onSubscribe(sub);\n                subscriber.onComplete();\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Creates a `Mono` that signals `onError` immediately upon subscription.\n     *\n     * @param error - The error to signal (wrapped in an `Error` if not already one).\n     * @returns An errored `Mono<T>`.\n     */\n    public static error<T = never>(error: unknown): Mono<T> {\n        const err = error instanceof Error ? error : new Error(String(error));\n        return new Mono<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                const sub = { request() {}, unsubscribe() {} };\n                subscriber.onSubscribe(sub);\n                subscriber.onError(err);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Creates a `Mono` that adapts a `Promise<T>`.\n     *\n     * The resolved value is emitted as the single item; a rejected promise signals `onError`.\n     *\n     * @param promise - The promise to adapt.\n     * @returns A `Mono<T>` backed by the promise.\n     *\n     * @example\n     * ```typescript\n     * Mono.fromPromise(fetch('/api/data').then(r => r.json()))\n     *   .subscribe(data => console.log(data));\n     * ```\n     */\n    public static fromPromise<T>(promise: Promise<T>): Mono<T> {\n        return Mono.generate(sink =>\n            promise\n                .then(value => sink.next(value))\n                .catch(err => sink.error(err instanceof Error ? err : new Error(String(err))))\n        );\n    }\n\n    /**\n     * Lazily creates a new `Mono` per subscription by calling `factory`.\n     *\n     * Useful when the source depends on mutable state that should be captured\n     * at subscribe time rather than at assembly time.\n     *\n     * @param factory - Called once per subscription to produce the actual `Mono<T>`.\n     * @returns A lazy `Mono<T>`.\n     */\n    public static defer<T>(factory: () => Mono<T>): Mono<T> {\n        return new Mono<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                return factory().subscribe(subscriber);\n            }\n        });\n    }\n\n    /**\n     * Alias for {@link Mono.generate} — imperative push interface.\n     *\n     * The generator receives a {@link Sink} and should call exactly one of:\n     * `sink.next(value)`, `sink.error(err)`, or `sink.complete()`.\n     *\n     * @param generator - Function that drives the `Mono` via the provided `Sink<T>`.\n     * @returns A cold `Mono<T>`.\n     */\n    public static create<T>(generator: (sink: Sink<T>) => void): Mono<T> {\n        return Mono.generate(generator);\n    }\n\n    /**\n     * Creates a `Mono<number>` that emits `0` after `ms` milliseconds then completes.\n     *\n     * Useful for introducing timed delays in reactive pipelines.\n     *\n     * @param ms - The delay in milliseconds.\n     * @returns A `Mono<number>` that emits `0` after the delay.\n     *\n     * @example\n     * ```typescript\n     * Mono.delay(500).flatMap(() => Mono.just('hello')).subscribe(v => console.log(v));\n     * ```\n     */\n    public static delay(ms: number): Mono<number> {\n        return Mono.generate<number>(sink => {\n            const id = setTimeout(() => sink.next(0), ms);\n            // cancellation note: timeout fires and is a no-op if sink already terminated\n            void id;\n        });\n    }\n\n    /**\n     * Creates a `Mono<T>` from a synchronous, potentially-throwing factory function.\n     *\n     * The factory is called **lazily** at subscription time (not at assembly time).\n     * If the factory throws, the exception is forwarded as `onError`.\n     *\n     * @param fn - Synchronous factory invoked once per subscription.\n     * @returns A cold `Mono<T>`.\n     *\n     * @example\n     * ```typescript\n     * Mono.fromCallable(() => JSON.parse(rawJson)).subscribe(v => console.log(v));\n     * ```\n     */\n    public static fromCallable<T>(fn: () => T): Mono<T> {\n        return Mono.generate<T>(sink => {\n            try { sink.next(fn()); }\n            catch (e) { sink.error(e instanceof Error ? e : new Error(String(e))); }\n        });\n    }\n\n    /**\n     * Races multiple `Mono`s — emits the first value to arrive, cancelling the rest.\n     *\n     * If a source completes without emitting, it is excluded from the race.\n     * If **all** sources complete empty, the resulting `Mono` also completes empty.\n     * If any source errors before another source emits, the error is propagated.\n     *\n     * @param sources - One or more `Mono<T>` sources to race.\n     * @returns A `Mono<T>` that emits the first available value.\n     *\n     * @example\n     * ```typescript\n     * Mono.firstWithValue(slow, fast).subscribe(v => console.log(v)); // fast's value\n     * ```\n     */\n    public static firstWithValue<T>(...sources: Mono<T>[]): Mono<T> {\n        if (sources.length === 0) return Mono.empty<T>();\n        return Mono.generate<T>(sink => {\n            let done = false;\n            let completedCount = 0;\n            const subs: Subscription[] = [];\n\n            for (const source of sources) {\n                const sub = source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v: T) {\n                        if (done) return;\n                        done = true;\n                        for (const s of subs) s.unsubscribe();\n                        sink.next(v);\n                    },\n                    onError(e: Error) {\n                        if (done) return;\n                        done = true;\n                        for (const s of subs) s.unsubscribe();\n                        sink.error(e);\n                    },\n                    onComplete() {\n                        if (done) return;\n                        completedCount++;\n                        if (completedCount === sources.length) {\n                            done = true;\n                            sink.complete();\n                        }\n                    }\n                });\n                subs.push(sub);\n            }\n            for (const sub of subs) sub.request(1);\n        });\n    }\n\n    /**\n     * Returns a `Mono<void>` that completes when **all** given publishers complete.\n     *\n     * Emitted values from the sources are ignored. If any source signals `onError`,\n     * the error is propagated immediately and all other sources are cancelled.\n     * If no sources are provided, completes immediately.\n     *\n     * @param sources - Zero or more publishers to wait on.\n     * @returns A `Mono<void>` that completes once every source has completed.\n     *\n     * @example\n     * ```typescript\n     * Mono.when(Mono.delay(100), Mono.delay(200))\n     *   .subscribe(undefined, undefined, () => console.log('all done'));\n     * ```\n     */\n    public static when(...sources: Publisher<unknown>[]): Mono<void> {\n        if (sources.length === 0) return Mono.empty<void>();\n        return Mono.generate<void>(sink => {\n            let done = false;\n            let completedCount = 0;\n            const subs: Subscription[] = [];\n\n            for (const source of sources) {\n                const sub = source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(_v) {},\n                    onError(e: Error) {\n                        if (done) return;\n                        done = true;\n                        for (const s of subs) s.unsubscribe();\n                        sink.error(e);\n                    },\n                    onComplete() {\n                        if (done) return;\n                        completedCount++;\n                        if (completedCount === sources.length) {\n                            done = true;\n                            sink.complete();\n                        }\n                    }\n                });\n                subs.push(sub);\n            }\n            for (const sub of subs) sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    // ─────────────────────── PipePublisher operators ─────────────────────────\n\n    /**\n     * Transforms the emitted value using `fn`, producing a `Mono<R>`.\n     *\n     * If `fn` throws, the exception is forwarded to `onError` and the stream terminates.\n     *\n     * @param fn - Mapping function applied to the emitted value.\n     * @returns A new `Mono<R>`.\n     *\n     * @example\n     * ```typescript\n     * Mono.just(42).map(n => n.toString()).subscribe(v => console.log(v)); // '42'\n     * ```\n     */\n    public map<R>(fn: (value: T) => R): Mono<R> {\n        return new Mono<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        try { subscriber.onNext(fn(v)); }\n                        catch (e) { subscriber.onError(e instanceof Error ? e : new Error(String(e))); }\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Transforms the emitted value with `fn`, completing empty if the result is `null` or `undefined`.\n     *\n     * @param fn - Mapping function; returning `null` or `undefined` produces an empty `Mono`.\n     * @returns A `Mono<NonNullable<R>>` that completes empty when the mapping returns null.\n     */\n    public mapNotNull<R>(fn: (value: T) => R | null | undefined): Mono<NonNullable<R>> {\n        return new Mono<NonNullable<R>>({\n            subscribe: (subscriber: Subscriber<NonNullable<R>>): Subscription => {\n                let done = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        if (done) return;\n                        try {\n                            const result = fn(v);\n                            if (result != null) subscriber.onNext(result as NonNullable<R>);\n                            else { done = true; subscriber.onComplete(); }\n                        } catch (e) {\n                            done = true;\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                        }\n                    },\n                    onError(e) { if (!done) { done = true; subscriber.onError(e); } },\n                    onComplete() { if (!done) { done = true; subscriber.onComplete(); } }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Maps the emitted value to an inner `Mono<R>` and flattens the result.\n     *\n     * When the source emits a value, `fn` is called and the resulting inner `Mono` is\n     * subscribed to. The inner `Mono`'s value (or completion/error) is forwarded downstream.\n     *\n     * @param fn - Maps the emitted value to a `Mono<R>` or any `Publisher<R>`.\n     * @returns A `Mono<R>` containing the result of the inner publisher.\n     */\n    public flatMap<R>(fn: (value: T) => Mono<R>): Mono<R>;\n    public flatMap<R>(fn: (value: T) => Publisher<R>): Mono<R>;\n    public flatMap<R>(fn: (value: T) => Publisher<R>): Mono<R> {\n        return new Mono<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                let outerSub: Subscription = { request() {}, unsubscribe() {} };\n                let innerSub: Subscription | null = null;\n                let cancelled = false;\n                let demand = 0;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) {\n                            subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                            return;\n                        }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (innerSub) innerSub.request(n);\n                    },\n                    unsubscribe() {\n                        cancelled = true;\n                        outerSub.unsubscribe();\n                        innerSub?.unsubscribe();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(sourceSub: Subscription) {\n                        outerSub = sourceSub;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        let inner: Publisher<R>;\n                        try { inner = fn(v); }\n                        catch (e) {\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                            return;\n                        }\n                        innerSub = inner.subscribe({\n                            onSubscribe(_s) {},\n                            onNext(r) { subscriber.onNext(r); },\n                            onError(e) { subscriber.onError(e); },\n                            onComplete() { subscriber.onComplete(); }\n                        });\n                        if (demand > 0) innerSub.request(demand);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() {\n                        if (!innerSub) subscriber.onComplete();\n                    }\n                });\n                outerSub.request(1);\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Passes the emitted value downstream only if `predicate` returns `true`;\n     * otherwise completes the `Mono` without emitting.\n     *\n     * @param predicate - Synchronous test applied to the emitted value.\n     * @returns A `Mono<T>` that completes empty when the predicate fails.\n     */\n    public filter(predicate: (value: T) => boolean): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let done = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        if (done) return;\n                        try {\n                            if (predicate(v)) subscriber.onNext(v);\n                            else { done = true; subscriber.onComplete(); }\n                        } catch (e) {\n                            done = true;\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                        }\n                    },\n                    onError(e) { if (!done) { done = true; subscriber.onError(e); } },\n                    onComplete() { if (!done) { done = true; subscriber.onComplete(); } }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Asynchronous filter: subscribes to `predicate(value)` and forwards the value\n     * downstream only if the predicate publisher emits `true`; otherwise completes empty.\n     *\n     * @param predicate - Returns a `Publisher<boolean>` for the emitted value.\n     * @returns A `Mono<T>` that completes empty when the predicate is not satisfied.\n     */\n    public filterWhen(predicate: (value: T) => Publisher<boolean>): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let outerSub: Subscription = { request() {}, unsubscribe() {} };\n                let innerSub: Subscription | null = null;\n                let cancelled = false;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) {\n                            subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                            return;\n                        }\n                    },\n                    unsubscribe() {\n                        cancelled = true;\n                        outerSub.unsubscribe();\n                        innerSub?.unsubscribe();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(sourceSub: Subscription) {\n                        outerSub = sourceSub;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        let pred: Publisher<boolean>;\n                        try { pred = predicate(v); }\n                        catch (e) {\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                            return;\n                        }\n                        let innerDone = false;\n                        innerSub = pred.subscribe({\n                            onSubscribe(_s) {},\n                            onNext(passes) {\n                                if (innerDone) return;\n                                innerDone = true;\n                                if (passes) subscriber.onNext(v);\n                                else subscriber.onComplete();\n                            },\n                            onError(e) { if (!innerDone) { innerDone = true; subscriber.onError(e); } },\n                            onComplete() { if (!innerDone) { innerDone = true; subscriber.onComplete(); } }\n                        });\n                        innerSub.request(1);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { if (!innerSub) subscriber.onComplete(); }\n                });\n                outerSub.request(1);\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Unsafe type cast — changes the declared element type to `R` without any\n     * runtime conversion. Use only when you are certain the actual runtime type is compatible.\n     *\n     * @typeParam R - The target element type.\n     * @returns This `Mono` re-typed as `Mono<R>`.\n     */\n    public cast<R>(): Mono<R> {\n        return new Mono<R>(this.source as unknown as Publisher<R>);\n    }\n\n    /**\n     * Executes a side-effect function after the stream ends for **any** reason —\n     * normal completion or error. Unlike {@link Flux#doFinally}, this does not fire on\n     * cancellation (a `Mono` cancel is semantically identical to an unneeded result).\n     *\n     * Any exception thrown by `fn` is silently swallowed.\n     *\n     * @param fn - Side-effect to run after any terminal event.\n     * @returns A `Mono<T>` with the side effect attached.\n     */\n    public doFinally(fn: () => void): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) {\n                        try { fn(); } catch (_) {}\n                        subscriber.onError(e);\n                    },\n                    onComplete() {\n                        try { fn(); } catch (_) {}\n                        subscriber.onComplete();\n                    }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Low-level escape hatch for bridging imperative push-based sources into a `Mono<R>`.\n     *\n     * The `producer` receives three callbacks and must call them to drive the stream.\n     * `onRequest` and `onUnsubscribe` let the caller respond to downstream demand and\n     * cancellation respectively.\n     *\n     * @param producer - Callback that receives `(onNext, onError, onComplete)` and drives the stream.\n     * @param onRequest - Called when the downstream subscriber requests `n` more items.\n     * @param onUnsubscribe - Called when the downstream subscriber cancels.\n     * @returns A `Mono<R>` backed by the imperative producer.\n     */\n    public pipe<R>(\n        producer: (onNext: (value: R) => void, onError: (error: Error) => void, onComplete: () => void) => void,\n        onRequest: (request: number) => void,\n        onUnsubscribe: () => void\n    ): Mono<R> {\n        return new Mono<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                producer(\n                    v => subscriber.onNext(v),\n                    e => subscriber.onError(e),\n                    () => subscriber.onComplete()\n                );\n                const sub = { request: onRequest, unsubscribe: onUnsubscribe };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    // ─────────────────────── Mono-specific operators ─────────────────────────\n\n    /**\n     * Maps the emitted value to a multi-item publisher and returns the items as a `Flux<R>`.\n     *\n     * The inner publisher is subscribed to once the source emits its single value.\n     * All items from the inner publisher are forwarded downstream. If the source is empty,\n     * the resulting `Flux` also completes empty.\n     *\n     * @param mapper - Maps the emitted value to a `Flux<R>`, `Mono<R>`, or any `Publisher<R>`.\n     * @returns A `Flux<R>` containing all items from the inner publisher.\n     *\n     * @example\n     * ```typescript\n     * Mono.just(3)\n     *   .flatMapMany(n => Flux.range(1, n))\n     *   .subscribe(v => console.log(v)); // 1  2  3\n     * ```\n     */\n    public flatMapMany<R>(mapper: (value: T) => Flux<R>): Flux<R>;\n    public flatMapMany<R>(mapper: (value: T) => Mono<R>): Flux<R>;\n    public flatMapMany<R>(mapper: (value: T) => Publisher<R>): Flux<R>;\n    public flatMapMany<R>(mapper: (value: T) => Publisher<R>): Flux<R> {\n        return Flux.from<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                let outerSub: Subscription = { request() {}, unsubscribe() {} };\n                let innerSub: Subscription | null = null;\n                let cancelled = false;\n                let demand = 0;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) {\n                            subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                            return;\n                        }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (innerSub) innerSub.request(n);\n                    },\n                    unsubscribe() {\n                        cancelled = true;\n                        outerSub.unsubscribe();\n                        innerSub?.unsubscribe();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(sourceSub: Subscription) {\n                        outerSub = sourceSub;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        let inner: Publisher<R>;\n                        try { inner = mapper(v); }\n                        catch (e) {\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                            return;\n                        }\n                        innerSub = inner.subscribe({\n                            onSubscribe(_s) {},\n                            onNext(r) { subscriber.onNext(r); },\n                            onError(e) { subscriber.onError(e); },\n                            onComplete() { subscriber.onComplete(); }\n                        });\n                        if (demand > 0) innerSub.request(demand);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { if (!innerSub) subscriber.onComplete(); }\n                });\n                outerSub.request(1);\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Subscribes to this `Mono` and `other` concurrently and combines their values\n     * into a `[T, R]` tuple once both emit.\n     *\n     * If either `Mono` completes empty, the resulting `Mono` also completes empty.\n     * If either errors, the error is forwarded and the other is cancelled.\n     *\n     * @param other - The second `Mono` to zip with.\n     * @returns A `Mono<[T, R]>` emitting the combined tuple.\n     *\n     * @example\n     * ```typescript\n     * Mono.just(1).zipWith(Mono.just('a')).subscribe(([n, s]) => console.log(n, s)); // 1 a\n     * ```\n     */\n    public zipWith<R>(other: Mono<R>): Mono<[T, R]> {\n        return Mono.generate<[T, R]>(sink => {\n            let left: T | undefined;\n            let right: R | undefined;\n            let leftDone = false;\n            let rightDone = false;\n            let failed = false;\n\n            const fail = (e: Error) => {\n                if (failed) return;\n                failed = true;\n                leftSub?.unsubscribe();\n                rightSub?.unsubscribe();\n                sink.error(e);\n            };\n\n            const tryEmit = () => {\n                if (leftDone && rightDone) {\n                    sink.next([left as T, right as R]);\n                }\n            };\n\n            let leftSub: Subscription;\n            let rightSub: Subscription;\n\n            leftSub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) { left = v; leftDone = true; tryEmit(); },\n                onError(e) { fail(e); },\n                onComplete() { if (!leftDone) { rightSub?.unsubscribe(); sink.complete(); } }\n            });\n\n            rightSub = other.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) { right = v; rightDone = true; tryEmit(); },\n                onError(e) { fail(e); },\n                onComplete() { if (!rightDone) { leftSub?.unsubscribe(); sink.complete(); } }\n            });\n\n            leftSub.request(1);\n            rightSub.request(1);\n        });\n    }\n\n    /**\n     * Emits the source value and uses `fn` to derive a second `Mono`, combining both into a tuple.\n     *\n     * The source value is passed to `fn` to produce the second `Mono`. Both values are then\n     * combined into a `[T, R]` tuple. If either `Mono` is empty or errors, those signals\n     * propagate to the subscriber.\n     *\n     * @param fn - Called with the emitted value to produce the second `Mono<R>`.\n     * @returns A `Mono<[T, R]>` emitting both values as a tuple.\n     *\n     * @example\n     * ```typescript\n     * Mono.just(42).zipWhen(n => Mono.just(n.toString())).subscribe(([n, s]) => console.log(n, s));\n     * // 42 '42'\n     * ```\n     */\n    public zipWhen<R>(fn: (value: T) => Mono<R>): Mono<[T, R]> {\n        return Mono.generate<[T, R]>(sink => {\n            const outerSub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v: T) {\n                    let inner: Mono<R>;\n                    try { inner = fn(v); }\n                    catch (e) { sink.error(e instanceof Error ? e : new Error(String(e))); return; }\n\n                    const innerSub = inner.subscribe({\n                        onSubscribe(_s) {},\n                        onNext(r) { sink.next([v, r]); },\n                        onError(e) { sink.error(e); },\n                        onComplete() { sink.complete(); }\n                    });\n                    innerSub.request(1);\n                },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.complete(); }\n            });\n            outerSub.request(1);\n        });\n    }\n\n    /**\n     * Emits `true` if this `Mono` emits a value, `false` if it completes empty.\n     *\n     * @returns A `Mono<boolean>`.\n     */\n    public hasElement(): Mono<boolean> {\n        return Mono.generate<boolean>(sink => {\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(_v) { sub.unsubscribe(); sink.next(true); },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.next(false); }\n            });\n            sub.request(1);\n        });\n    }\n\n    /**\n     * Side effect executed when the `Mono` emits its value.\n     *\n     * Does **not** affect the emitted value or stream lifecycle.\n     * Exceptions thrown by `fn` are forwarded as `onError`.\n     *\n     * @param fn - Called with the emitted value.\n     * @returns A `Mono<T>` with the side effect attached.\n     *\n     * @example\n     * ```typescript\n     * Mono.just(42).doOnSuccess(v => console.log('got', v)).subscribe();\n     * ```\n     */\n    public doOnSuccess(fn: (value: T) => void): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        try { fn(v); } catch (e) {\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                            return;\n                        }\n                        subscriber.onNext(v);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Converts a terminal error into a normal `onComplete` signal.\n     *\n     * If a `predicate` is supplied, only errors for which the predicate returns `true`\n     * are swallowed; others are re-propagated as-is.\n     *\n     * @param predicate - Optional filter; when absent all errors are converted.\n     * @returns A `Mono<T>` that completes rather than errors (when predicate matches).\n     *\n     * @example\n     * ```typescript\n     * Mono.error(new Error('oops')).onErrorComplete().subscribe(undefined, undefined, () => console.log('done'));\n     * ```\n     */\n    public onErrorComplete(predicate?: (e: Error) => boolean): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) {\n                        if (!predicate || predicate(e)) subscriber.onComplete();\n                        else subscriber.onError(e);\n                    },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Ignores any value emitted by this `Mono` and, upon normal completion,\n     * emits `value` instead.\n     *\n     * Errors from the source are propagated unchanged.\n     *\n     * @param value - The value to emit after this `Mono` completes.\n     * @returns A `Mono<R>` that emits `value` on source completion.\n     *\n     * @example\n     * ```typescript\n     * Mono.just('ignored').thenReturn(42).subscribe(v => console.log(v)); // 42\n     * ```\n     */\n    public thenReturn<R>(value: R): Mono<R> {\n        return new Mono<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                let done = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(_v) { /* swallow the emitted value */ },\n                    onError(e) { if (!done) { done = true; subscriber.onError(e); } },\n                    onComplete() {\n                        if (!done) {\n                            done = true;\n                            subscriber.onNext(value);\n                            subscriber.onComplete();\n                        }\n                    }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Delays delivery of the emitted value by `ms` milliseconds.\n     *\n     * The delay is introduced **after** the source emits; completion and errors\n     * are forwarded without delay.\n     *\n     * @param ms - Delay in milliseconds.\n     * @returns A `Mono<T>` whose value arrives `ms` milliseconds later.\n     *\n     * @example\n     * ```typescript\n     * Mono.just('hello').delayElement(200).subscribe(v => console.log(v));\n     * ```\n     */\n    public delayElement(ms: number): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let timerId: ReturnType<typeof setTimeout> | null = null;\n                let cancelled = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        if (cancelled) return;\n                        timerId = setTimeout(() => {\n                            if (!cancelled) {\n                                subscriber.onNext(v);\n                                subscriber.onComplete();\n                            }\n                        }, ms);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { /* wait for timer, or complete immediately if no value */ }\n                });\n                const proxy: Subscription = {\n                    request(n) { sub.request(n); },\n                    unsubscribe() {\n                        cancelled = true;\n                        if (timerId !== null) clearTimeout(timerId);\n                        sub.unsubscribe();\n                    }\n                };\n                subscriber.onSubscribe(proxy);\n                return proxy;\n            }\n        });\n    }\n\n    /**\n     * Holds the emitted value until a trigger publisher (returned by `triggerFn`) emits\n     * or completes, then forwards the value downstream.\n     *\n     * If the trigger errors, the error is propagated and the value is discarded.\n     * If the source is empty, completes immediately without invoking `triggerFn`.\n     *\n     * @param triggerFn - Receives the emitted value and returns a trigger `Publisher`.\n     * @returns A `Mono<T>` that emits after the trigger fires.\n     *\n     * @example\n     * ```typescript\n     * Mono.just(42).delayUntil(() => Mono.delay(300)).subscribe(v => console.log(v));\n     * ```\n     */\n    public delayUntil(triggerFn: (value: T) => Publisher<unknown>): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let outerSub: Subscription = { request() {}, unsubscribe() {} };\n                let innerSub: Subscription | null = null;\n                let cancelled = false;\n\n                const operatorSub: Subscription = {\n                    request(n) { if (!cancelled) outerSub.request(n); },\n                    unsubscribe() {\n                        cancelled = true;\n                        outerSub.unsubscribe();\n                        innerSub?.unsubscribe();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s) { outerSub = s; subscriber.onSubscribe(operatorSub); },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        let trigger: Publisher<unknown>;\n                        try { trigger = triggerFn(v); }\n                        catch (e) {\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                            return;\n                        }\n                        let triggered = false;\n                        innerSub = trigger.subscribe({\n                            onSubscribe(_s) {},\n                            onNext(_u) {\n                                if (triggered || cancelled) return;\n                                triggered = true;\n                                innerSub?.unsubscribe();\n                                subscriber.onNext(v);\n                                subscriber.onComplete();\n                            },\n                            onError(e) { if (!cancelled) subscriber.onError(e); },\n                            onComplete() {\n                                if (!triggered && !cancelled) {\n                                    triggered = true;\n                                    subscriber.onNext(v);\n                                    subscriber.onComplete();\n                                }\n                            }\n                        });\n                        innerSub.request(Number.MAX_SAFE_INTEGER);\n                    },\n                    onError(e) { if (!cancelled) subscriber.onError(e); },\n                    onComplete() { if (!cancelled && !innerSub) subscriber.onComplete(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Falls back to `other` if this `Mono` completes without emitting a value (empty).\n     *\n     * If this `Mono` emits a value or errors, `other` is never subscribed to.\n     *\n     * @param other - The fallback `Mono<T>` to subscribe to when the source is empty.\n     * @returns A `Mono<T>` that emits from `other` when the source is empty.\n     *\n     * @example\n     * ```typescript\n     * Mono.empty<number>().or(Mono.just(99)).subscribe(v => console.log(v)); // 99\n     * ```\n     */\n    public or(other: Mono<T>): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let outerSub: Subscription = { request() {}, unsubscribe() {} };\n                let innerSub: Subscription | null = null;\n                let cancelled = false;\n                let emitted = false;\n\n                const operatorSub: Subscription = {\n                    request(n) {\n                        if (cancelled) return;\n                        if (innerSub) innerSub.request(n);\n                        else outerSub.request(n);\n                    },\n                    unsubscribe() {\n                        cancelled = true;\n                        outerSub.unsubscribe();\n                        innerSub?.unsubscribe();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s) { outerSub = s; subscriber.onSubscribe(operatorSub); },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        emitted = true;\n                        subscriber.onNext(v);\n                    },\n                    onError(e) { if (!cancelled) subscriber.onError(e); },\n                    onComplete() {\n                        if (cancelled || emitted) return;\n                        innerSub = other.subscribe({\n                            onSubscribe(_s) {},\n                            onNext(v) { if (!cancelled) subscriber.onNext(v); },\n                            onError(e) { if (!cancelled) subscriber.onError(e); },\n                            onComplete() { if (!cancelled) subscriber.onComplete(); }\n                        });\n                        innerSub.request(1);\n                    }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Re-subscribes to this `Mono` on error, using a control publisher to decide\n     * whether and when to retry.\n     *\n     * Each time the source errors, the error is pushed to the control stream returned\n     * by `fn`. If that stream emits any item, the source is re-subscribed. If it\n     * completes or errors, that terminal signal is forwarded downstream.\n     *\n     * @param fn - Receives a `Flux<Error>` of upstream errors; returns a control publisher.\n     * @returns A `Mono<T>` that retries according to the control signal.\n     *\n     * @example\n     * ```typescript\n     * Mono.error(new Error('boom'))\n     *   .retryWhen(errors => errors.take(3))\n     *   .subscribe(undefined, e => console.error(e));\n     * ```\n     */\n    public retryWhen(fn: (errors: Flux<Error>) => Publisher<unknown>): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let cancelled = false;\n                let currentSub: Subscription | null = null;\n                let emitted = false;\n\n                // Relay subscriber that the control stream holds\n                let controlSub: { onNext: (e: Error) => void } | null = null;\n\n                const errorRelay = Flux.from<Error>({\n                    subscribe(relaySubscriber) {\n                        controlSub = { onNext: (e) => relaySubscriber.onNext(e) };\n                        const sub: Subscription = {\n                            request(_n) {},\n                            unsubscribe() { cancelled = true; }\n                        };\n                        relaySubscriber.onSubscribe(sub);\n                        return sub;\n                    }\n                });\n\n                const control = fn(errorRelay);\n\n                let controlSubscriber: {\n                    onNext: (v: unknown) => void;\n                    onError: (e: Error) => void;\n                    onComplete: () => void;\n                };\n\n                const attempt = () => {\n                    if (cancelled || emitted) return;\n                    currentSub = this.source.subscribe({\n                        onSubscribe(_s) {},\n                        onNext(v: T) {\n                            if (cancelled || emitted) return;\n                            emitted = true;\n                            subscriber.onNext(v);\n                            subscriber.onComplete();\n                        },\n                        onError(e: Error) {\n                            if (cancelled) return;\n                            controlSub?.onNext(e);\n                        },\n                        onComplete() {\n                            if (!cancelled && !emitted) subscriber.onComplete();\n                        }\n                    });\n                    currentSub.request(1);\n                };\n\n                const controlSub2 = control.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(_v: unknown) { if (!cancelled && !emitted) attempt(); },\n                    onError(e: Error) { if (!cancelled) subscriber.onError(e); },\n                    onComplete() { if (!cancelled && !emitted) subscriber.onComplete(); }\n                });\n                controlSub2.request(Number.MAX_SAFE_INTEGER);\n\n                controlSubscriber = {\n                    onNext: (_v) => { if (!cancelled && !emitted) attempt(); },\n                    onError: (e) => { if (!cancelled) subscriber.onError(e); },\n                    onComplete: () => { if (!cancelled && !emitted) subscriber.onComplete(); }\n                };\n                void controlSubscriber;\n\n                attempt();\n\n                const operatorSub: Subscription = {\n                    request(_n) {},\n                    unsubscribe() {\n                        cancelled = true;\n                        currentSub?.unsubscribe();\n                        controlSub2.unsubscribe();\n                    }\n                };\n                subscriber.onSubscribe(operatorSub);\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Alias for {@link Mono#toPromise} — returns a `Promise<T | null>` that resolves\n     * with the emitted value (or `null` if the `Mono` is empty).\n     *\n     * @returns A `Promise<T | null>`.\n     */\n    public toFuture(): Promise<T | null> {\n        return this.toPromise();\n    }\n\n    /**\n     * Subscribes to this `Mono` and returns a `Promise<T | null>`.\n     *\n     * The promise resolves with the emitted value, or with `null` if the `Mono` completes empty.\n     * The promise rejects if the `Mono` signals an error.\n     *\n     * @returns A `Promise<T | null>` that resolves when the `Mono` terminates.\n     */\n    public toPromise(): Promise<T | null> {\n        return new Promise<T | null>((resolve, reject) => {\n            let value: T | null = null;\n            const sub = this.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) { value = v; },\n                onError(e) { reject(e); },\n                onComplete() { resolve(value); }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n}\n","import {Sink} from \"@/sinks/Sink\";\nimport {Flux, Publisher} from \"@/publishers\";\nimport {Subscriber, Subscription} from \"@/subscriptions\";\n\n// Rule 1.1: demand tracked per subscriber — onNext only sent when demand >= 1\ntype Entry = { demand: number; cancelled: boolean; completionQueued: boolean };\n\nexport default class OneSink<T> implements Sink<T>, Publisher<T> {\n    private pendingValue: { value: T } | null = null;\n    private completed: boolean = false;\n    private terminalError: Error | null = null;\n    private readonly entries = new Map<Subscriber<T>, Entry>();\n\n    private get terminated(): boolean {\n        return this.completed || this.terminalError !== null;\n    }\n\n    next(value: T): void {\n        if (this.terminated || this.pendingValue !== null) return;\n        this.pendingValue = { value };\n    }\n\n    error(error: Error): void {\n        if (this.terminated) return;\n        this.terminalError = error;\n        for (const [s, e] of this.entries) {\n            if (!e.cancelled) s.onError(error);\n        }\n        this.entries.clear();\n    }\n\n    complete(): void {\n        if (this.terminated) return;\n        this.completed = true;\n        for (const [s, entry] of this.entries) {\n            if (entry.cancelled) continue;\n            if (this.pendingValue === null) {\n                s.onComplete();\n                this.entries.delete(s);\n            } else if (entry.demand >= 1) {\n                entry.demand--;\n                s.onNext(this.pendingValue.value);\n                if (!entry.cancelled) s.onComplete();\n                this.entries.delete(s);\n            } else {\n                // No demand yet — defer delivery until request(n)\n                entry.completionQueued = true;\n            }\n        }\n    }\n\n    asFlux(): Flux<T> {\n        return Flux.from(this);\n    }\n\n    subscribe(subscriber: Subscriber<T>): Subscription {\n        if (this.terminalError) {\n            const sub = { request() {}, unsubscribe() {} };\n            subscriber.onSubscribe(sub);\n            subscriber.onError(this.terminalError);\n            return sub;\n        }\n\n        const entry: Entry = { demand: 0, cancelled: false, completionQueued: this.completed };\n        this.entries.set(subscriber, entry);\n\n        // Already completed with no value — signal immediately\n        if (this.completed && this.pendingValue === null) {\n            this.entries.delete(subscriber);\n            const sub = { request() {}, unsubscribe() {} };\n            subscriber.onSubscribe(sub);\n            subscriber.onComplete();\n            return sub;\n        }\n\n        const sub = {\n            request: (n: number) => {\n                if (entry.cancelled) return;\n                // Rule 3.9: request(n ≤ 0) MUST signal onError\n                if (n <= 0) {\n                    entry.cancelled = true;\n                    this.entries.delete(subscriber);\n                    subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                    return;\n                }\n                entry.demand = Math.min(entry.demand + n, Number.MAX_SAFE_INTEGER);\n                // Deliver queued value now that demand is available\n                if (entry.completionQueued && this.pendingValue !== null && entry.demand >= 1) {\n                    entry.demand--;\n                    entry.cancelled = true;\n                    this.entries.delete(subscriber);\n                    subscriber.onNext(this.pendingValue.value);\n                    subscriber.onComplete();\n                }\n            },\n            unsubscribe: () => {\n                entry.cancelled = true;\n                this.entries.delete(subscriber);\n            }\n        };\n        subscriber.onSubscribe(sub);\n        return sub;\n    }\n}\n","import {Sink} from \"@/sinks/Sink\";\nimport {Flux, Publisher} from \"@/publishers\";\nimport {Subscriber, Subscription} from \"@/subscriptions\";\n\ntype Terminal = { kind: 'completed' } | { kind: 'error'; error: Error };\n\nexport default class EmptySink<T> implements Sink<T>, Publisher<T> {\n    private terminal: Terminal | null = null;\n    private readonly subscribers = new Set<Subscriber<T>>();\n\n    next(_value: T): void {}\n\n    error(error: Error): void {\n        if (this.terminal) return;\n        this.terminal = { kind: 'error', error };\n        for (const s of this.subscribers) s.onError(error);\n        this.subscribers.clear();\n    }\n\n    complete(): void {\n        if (this.terminal) return;\n        this.terminal = { kind: 'completed' };\n        for (const s of this.subscribers) s.onComplete();\n        this.subscribers.clear();\n    }\n\n    asFlux(): Flux<T> {\n        return Flux.from(this);\n    }\n\n    subscribe(subscriber: Subscriber<T>): Subscription {\n        if (this.terminal) {\n            const sub = { request() {}, unsubscribe() {} };\n            subscriber.onSubscribe(sub);\n            this.terminal.kind === 'completed'\n                ? subscriber.onComplete()\n                : subscriber.onError(this.terminal.error);\n            return sub;\n        }\n        this.subscribers.add(subscriber);\n        const sub = {\n            // Rule 3.9: request(n ≤ 0) MUST signal onError\n            request: (n: number) => {\n                if (!this.subscribers.has(subscriber)) return;\n                if (n <= 0) {\n                    this.subscribers.delete(subscriber);\n                    subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                }\n            },\n            unsubscribe: () => { this.subscribers.delete(subscriber); }\n        };\n        subscriber.onSubscribe(sub);\n        return sub;\n    }\n}\n","import {Sink} from \"@/sinks/Sink\";\nimport {Flux, Publisher} from \"@/publishers\";\nimport {Subscriber, Subscription} from \"@/subscriptions\";\n\n/**\n * Base class for unicast sinks (one producer → at most one subscriber).\n *\n * Handles the common subscribe() boilerplate:\n *  - Reject a second subscriber with a descriptive error\n *  - Replay terminal signal immediately if already terminated\n *  - Build the Subscription with Rule 3.9 enforcement and demand accumulation\n *\n * Hooks (all no-ops by default, override as needed):\n *  - `shouldReplayTerminalOnSubscribe()` — override to false for buffer-based sinks\n *    that can accept a subscriber after termination and deliver buffered items first\n *  - `onDemandGranted()`  — called after demand is accumulated (e.g. drain)\n *  - `onUnsubscribed()`   — extra cleanup on cancel (e.g. clear buffer)\n *  - `afterSubscribed()`  — called after subscriber.onSubscribe() (e.g. initial drain)\n *  - `onTerminal()`       — how to deliver terminal signal (default: direct; override for drain)\n */\nexport abstract class AbstractUnicastSink<T> implements Sink<T>, Publisher<T> {\n\n    protected subscriber: Subscriber<T> | null = null;\n    protected demand = 0;\n    protected cancelled = false;\n    protected terminated = false;\n    protected terminalError: Error | null = null;\n\n    abstract next(value: T): void;\n\n    asFlux(): Flux<T> {\n        return Flux.from(this);\n    }\n\n    // ──── Hooks ──────────────────────────────────────────────────────────────\n\n    /** True → replay terminal immediately for late subscribers. */\n    protected shouldReplayTerminalOnSubscribe(): boolean {\n        return this.terminated;\n    }\n\n    /** Called after demand is accumulated in this.demand. Default: noop. */\n    protected onDemandGranted(): void {}\n\n    /** Called after subscriber is cleared on unsubscribe. Default: noop. */\n    protected onUnsubscribed(): void {}\n\n    /** Called after subscriber.onSubscribe(sub). Default: noop. */\n    protected afterSubscribed(): void {}\n\n    /**\n     * How to deliver the terminal signal. Called by both error() and complete().\n     * Default: direct onError / onComplete. Override to use drain() instead.\n     */\n    protected onTerminal(): void {\n        if (this.subscriber && !this.cancelled) {\n            this.terminalError\n                ? this.subscriber.onError(this.terminalError)\n                : this.subscriber.onComplete();\n        }\n    }\n\n    // ──── Terminal signal ─────────────────────────────────────────────────────\n\n    error(error: Error): void {\n        if (this.terminated) return;\n        this.terminated = true;\n        this.terminalError = error;\n        this.onTerminal();\n    }\n\n    complete(): void {\n        if (this.terminated) return;\n        this.terminated = true;\n        this.onTerminal();\n    }\n\n    // ──── Subscribe ───────────────────────────────────────────────────────────\n\n    subscribe(subscriber: Subscriber<T>): Subscription {\n        if (this.subscriber !== null) {\n            const noop = { request() {}, unsubscribe() {} };\n            subscriber.onSubscribe(noop);\n            subscriber.onError(new Error(`${this.constructor.name} allows only one subscriber`));\n            return noop;\n        }\n        if (this.shouldReplayTerminalOnSubscribe()) {\n            const sub = { request() {}, unsubscribe() {} };\n            subscriber.onSubscribe(sub);\n            this.terminalError\n                ? subscriber.onError(this.terminalError)\n                : subscriber.onComplete();\n            return sub;\n        }\n\n        this.subscriber = subscriber;\n        const sub = {\n            request: (n: number) => {\n                if (this.cancelled) return;\n                // Rule 3.9: request(n ≤ 0) MUST signal onError\n                if (n <= 0) {\n                    this.cancelled = true;\n                    const s = this.subscriber;\n                    this.subscriber = null;\n                    s?.onError(new Error(`request must be > 0, but was ${n}`));\n                    return;\n                }\n                this.demand = Math.min(this.demand + n, Number.MAX_SAFE_INTEGER);\n                this.onDemandGranted();\n            },\n            unsubscribe: () => {\n                this.cancelled = true;\n                this.subscriber = null;\n                this.onUnsubscribed();\n            }\n        };\n\n        subscriber.onSubscribe(sub);\n        this.afterSubscribed();\n        return sub;\n    }\n}\n","import {AbstractUnicastSink} from \"@/sinks/internal/AbstractUnicastSink\";\n\nexport default class UnicastOnBackpressureBufferSink<T> extends AbstractUnicastSink<T> {\n\n    private readonly buffer: T[] = [];\n    // Rule 3.16: guard against re-entrant drain (onNext → request → drain)\n    private draining = false;\n\n    // ──── AbstractUnicastSink hooks ───────────────────────────────────────────\n\n    /** Allow late subscribers — they receive buffered items then the terminal signal. */\n    protected shouldReplayTerminalOnSubscribe(): boolean {\n        return false;\n    }\n\n    /** Use drain() for both error and complete so buffered items are delivered first. */\n    protected onTerminal(): void {\n        this.drain();\n    }\n\n    protected onDemandGranted(): void {\n        this.drain();\n    }\n\n    protected onUnsubscribed(): void {\n        this.buffer.length = 0;\n    }\n\n    protected afterSubscribed(): void {\n        this.drain();\n    }\n\n    // ──── Sink.next ───────────────────────────────────────────────────────────\n\n    next(value: T): void {\n        if (this.terminated || this.cancelled) return;\n        this.buffer.push(value);\n        this.drain();\n    }\n\n    // ──── Internal drain ──────────────────────────────────────────────────────\n\n    private drain(): void {\n        if (!this.subscriber || this.cancelled || this.draining) return;\n        this.draining = true;\n        try {\n            while (this.demand > 0 && this.buffer.length > 0) {\n                this.demand--;\n                this.subscriber.onNext(this.buffer.shift()!);\n                if (this.cancelled) return;\n            }\n            if (this.buffer.length === 0 && this.terminated) {\n                const s = this.subscriber;\n                this.subscriber = null;\n                this.terminalError ? s.onError(this.terminalError) : s.onComplete();\n            }\n        } finally {\n            this.draining = false;\n        }\n    }\n}\n","import {AbstractUnicastSink} from \"@/sinks/internal/AbstractUnicastSink\";\n\nexport default class UnicastOnBackpressureErrorSink<T> extends AbstractUnicastSink<T> {\n\n    next(value: T): void {\n        if (this.terminated || this.cancelled || !this.subscriber) return;\n        if (this.demand <= 0) {\n            this.error(new Error('UnicastOnBackpressureErrorSink: subscriber cannot keep up with demand'));\n            return;\n        }\n        this.demand--;\n        this.subscriber.onNext(value);\n    }\n}\n","import {AbstractMulticastSink} from \"@/sinks/internal/AbstractMulticastSink\";\n\ntype Entry = { demand: number; cancelled: boolean };\n\nexport default class MulticastDirectAllOrNothingSink<T> extends AbstractMulticastSink<T, Entry> {\n\n    protected createEntry(): Entry {\n        return { demand: 0, cancelled: false };\n    }\n\n    next(value: T): void {\n        if (this.terminated) return;\n        const active = [...this.entries.values()].filter(e => !e.cancelled);\n        if (active.length === 0 || !active.every(e => e.demand > 0)) return;\n        for (const [sub, entry] of this.entries) {\n            if (!entry.cancelled) {\n                entry.demand--;\n                sub.onNext(value);\n            }\n        }\n    }\n}\n","import {AbstractMulticastSink} from \"@/sinks/internal/AbstractMulticastSink\";\nimport {Subscriber} from \"@/subscriptions\";\n\ntype Entry = { demand: number; cancelled: boolean };\n\nexport default class MulticastDirectBestEffortSink<T> extends AbstractMulticastSink<T, Entry> {\n\n    protected createEntry(): Entry {\n        return { demand: 0, cancelled: false };\n    }\n\n    next(value: T): void {\n        if (this.terminated) return;\n        for (const [sub, entry] of this.entries) {\n            if (!entry.cancelled && entry.demand > 0) {\n                entry.demand--;\n                sub.onNext(value);\n            }\n        }\n    }\n}\n","import {AbstractMulticastSink} from \"@/sinks/internal/AbstractMulticastSink\";\nimport {Subscriber} from \"@/subscriptions\";\n\n// Rule 3.16: draining flag per subscriber prevents re-entrant drain (onNext → request → drain)\ntype Entry<T> = { buffer: T[]; demand: number; cancelled: boolean; draining: boolean };\n\nexport default class MulticastOnBackpressureBufferSink<T>\n    extends AbstractMulticastSink<T, Entry<T>> {\n\n    private readonly bufferSize: number;\n    private readonly autoCancel: boolean;\n\n    constructor(bufferSize: number = 256, autoCancel: boolean = true) {\n        super();\n        this.bufferSize = bufferSize;\n        this.autoCancel = autoCancel;\n    }\n\n    // ──── AbstractMulticastSink hooks ─────────────────────────────────────────\n\n    protected createEntry(): Entry<T> {\n        return { buffer: [], demand: 0, cancelled: false, draining: false };\n    }\n\n    /** Drain buffered items for each subscriber instead of completing immediately. */\n    protected deliverComplete(sub: Subscriber<T>, entry: Entry<T>): void {\n        this.drainEntry(sub, entry);\n    }\n\n    /** drainEntry handles its own cleanup — don't clear the map eagerly. */\n    protected clearEntriesAfterComplete(): boolean {\n        return false;\n    }\n\n    protected onDemandGranted(sub: Subscriber<T>, entry: Entry<T>): void {\n        this.drainEntry(sub, entry);\n    }\n\n    protected onUnsubscribed(_sub: Subscriber<T>, _entry: Entry<T>): void {\n        if (this.autoCancel && this.entries.size === 0) this.terminated = true;\n    }\n\n    // ──── Sink.next ───────────────────────────────────────────────────────────\n\n    next(value: T): void {\n        if (this.terminated) return;\n        for (const [sub, entry] of this.entries) {\n            if (entry.cancelled) continue;\n            if (entry.demand > 0) {\n                entry.demand--;\n                sub.onNext(value);\n            } else if (entry.buffer.length < this.bufferSize) {\n                entry.buffer.push(value);\n            } else {\n                entry.cancelled = true;\n                this.entries.delete(sub);\n                sub.onError(new Error('MulticastOnBackpressureBufferSink: buffer overflow'));\n                if (this.autoCancel && this.entries.size === 0) this.terminated = true;\n            }\n        }\n    }\n\n    // ──── Internal drain ──────────────────────────────────────────────────────\n\n    private drainEntry(sub: Subscriber<T>, entry: Entry<T>): void {\n        if (entry.cancelled || entry.draining) return;\n        entry.draining = true;\n        try {\n            while (entry.demand > 0 && entry.buffer.length > 0) {\n                entry.demand--;\n                sub.onNext(entry.buffer.shift()!);\n                if (entry.cancelled) return;\n            }\n            if (entry.buffer.length === 0 && this.terminated) {\n                this.entries.delete(sub);\n                this.terminalError ? sub.onError(this.terminalError) : sub.onComplete();\n            }\n        } finally {\n            entry.draining = false;\n        }\n    }\n}\n","import {AbstractMulticastSink} from \"@/sinks/internal/AbstractMulticastSink\";\nimport {Subscriber} from \"@/subscriptions\";\n\n// Rule 3.16: draining flag prevents re-entrant drain (onNext → request → drain)\ntype Entry<T> = { replay: T[]; demand: number; cancelled: boolean; draining: boolean };\n\n/**\n * Replays the latest `limit` emitted items to each new subscriber.\n * Used for both `Sinks.many().replay().latest(limit)` and `Sinks.many().replay().limit(limit)`.\n */\nexport default class ReplayLatestSink<T> extends AbstractMulticastSink<T, Entry<T>> {\n\n    private readonly limit: number;\n    private readonly history: T[] = [];\n\n    constructor(limit: number) {\n        super();\n        this.limit = limit;\n    }\n\n    // ──── AbstractMulticastSink hooks ─────────────────────────────────────────\n\n    protected createEntry(): Entry<T> {\n        return { replay: [...this.history], demand: 0, cancelled: false, draining: false };\n    }\n\n    protected shouldReplayTerminalOnSubscribe(): boolean {\n        return this.terminated && this.history.length === 0;\n    }\n\n    /** Drain buffered replay queue first, then signal error. */\n    protected deliverError(sub: Subscriber<T>, entry: Entry<T>): void {\n        this.drainEntry(sub, entry);\n        if (!entry.cancelled) sub.onError(this.terminalError!);\n    }\n\n    /** Drain buffered replay queue — drainEntry signals complete when done. */\n    protected deliverComplete(sub: Subscriber<T>, entry: Entry<T>): void {\n        if (!entry.cancelled) this.drainEntry(sub, entry);\n    }\n\n    protected clearEntriesAfterComplete(): boolean {\n        return false;\n    }\n\n    protected onDemandGranted(sub: Subscriber<T>, entry: Entry<T>): void {\n        this.drainEntry(sub, entry);\n    }\n\n    // ──── Sink.next ───────────────────────────────────────────────────────────\n\n    next(value: T): void {\n        if (this.terminated) return;\n        this.history.push(value);\n        if (this.history.length > this.limit) this.history.shift();\n        for (const [sub, entry] of this.entries) {\n            if (!entry.cancelled) {\n                entry.replay.push(value);\n                this.drainEntry(sub, entry);\n            }\n        }\n    }\n\n    // ──── Internal drain ──────────────────────────────────────────────────────\n\n    private drainEntry(sub: Subscriber<T>, entry: Entry<T>): void {\n        if (entry.cancelled || entry.draining) return;\n        entry.draining = true;\n        try {\n            while (entry.demand > 0 && entry.replay.length > 0) {\n                entry.demand--;\n                sub.onNext(entry.replay.shift()!);\n                if (entry.cancelled) return;\n            }\n            if (entry.replay.length === 0 && this.terminated) {\n                this.entries.delete(sub);\n                this.terminalError ? sub.onError(this.terminalError) : sub.onComplete();\n            }\n        } finally {\n            entry.draining = false;\n        }\n    }\n}\n","import {AbstractMulticastSink} from \"@/sinks/internal/AbstractMulticastSink\";\nimport {Subscriber} from \"@/subscriptions\";\n\n// Rule 3.16: draining flag prevents re-entrant drain (onNext → request → drain)\ntype Entry<T> = { pending: T; hasPending: boolean; demand: number; cancelled: boolean; draining: boolean };\n\n/**\n * Replays the latest emitted item to new subscribers, or the default value if no item was emitted yet.\n */\nexport default class ReplayLatestOrDefaultSink<T> extends AbstractMulticastSink<T, Entry<T>> {\n\n    private latestValue: T;\n\n    constructor(defaultValue: T) {\n        super();\n        this.latestValue = defaultValue;\n    }\n\n    // ──── AbstractMulticastSink hooks ─────────────────────────────────────────\n\n    protected createEntry(): Entry<T> {\n        return { pending: this.latestValue, hasPending: true, demand: 0, cancelled: false, draining: false };\n    }\n\n    /**\n     * Only replay an error terminal immediately. If completed, allow subscription\n     * so the subscriber can still receive the latest value.\n     */\n    protected shouldReplayTerminalOnSubscribe(): boolean {\n        return this.terminated && this.terminalError !== null;\n    }\n\n    /** Drain pending value first, then signal error. */\n    protected deliverError(sub: Subscriber<T>, entry: Entry<T>): void {\n        this.drainEntry(sub, entry);\n        if (!entry.cancelled) sub.onError(this.terminalError!);\n    }\n\n    /** Drain pending value — drainEntry signals complete when done. */\n    protected deliverComplete(sub: Subscriber<T>, entry: Entry<T>): void {\n        if (!entry.cancelled) this.drainEntry(sub, entry);\n    }\n\n    protected clearEntriesAfterComplete(): boolean {\n        return false;\n    }\n\n    protected onDemandGranted(sub: Subscriber<T>, entry: Entry<T>): void {\n        this.drainEntry(sub, entry);\n    }\n\n    // ──── Sink.next ───────────────────────────────────────────────────────────\n\n    next(value: T): void {\n        if (this.terminated) return;\n        this.latestValue = value;\n        for (const [sub, entry] of this.entries) {\n            if (!entry.cancelled) {\n                entry.pending = value;\n                entry.hasPending = true;\n                this.drainEntry(sub, entry);\n            }\n        }\n    }\n\n    // ──── Internal drain ──────────────────────────────────────────────────────\n\n    private drainEntry(sub: Subscriber<T>, entry: Entry<T>): void {\n        if (entry.cancelled || entry.draining) return;\n        entry.draining = true;\n        try {\n            if (entry.hasPending && entry.demand > 0) {\n                entry.demand--;\n                entry.hasPending = false;\n                sub.onNext(entry.pending);\n                if (entry.cancelled) return;\n            }\n            if (!entry.hasPending && this.terminated) {\n                this.entries.delete(sub);\n                this.terminalError ? sub.onError(this.terminalError) : sub.onComplete();\n            }\n        } finally {\n            entry.draining = false;\n        }\n    }\n}\n","import {Flux, Publisher} from \"@/publishers\";\nimport {Sink} from \"@/sinks/Sink\";\nimport OneSink from \"@/sinks/OneSink\";\nimport EmptySink from \"@/sinks/EmptySink\";\nimport UnicastOnBackpressureBufferSink from \"@/sinks/UnicastOnBackpressureBufferSink\";\nimport UnicastOnBackpressureErrorSink from \"@/sinks/UnicastOnBackpressureErrorSink\";\nimport MulticastDirectAllOrNothingSink from \"@/sinks/MulticastDirectAllOrNothingSink\";\nimport MulticastDirectBestEffortSink from \"@/sinks/MulticastDirectBestEffortSink\";\nimport MulticastOnBackpressureBufferSink from \"@/sinks/MulticastOnBackpressureBufferSink\";\nimport ReplayAllSink from \"@/sinks/ReplayAllSink\";\nimport ReplayLatestSink from \"@/sinks/ReplayLatestSink\";\nimport ReplayLatestOrDefaultSink from \"@/sinks/ReplayLatestOrDefaultSink\";\n\n/**\n * A {@link Sink} that is also a {@link Publisher}, with a convenience `asFlux()` accessor.\n * Callers can push values via the `Sink` interface, subscribe via the `Publisher` interface,\n * or obtain a full-featured {@link Flux} view via `asFlux()`.\n */\nexport type SinkPublisher<T> = Sink<T> & Publisher<T> & { asFlux(): Flux<T> };\n\nexport {type Sink};\n\n/**\n * Factory namespace for creating hot or replayable sink/publisher pairs.\n *\n * Each factory returns a {@link SinkPublisher} that implements both {@link Sink} (for pushing values)\n * and {@link Publisher} (for subscribing).\n *\n * @example\n * ```typescript\n * const sink = Sinks.many().multicast().directBestEffort<number>();\n * const flux = Flux.from(sink);\n * flux.subscribe(v => console.log(v));\n * sink.next(1);\n * sink.next(2);\n * sink.complete();\n * ```\n */\nexport const Sinks = {\n    /**\n     * A sink that immediately completes any subscriber without emitting values.\n     * Equivalent to `Flux.empty()` but hot/shared.\n     */\n    empty: <T>(): SinkPublisher<T> => new EmptySink(),\n\n    /**\n     * A sink for exactly one value. Replays that value (and subsequent completion) to all subscribers.\n     * Use for single-result async operations.\n     */\n    one: <T>(): SinkPublisher<T> => new OneSink(),\n\n    /** Creates a multi-subscriber sink factory. */\n    many: () => ({\n        /** Creates multicast (fan-out) sinks that deliver to all current subscribers. */\n        multicast: () => ({\n            /**\n             * Delivers each item to all current subscribers simultaneously.\n             * If any subscriber cannot accept the item (due to backpressure), **none** of them receive it.\n             */\n            directAllOrNothing: <T>(): SinkPublisher<T> =>\n                new MulticastDirectAllOrNothingSink(),\n\n            /**\n             * Delivers each item to all current subscribers on a best-effort basis.\n             * Subscribers that are not ready (backpressure) are skipped for that item.\n             */\n            directBestEffort: <T>(): SinkPublisher<T> =>\n                new MulticastDirectBestEffortSink(),\n\n            /**\n             * Buffers items and delivers them to all subscribers respecting backpressure.\n             *\n             * @param bufferSize - Maximum number of items to buffer (default: `256`).\n             * @param autoCancel - If `true`, cancels the sink when all subscribers unsubscribe (default: `true`).\n             */\n            onBackpressureBuffer: <T>(bufferSize: number = 256, autoCancel: boolean = true): SinkPublisher<T> =>\n                new MulticastOnBackpressureBufferSink(bufferSize, autoCancel),\n        }),\n\n        /** Creates unicast (single-subscriber) sinks. */\n        unicast: () => ({\n            /**\n             * Unicast sink that buffers items until the single subscriber requests them.\n             * A second `subscribe()` call throws.\n             */\n            onBackpressureBuffer: <T>(): SinkPublisher<T> =>\n                new UnicastOnBackpressureBufferSink(),\n\n            /**\n             * Unicast sink that errors if an item is pushed when the subscriber has no outstanding demand.\n             * A second `subscribe()` call throws.\n             */\n            onBackpressureError: <T>(): SinkPublisher<T> =>\n                new UnicastOnBackpressureErrorSink(),\n        }),\n\n        /** Creates replay sinks that buffer past items for late subscribers. */\n        replay: () => ({\n            /**\n             * Replays **all** previously emitted items to each new subscriber.\n             * Items are accumulated indefinitely.\n             */\n            all: <T>(): SinkPublisher<T> =>\n                new ReplayAllSink(),\n\n            /**\n             * Replays the most recent `limit` items to each new subscriber.\n             *\n             * @param limit - Maximum number of items to replay.\n             */\n            latest: <T>(limit: number): SinkPublisher<T> =>\n                new ReplayLatestSink(limit),\n\n            /**\n             * Replays the most recent item (or `value` if nothing has been emitted yet) to each new subscriber.\n             *\n             * @param value - Default value replayed until the first `next()` call.\n             */\n            latestOrDefault: <T>(value: T): SinkPublisher<T> =>\n                new ReplayLatestOrDefaultSink(value),\n\n            /**\n             * Alias for {@link latest}. Replays the most recent `limit` items.\n             *\n             * @param limit - Maximum number of items to replay.\n             */\n            limit: <T>(limit: number): SinkPublisher<T> =>\n                new ReplayLatestSink(limit),\n        }),\n    }),\n}\n"],"mappings":"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","names":["index_exports","__export","Flux","Mono","Schedulers","Signal","Sinks","__toCommonJS","AbstractMulticastSink","Flux","_sub","_entry","sub","entry","error","subscriber","n","ReplayAllSink","AbstractMulticastSink","sub","entry","value","Signal","value","error","AbstractPipePublisher","source","subscriberOrOnNext","onError","onComplete","onNext","demand","s","e","alternative","subscriber","primarySub","altSub","hasValue","cancelled","operatorSub","n","sourceSub","v","altSourceSub","replacement","_e","predicate","sub","_s","fn","first","scheduler","alt","fnErr","e2","ms","fallback","sourceDone","terminated","timer","clearTimer","startTimer","proxy","timerId","originalUnsub","label","tag","wrappedSub","Signal","pending","ImmediateScheduler","task","MicroScheduler","task","MacroScheduler","task","DelayScheduler","delay","task","id","IntervalScheduler","delay","task","id","Schedulers","ImmediateScheduler","MicroScheduler","MacroScheduler","ms","DelayScheduler","IntervalScheduler","Flux","_Flux","AbstractPipePublisher","source","publisher","generator","subscriber","buffer","demand","terminated","terminalDelivered","terminalError","cancelled","draining","drain","sink","v","err","subscription","n","e","iterable","item","start","count","i","sub","factory","items","error","emitter","requestCbs","cancelCbs","disposeCbs","fireDispose","fn","value","resourceSupplier","sourceFactory","cleanup","resource","sources","doneCount","subs","terminate","s","operatorSub","inner","won","finished","lastError","idx","j","ms","counter","id","combiner","queues","completed","tryEmit","q","args","result","done","pending","latest","hasValue","flush","_s","sourceSub","r","handler","emitted","sinkWrapper","outerSub","innerSubs","outerDone","innerSub","generation","myGen","predicate","pass","trigger","triggerSub","_v","maxRetries","currentSub","retries","attempt","reducer","acc","hasAcc","seedFactory","other","leftQueue","rightQueue","leftDone","rightDone","leftSub","rightSub","l","producer","onRequest","onUnsubscribe","Mono","last","index","defaultValue","_force","comparator","arr","maxSize","batch","ReplayAllSink","connected","entries","upstreamSub","connect","entry","skipped","skipping","gating","primarySub","seen","a","b","prev","first","sourceCompleted","wasZero","Schedulers","otherSub","otherSourceSub","otherSubRef","errBuf","errSub","errDemand","pushErr","drainErrs","errorFlux","relay","compBuf","compSub","compDemand","drainingComps","drainComps","pushComp","completeFlux","keyFn","groups","_n","key","g","timer","toEmit","resetTimer","val","triggerFn","_r","active","sourceDone","children","lastTime","now","Signal","signal","onDrop","hasLatest","prefetch","replenish","consumed","requestMore","toRequest","constructor","Mono","_Mono","AbstractPipePublisher","source","generator","subscriber","cancelled","demanded","terminated","pending","pendingError","tryDeliver","v","e","sink","err","subscription","n","publisher","value","sub","error","promise","factory","ms","id","fn","sources","done","completedCount","subs","_s","s","_v","result","outerSub","innerSub","demand","operatorSub","sourceSub","inner","r","predicate","pred","innerDone","passes","producer","onRequest","onUnsubscribe","mapper","Flux","other","left","right","leftDone","rightDone","failed","fail","leftSub","rightSub","tryEmit","timerId","proxy","triggerFn","trigger","triggered","_u","emitted","currentSub","controlSub","errorRelay","relaySubscriber","_n","control","controlSubscriber","attempt","controlSub2","resolve","reject","OneSink","value","error","s","e","entry","Flux","subscriber","sub","n","EmptySink","_value","error","s","Flux","subscriber","sub","n","AbstractUnicastSink","Flux","error","subscriber","noop","sub","n","s","UnicastOnBackpressureBufferSink","AbstractUnicastSink","value","s","UnicastOnBackpressureErrorSink","AbstractUnicastSink","value","MulticastDirectAllOrNothingSink","AbstractMulticastSink","value","active","e","sub","entry","MulticastDirectBestEffortSink","AbstractMulticastSink","value","sub","entry","MulticastOnBackpressureBufferSink","AbstractMulticastSink","bufferSize","autoCancel","sub","entry","_sub","_entry","value","ReplayLatestSink","AbstractMulticastSink","limit","sub","entry","value","ReplayLatestOrDefaultSink","AbstractMulticastSink","defaultValue","sub","entry","value","Sinks","EmptySink","OneSink","MulticastDirectAllOrNothingSink","MulticastDirectBestEffortSink","bufferSize","autoCancel","MulticastOnBackpressureBufferSink","UnicastOnBackpressureBufferSink","UnicastOnBackpressureErrorSink","ReplayAllSink","limit","ReplayLatestSink","value","ReplayLatestOrDefaultSink"]}
+{"version":3,"sources":["../src/index.ts","../src/sinks/internal/AbstractMulticastSink.ts","../src/sinks/ReplayAllSink.ts","../src/publishers/Signal.ts","../src/publishers/internal/AbstractPipePublisher.ts","../src/schedulers/ImmediateScheduler.ts","../src/schedulers/MicroScheduler.ts","../src/schedulers/MacroScheduler.ts","../src/schedulers/DelayScheduler.ts","../src/schedulers/IntervalScheduler.ts","../src/schedulers/index.ts","../src/publishers/Flux.ts","../src/publishers/Mono.ts","../src/sinks/OneSink.ts","../src/sinks/EmptySink.ts","../src/sinks/internal/AbstractUnicastSink.ts","../src/sinks/UnicastOnBackpressureBufferSink.ts","../src/sinks/UnicastOnBackpressureErrorSink.ts","../src/sinks/MulticastDirectAllOrNothingSink.ts","../src/sinks/MulticastDirectBestEffortSink.ts","../src/sinks/MulticastOnBackpressureBufferSink.ts","../src/sinks/ReplayLatestSink.ts","../src/sinks/ReplayLatestOrDefaultSink.ts","../src/sinks/index.ts"],"sourcesContent":["export * from '@/publishers'\nexport * from '@/schedulers'\nexport * from '@/sinks'\nexport * from '@/subscriptions'","import {Sink} from \"@/sinks/Sink\";\nimport {Flux, Publisher} from \"@/publishers\";\nimport {Subscriber, Subscription} from \"@/subscriptions\";\n\n/**\n * Base class for all multicast sinks (one-to-many, Map-based subscriber tracking).\n *\n * Subclasses provide:\n *  - `createEntry()` — constructs a fresh per-subscriber state object\n *  - `next(value)`   — emission logic (differs per delivery strategy)\n *\n * Hooks (all no-ops by default, override as needed):\n *  - `shouldReplayTerminalOnSubscribe()` — when to replay terminal immediately on subscribe\n *  - `onDemandGranted(sub, entry)`       — called after demand is accumulated (e.g. drain)\n *  - `onUnsubscribed(sub, entry)`        — extra cleanup on cancel (e.g. autoCancel logic)\n *  - `onSubscribed(sub, entry)`          — called after subscriber.onSubscribe() (e.g. initial drain)\n *  - `deliverError(sub, entry)`          — how to signal error to one entry (default: direct)\n *  - `deliverComplete(sub, entry)`       — how to signal complete to one entry (default: direct)\n *  - `clearEntriesAfterComplete()`       — false for drain-based sinks (drainEntry cleans up)\n *\n * E must have at least `{ cancelled: boolean; demand: number }`.\n */\nexport abstract class AbstractMulticastSink<T, E extends { cancelled: boolean; demand: number }>\n    implements Sink<T>, Publisher<T> {\n\n    protected readonly entries = new Map<Subscriber<T>, E>();\n    protected terminated = false;\n    protected terminalError: Error | null = null;\n\n    abstract next(value: T): void;\n    protected abstract createEntry(): E;\n\n    asFlux(): Flux<T> {\n        return Flux.from(this);\n    }\n\n    // ──── Hooks ──────────────────────────────────────────────────────────────\n\n    /** True → replay terminal signal immediately when subscriber joins. */\n    protected shouldReplayTerminalOnSubscribe(): boolean {\n        return this.terminated;\n    }\n\n    /** Called after demand is accumulated in entry.demand. Default: noop. */\n    protected onDemandGranted(_sub: Subscriber<T>, _entry: E): void {}\n\n    /** Called after entry removal on unsubscribe. Default: noop. */\n    protected onUnsubscribed(_sub: Subscriber<T>, _entry: E): void {}\n\n    /** Called after subscriber.onSubscribe(sub). Default: noop. */\n    protected onSubscribed(_sub: Subscriber<T>, _entry: E): void {}\n\n    /** How to deliver error to one entry. Default: direct onError. */\n    protected deliverError(sub: Subscriber<T>, entry: E): void {\n        if (!entry.cancelled) sub.onError(this.terminalError!);\n    }\n\n    /** How to deliver complete to one entry. Default: direct onComplete. */\n    protected deliverComplete(sub: Subscriber<T>, entry: E): void {\n        if (!entry.cancelled) sub.onComplete();\n    }\n\n    /**\n     * Whether to call entries.clear() after iterating in complete().\n     * Override to false for drain-based sinks — drainEntry deletes entries individually.\n     */\n    protected clearEntriesAfterComplete(): boolean {\n        return true;\n    }\n\n    // ──── Terminal signal ─────────────────────────────────────────────────────\n\n    error(error: Error): void {\n        if (this.terminated) return;\n        this.terminated = true;\n        this.terminalError = error;\n        for (const [sub, entry] of this.entries) {\n            this.deliverError(sub, entry);\n        }\n        this.entries.clear();\n    }\n\n    complete(): void {\n        if (this.terminated) return;\n        this.terminated = true;\n        for (const [sub, entry] of this.entries) {\n            this.deliverComplete(sub, entry);\n        }\n        if (this.clearEntriesAfterComplete()) this.entries.clear();\n    }\n\n    // ──── Subscribe ───────────────────────────────────────────────────────────\n\n    subscribe(subscriber: Subscriber<T>): Subscription {\n        if (this.shouldReplayTerminalOnSubscribe()) {\n            const sub = { request() {}, unsubscribe() {} };\n            subscriber.onSubscribe(sub);\n            this.terminalError\n                ? subscriber.onError(this.terminalError)\n                : subscriber.onComplete();\n            return sub;\n        }\n\n        const entry = this.createEntry();\n        this.entries.set(subscriber, entry);\n\n        const sub = {\n            request: (n: number) => {\n                if (entry.cancelled) return;\n                // Rule 3.9: request(n ≤ 0) MUST signal onError\n                if (n <= 0) {\n                    entry.cancelled = true;\n                    this.entries.delete(subscriber);\n                    subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                    return;\n                }\n                entry.demand = Math.min(entry.demand + n, Number.MAX_SAFE_INTEGER);\n                this.onDemandGranted(subscriber, entry);\n            },\n            unsubscribe: () => {\n                entry.cancelled = true;\n                this.entries.delete(subscriber);\n                this.onUnsubscribed(subscriber, entry);\n            }\n        };\n\n        subscriber.onSubscribe(sub);\n        this.onSubscribed(subscriber, entry);\n        return sub;\n    }\n}\n","import {AbstractMulticastSink} from \"@/sinks/internal/AbstractMulticastSink\";\nimport {Subscriber} from \"@/subscriptions\";\n\n// Rule 3.16: draining flag prevents re-entrant drain (onNext → request → drain)\ntype Entry = { position: number; demand: number; cancelled: boolean; draining: boolean };\n\nexport default class ReplayAllSink<T> extends AbstractMulticastSink<T, Entry> {\n\n    private readonly history: T[] = [];\n\n    // ──── AbstractMulticastSink hooks ─────────────────────────────────────────\n\n    protected createEntry(): Entry {\n        return { position: 0, demand: 0, cancelled: false, draining: false };\n    }\n\n    /** Only replay terminal immediately if there's nothing in history to deliver. */\n    protected shouldReplayTerminalOnSubscribe(): boolean {\n        return this.terminated && this.history.length === 0;\n    }\n\n    /** Drain buffered history first, then signal error. */\n    protected deliverError(sub: Subscriber<T>, entry: Entry): void {\n        this.drainEntry(sub, entry);\n        if (!entry.cancelled) sub.onError(this.terminalError!);\n    }\n\n    /** Drain buffered history — drainEntry signals complete when done. */\n    protected deliverComplete(sub: Subscriber<T>, entry: Entry): void {\n        if (!entry.cancelled) this.drainEntry(sub, entry);\n    }\n\n    protected clearEntriesAfterComplete(): boolean {\n        return false;\n    }\n\n    protected onDemandGranted(sub: Subscriber<T>, entry: Entry): void {\n        this.drainEntry(sub, entry);\n    }\n\n    // ──── Sink.next ───────────────────────────────────────────────────────────\n\n    next(value: T): void {\n        if (this.terminated) return;\n        this.history.push(value);\n        for (const [sub, entry] of this.entries) {\n            if (!entry.cancelled) this.drainEntry(sub, entry);\n        }\n    }\n\n    // ──── Internal drain ──────────────────────────────────────────────────────\n\n    private drainEntry(sub: Subscriber<T>, entry: Entry): void {\n        if (entry.cancelled || entry.draining) return;\n        entry.draining = true;\n        try {\n            while (entry.demand > 0 && entry.position < this.history.length) {\n                entry.demand--;\n                sub.onNext(this.history[entry.position++]);\n                if (entry.cancelled) return;\n            }\n            if (entry.position >= this.history.length && this.terminated) {\n                this.entries.delete(sub);\n                this.terminalError ? sub.onError(this.terminalError) : sub.onComplete();\n            }\n        } finally {\n            entry.draining = false;\n        }\n    }\n}\n","/**\n * Represents a reactive signal — one of the three events that can be emitted\n * by a {@link Publisher}: a value (`next`), a terminal error (`error`), or\n * a normal completion (`complete`).\n *\n * `Signal` is the type used by {@link Flux#materialize} /\n * {@link Flux#dematerialize} to pass reactive events as plain data values.\n *\n * @typeParam T - The type of the value carried by a `next` signal.\n */\nexport type Signal<T> =\n    | { readonly kind: 'next'; readonly value: T }\n    | { readonly kind: 'error'; readonly error: Error }\n    | { readonly kind: 'complete' };\n\n/**\n * Namespace of factory helpers for creating {@link Signal} instances.\n */\nexport const Signal = {\n    /**\n     * Creates a `next` signal carrying `value`.\n     * @param value - The item to wrap.\n     */\n    next<T>(value: T): Signal<T> { return { kind: 'next', value }; },\n\n    /**\n     * Creates an `error` signal carrying `error`.\n     * @param error - The error to wrap.\n     */\n    error<T>(error: Error): Signal<T> { return { kind: 'error', error }; },\n\n    /**\n     * Creates a `complete` signal.\n     */\n    complete<T>(): Signal<T> { return { kind: 'complete' }; },\n};\n","import {Publisher} from \"@/publishers/Publisher\";\nimport {Subscriber} from \"@/subscriptions/Subscriber\";\nimport {Subscription} from \"@/subscriptions/Subscription\";\nimport {Scheduler} from \"@/schedulers/Scheduler\";\nimport {Signal} from \"@/publishers/Signal\";\n\n/**\n * Base class for Flux and Mono providing the common operator implementations\n * that are identical across both types. Operators that preserve T use the\n * abstract `wrapSource` factory so that subclasses always return their own\n * concrete type (Flux → Flux, Mono → Mono) without any unsafe casts at\n * call-sites.\n *\n * Operators NOT included here (different semantics or change the type):\n *  - filter / filterWhen  — demand-replenishment differs between Flux and Mono\n *  - doFinally            — Flux also fires fn on cancel; Mono does not\n *  - map / flatMap / cast / pipe / mapNotNull — change the type T → R\n */\nexport abstract class AbstractPipePublisher<T, Self> implements Publisher<T> {\n\n    protected constructor(protected readonly source: Publisher<T>) {}\n\n    /**\n     * Default demand issued in the auto-request onSubscribe when using the\n     * convenience subscribe() overloads (no explicit Subscriber provided).\n     * Mono overrides this to 1; Flux overrides it to Number.MAX_SAFE_INTEGER.\n     */\n    protected abstract defaultDemand(): number;\n\n    /**\n     * Subscribe with a full Subscriber (existing contract — full demand control).\n     */\n    subscribe(subscriber: Subscriber<T>): Subscription;\n\n    /**\n     * Convenience overload — any combination of callbacks may be omitted.\n     * An auto-request of `defaultDemand()` is issued on subscribe so items\n     * start flowing immediately without a manual request() call.\n     *\n     * If `onError` is not provided, unhandled errors are re-thrown so they\n     * surface as uncaught exceptions rather than being silently swallowed.\n     *\n     * @example\n     * // Mono — requests 1 automatically\n     * Mono.just(42).subscribe(v => console.log(v));\n     *\n     * // Flux — requests unbounded automatically\n     * Flux.range(0, 5).subscribe(v => console.log(v), err => console.error(err));\n     */\n    subscribe(onNext?: (value: T) => void, onError?: (error: Error) => void, onComplete?: () => void): Subscription;\n\n    subscribe(\n        subscriberOrOnNext?: Subscriber<T> | ((value: T) => void),\n        onError?: (error: Error) => void,\n        onComplete?: () => void,\n    ): Subscription {\n        // Full Subscriber object — delegate unchanged (caller owns demand).\n        if (subscriberOrOnNext !== undefined && typeof subscriberOrOnNext === 'object') {\n            return this.source.subscribe(subscriberOrOnNext);\n        }\n\n        // Convenience path: wrap callbacks in a LambdaSubscriber that auto-requests.\n        const onNext = subscriberOrOnNext as ((value: T) => void) | undefined;\n        const demand = this.defaultDemand();\n        return this.source.subscribe({\n            onSubscribe(s) { s.request(demand); },\n            onNext:     onNext   ?? (() => {}),\n            onError:    onError  ?? ((e) => { throw e; }),\n            onComplete: onComplete ?? (() => {}),\n        });\n    }\n\n    /**\n     * Wraps a publisher in the concrete subclass type.\n     * Called internally by every operator that preserves T.\n     */\n    protected abstract wrapSource(source: Publisher<T>): Self;\n\n    // ──────────────────────── Error handling ────────────────────────────────\n\n    /**\n     * Falls back to `alternative` if this source completes without emitting any items.\n     *\n     * If the source emits at least one item, `alternative` is never subscribed to.\n     * If the source errors, the error is forwarded and `alternative` is not subscribed to.\n     *\n     * @param alternative - Publisher to subscribe to if the source is empty.\n     * @returns A publisher that uses `alternative` when the source is empty.\n     */\n    public switchIfEmpty(alternative: Publisher<T>): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let primarySub: Subscription = { request() {}, unsubscribe() {} };\n                let altSub: Subscription | null = null;\n                let hasValue = false;\n                let cancelled = false;\n                let demand = 0;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (altSub) altSub.request(n); else primarySub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; primarySub.unsubscribe(); altSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(sourceSub: Subscription) {\n                        primarySub = sourceSub;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v) { hasValue = true; subscriber.onNext(v); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() {\n                        if (hasValue || cancelled) { subscriber.onComplete(); return; }\n                        altSub = alternative.subscribe({\n                            onSubscribe(altSourceSub: Subscription) {\n                                altSub = altSourceSub;\n                                if (demand > 0) altSub.request(demand);\n                            },\n                            onNext(v) { subscriber.onNext(v); },\n                            onError(e) { subscriber.onError(e); },\n                            onComplete() { subscriber.onComplete(); }\n                        });\n                    }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Substitutes the error signal with items from `replacement`.\n     *\n     * When the source signals `onError`, `replacement` is subscribed to and its items are\n     * forwarded downstream as if they came from the original source.\n     * If `replacement` itself errors, that error is forwarded.\n     *\n     * @param replacement - Publisher whose items replace the error.\n     * @returns A publisher that recovers from errors by switching to `replacement`.\n     */\n    public onErrorReturn(replacement: Publisher<T>): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let primarySub: Subscription = { request() {}, unsubscribe() {} };\n                let altSub: Subscription | null = null;\n                let cancelled = false;\n                let demand = 0;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (altSub) altSub.request(n); else primarySub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; primarySub.unsubscribe(); altSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(sourceSub: Subscription) {\n                        primarySub = sourceSub;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(_e) {\n                        if (cancelled) return;\n                        altSub = replacement.subscribe({\n                            onSubscribe(altSourceSub: Subscription) {\n                                altSub = altSourceSub;\n                                if (demand > 0) altSub.request(demand);\n                            },\n                            onNext(v) { subscriber.onNext(v); },\n                            onError(e) { subscriber.onError(e); },\n                            onComplete() { subscriber.onComplete(); }\n                        });\n                    },\n                    onComplete() { subscriber.onComplete(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Handles errors selectively: if `predicate(error)` returns `true`, the error is\n     * swallowed and the stream completes normally; otherwise the error is forwarded.\n     *\n     * @param predicate - Receives the error and returns `true` to suppress it.\n     * @returns A publisher that converts matching errors into normal completions.\n     */\n    public onErrorContinue(predicate: (error: Error) => boolean): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) {\n                        if (predicate(e)) subscriber.onComplete();\n                        else subscriber.onError(e);\n                    },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    // ──────────────────────── Side effects ──────────────────────────────────\n\n    /**\n     * Executes a side-effect `fn` on the **first** item emitted by the source.\n     *\n     * Subsequent items pass through unchanged. Any exception thrown by `fn` is silently swallowed.\n     *\n     * @param fn - Side-effect to run on the very first item.\n     * @returns A publisher with the side effect attached to the first item.\n     */\n    public doFirst(fn: () => void): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let first = true;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        if (first) { first = false; try { fn(); } catch (_) {} }\n                        subscriber.onNext(v);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Executes a side-effect `fn` for every item emitted by the source, before\n     * forwarding the item downstream.\n     *\n     * Any exception thrown by `fn` is silently swallowed; the item is still forwarded.\n     *\n     * @param fn - Side-effect called for each item.\n     * @returns A publisher with the side effect attached to each item.\n     */\n    public doOnNext(fn: (value: T) => void): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { try { fn(v); } catch (_) {} subscriber.onNext(v); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Executes a side-effect `fn` when the source signals an error, before\n     * forwarding the error downstream.\n     *\n     * Any exception thrown by `fn` is silently swallowed; the original error is still forwarded.\n     *\n     * @param fn - Side-effect called with the error.\n     * @returns A publisher with the side effect attached to the error signal.\n     */\n    public doOnError(fn: (error: Error) => void): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) { try { fn(e); } catch (_) {} subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Executes a side-effect `fn` when the source calls `onSubscribe`, passing the\n     * resulting {@link Subscription} to the callback.\n     *\n     * Any exception thrown by `fn` is silently swallowed.\n     *\n     * @param fn - Side-effect called with the subscription object.\n     * @returns A publisher with the side effect attached to the subscribe event.\n     */\n    public doOnSubscribe(fn: (subscription: Subscription) => void): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                try { fn(sub); } catch (_) {}\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    // ──────────────────────── Scheduling ────────────────────────────────────\n\n    /**\n     * Shifts item delivery to the given `scheduler`.\n     *\n     * Each `onNext`, `onError`, and `onComplete` callback is scheduled on `scheduler`\n     * instead of being called inline. The source is still subscribed to on the\n     * calling thread; only the *delivery* of signals is redirected.\n     *\n     * @param scheduler - The scheduler on which downstream signals are delivered.\n     * @returns A publisher that delivers signals on the given scheduler.\n     */\n    public publishOn(scheduler: Scheduler): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { scheduler.schedule(() => subscriber.onNext(v)); },\n                    onError(e) { scheduler.schedule(() => subscriber.onError(e)); },\n                    onComplete() { scheduler.schedule(() => subscriber.onComplete()); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    // ──────────────────────── Error recovery ────────────────────────────────\n\n    /**\n     * Falls back to a publisher produced by `fn` when the source signals an error.\n     *\n     * Unlike {@link onErrorReturn} (which takes a static replacement), this operator\n     * calls `fn` with the actual error, allowing dynamic recovery based on the error type.\n     *\n     * @param fn - Called with the error; returns the replacement publisher.\n     * @returns A publisher that recovers from errors dynamically.\n     *\n     * @example\n     * ```typescript\n     * Flux.error(new Error('not found'))\n     *   .onErrorResume(e => e.message === 'not found' ? Flux.just('default') : Flux.error(e))\n     *   .subscribe(v => console.log(v)); // 'default'\n     * ```\n     */\n    public onErrorResume(fn: (error: Error) => Publisher<T>): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let primarySub: Subscription = { request() {}, unsubscribe() {} };\n                let altSub: Subscription | null = null;\n                let cancelled = false;\n                let demand = 0;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (altSub) altSub.request(n); else primarySub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; primarySub.unsubscribe(); altSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) { primarySub = s; subscriber.onSubscribe(operatorSub); },\n                    onNext(v: T) { subscriber.onNext(v); },\n                    onError(e: Error) {\n                        if (cancelled) return;\n                        let alt: Publisher<T>;\n                        try { alt = fn(e); }\n                        catch (fnErr) { subscriber.onError(fnErr instanceof Error ? fnErr : new Error(String(fnErr))); return; }\n                        altSub = alt.subscribe({\n                            onSubscribe(s: Subscription) { altSub = s; if (demand > 0) s.request(demand); },\n                            onNext(v: T) { subscriber.onNext(v); },\n                            onError(e2: Error) { subscriber.onError(e2); },\n                            onComplete() { subscriber.onComplete(); }\n                        });\n                    },\n                    onComplete() { subscriber.onComplete(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Transforms the error signal using `fn` before forwarding it downstream.\n     *\n     * Useful for converting low-level errors into domain-specific error types.\n     *\n     * @param fn - Receives the original error and returns a replacement error.\n     * @returns A publisher that transforms errors before propagating them.\n     *\n     * @example\n     * ```typescript\n     * Flux.error(new Error('HTTP 404'))\n     *   .onErrorMap(e => new Error(`NotFound: ${e.message}`))\n     *   .subscribe(null, e => console.error(e.message)); // NotFound: HTTP 404\n     * ```\n     */\n    public onErrorMap(fn: (error: Error) => Error): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v: T) { subscriber.onNext(v); },\n                    onError(e: Error) {\n                        try { subscriber.onError(fn(e)); }\n                        catch (fnErr) { subscriber.onError(fnErr instanceof Error ? fnErr : new Error(String(fnErr))); }\n                    },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    // ──────────────────────── Timing ────────────────────────────────────────\n\n    /**\n     * Emits a `TimeoutError` (or switches to `fallback`) if no item is received\n     * within `ms` milliseconds of the previous item (or of subscription).\n     *\n     * The timer resets on each received item, so it measures **inter-item** idle time.\n     *\n     * @param ms - Timeout duration in milliseconds.\n     * @param fallback - Optional publisher to switch to on timeout instead of erroring.\n     * @returns A publisher that errors or falls back when no item arrives in time.\n     *\n     * @example\n     * ```typescript\n     * Flux.never<number>()\n     *   .timeout(100)\n     *   .subscribe(null, e => console.error(e.message)); // TimeoutError after 100ms\n     * ```\n     */\n    public timeout(ms: number, fallback?: Publisher<T>): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let sourceSub: Subscription = { request() {}, unsubscribe() {} };\n                let altSub: Subscription | null = null;\n                let cancelled = false;\n                let sourceDone = false;\n                let terminated = false;\n                let demand = 0;\n                let timer: ReturnType<typeof setTimeout> | null = null;\n\n                const clearTimer = () => { if (timer !== null) { clearTimeout(timer); timer = null; } };\n\n                const startTimer = () => {\n                    clearTimer();\n                    timer = setTimeout(() => {\n                        if (cancelled || terminated) return;\n                        sourceDone = true;\n                        sourceSub.unsubscribe();\n                        if (fallback) {\n                            altSub = fallback.subscribe({\n                                onSubscribe(s: Subscription) { altSub = s; if (demand > 0) s.request(demand); },\n                                onNext(v: T) { if (!cancelled && !terminated) subscriber.onNext(v); },\n                                onError(e: Error) { if (!cancelled && !terminated) { terminated = true; subscriber.onError(e); } },\n                                onComplete() { if (!cancelled && !terminated) { terminated = true; subscriber.onComplete(); } }\n                            });\n                        } else {\n                            terminated = true;\n                            subscriber.onError(new Error(`TimeoutError: no item within ${ms}ms`));\n                        }\n                    }, ms);\n                };\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (altSub) altSub.request(n); else sourceSub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; clearTimer(); sourceSub.unsubscribe(); altSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) { sourceSub = s; subscriber.onSubscribe(operatorSub); startTimer(); },\n                    onNext(v: T) {\n                        if (cancelled || sourceDone) return;\n                        startTimer();\n                        subscriber.onNext(v);\n                    },\n                    onError(e: Error) {\n                        clearTimer();\n                        if (!cancelled && !terminated) { terminated = true; subscriber.onError(e); }\n                    },\n                    onComplete() {\n                        clearTimer();\n                        if (!cancelled && !terminated) { terminated = true; subscriber.onComplete(); }\n                    }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Delays the subscription to the upstream source by `ms` milliseconds.\n     *\n     * `onSubscribe` is delivered immediately with a proxy `Subscription`.\n     * Any `request(n)` calls before the delay elapses are accumulated and\n     * forwarded once the actual subscription starts.\n     *\n     * @param ms - Delay in milliseconds before subscribing to the source.\n     * @returns A publisher whose upstream subscription is deferred.\n     */\n    public delaySubscription(ms: number): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let sourceSub: Subscription | null = null;\n                let cancelled = false;\n                let demand = 0;\n\n                const proxy: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (sourceSub) sourceSub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; sourceSub?.unsubscribe(); }\n                };\n\n                subscriber.onSubscribe(proxy);\n\n                const timerId = setTimeout(() => {\n                    if (cancelled) return;\n                    this.source.subscribe({\n                        onSubscribe(s: Subscription) {\n                            sourceSub = s;\n                            if (demand > 0) s.request(demand);\n                        },\n                        onNext(v: T) { if (!cancelled) subscriber.onNext(v); },\n                        onError(e: Error) { if (!cancelled) subscriber.onError(e); },\n                        onComplete() { if (!cancelled) subscriber.onComplete(); }\n                    });\n                }, ms);\n\n                // Override unsubscribe to also clear the timer\n                const originalUnsub = proxy.unsubscribe.bind(proxy);\n                (proxy as { unsubscribe: () => void }).unsubscribe = () => { clearTimeout(timerId); originalUnsub(); };\n\n                return proxy;\n            }\n        });\n    }\n\n    // ──────────────────────── Observability ─────────────────────────────────\n\n    /**\n     * Logs each reactive signal to the console for debugging.\n     *\n     * Prints `onSubscribe`, `request(n)`, `onNext(value)`, `onError`, `onComplete`,\n     * and `cancel` with an optional label prefix.\n     *\n     * @param label - Optional label prepended to each log line (default: `'reactor'`).\n     * @returns A publisher with logging side effects attached.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2).log('source').subscribe(v => console.log(v));\n     * // [source] onSubscribe\n     * // [source] request(9007199254740991)\n     * // [source] onNext(1)\n     * // ...\n     * ```\n     */\n    public log(label: string = 'reactor'): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const tag = `[${label}]`;\n                let wrappedSub!: Subscription;\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        console.log(`${tag} onSubscribe`);\n                        wrappedSub = {\n                            request(n: number) { console.log(`${tag} request(${n})`); s.request(n); },\n                            unsubscribe() { console.log(`${tag} cancel`); s.unsubscribe(); }\n                        };\n                        subscriber.onSubscribe(wrappedSub);\n                    },\n                    onNext(v: T) { console.log(`${tag} onNext(${JSON.stringify(v)})`); subscriber.onNext(v); },\n                    onError(e: Error) { console.error(`${tag} onError: ${e.message}`); subscriber.onError(e); },\n                    onComplete() { console.log(`${tag} onComplete`); subscriber.onComplete(); }\n                });\n                return wrappedSub;\n            }\n        });\n    }\n\n    /**\n     * Executes a side-effect `fn` whenever the downstream subscriber issues a `request(n)`.\n     *\n     * Useful for debugging backpressure — see exactly how much demand is flowing upstream.\n     * Any exception thrown by `fn` is silently swallowed.\n     *\n     * @param fn - Called with the requested count `n`.\n     * @returns A publisher with the side effect attached to the request signal.\n     */\n    public doOnRequest(fn: (n: number) => void): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v: T) { subscriber.onNext(v); },\n                    onError(e: Error) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                const wrappedSub: Subscription = {\n                    request(n: number) { try { fn(n); } catch (_) {} sub.request(n); },\n                    unsubscribe() { sub.unsubscribe(); }\n                };\n                subscriber.onSubscribe(wrappedSub);\n                return wrappedSub;\n            }\n        });\n    }\n\n    /**\n     * Executes a side-effect `fn` for every reactive signal (next, error, complete).\n     *\n     * The {@link Signal} discriminated union lets you inspect the kind and payload\n     * of each event in a single callback.\n     *\n     * @param fn - Called for every signal with a {@link Signal} wrapper.\n     * @returns A publisher with the side effect attached to all signals.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2)\n     *   .doOnEach(s => { if (s.kind === 'next') console.log('item:', s.value); })\n     *   .subscribe();\n     * ```\n     */\n    public doOnEach(fn: (signal: Signal<T>) => void): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v: T) { try { fn(Signal.next(v)); } catch (_) {} subscriber.onNext(v); },\n                    onError(e: Error) { try { fn(Signal.error<T>(e)); } catch (_) {} subscriber.onError(e); },\n                    onComplete() { try { fn(Signal.complete<T>()); } catch (_) {} subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Shifts the *subscription* (and source execution) to the given `scheduler`.\n     *\n     * The actual call to `this.source.subscribe(...)` is deferred and run on `scheduler`.\n     * Downstream `onSubscribe` is delivered immediately on the calling thread with a proxy\n     * `Subscription` that buffers `request(n)` calls until the source subscription is ready.\n     *\n     * Use this for cold sources that do their work synchronously on subscribe — it moves\n     * that work to a different thread/context.\n     *\n     * @param scheduler - The scheduler on which the source is subscribed to and runs.\n     * @returns A publisher whose source execution runs on the given scheduler.\n     */\n    public subscribeOn(scheduler: Scheduler): Self {\n        return this.wrapSource({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let sub: Subscription | null = null;\n                let pending = 0;\n                let cancelled = false;\n\n                const proxy: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        if (sub) sub.request(n); else pending = Math.min(pending + n, Number.MAX_SAFE_INTEGER);\n                    },\n                    unsubscribe() { cancelled = true; sub?.unsubscribe(); }\n                };\n\n                subscriber.onSubscribe(proxy);\n\n                scheduler.schedule(() => {\n                    if (cancelled) return;\n                    sub = this.source.subscribe({\n                        onSubscribe(_s) {},\n                        onNext(v) { subscriber.onNext(v); },\n                        onError(e) { subscriber.onError(e); },\n                        onComplete() { subscriber.onComplete(); }\n                    });\n                    if (pending > 0) sub.request(pending);\n                });\n\n                return proxy;\n            }\n        });\n    }\n}\n","import {Scheduler} from '@/schedulers/Scheduler'\n\n/**\n * A scheduler that immediately executes tasks.\n * Implements the `Scheduler` interface to execute tasks without any delay.\n */\n\nexport class ImmediateScheduler implements Scheduler {\n    /**\n     * Schedules a task to be executed immediately.\n     * @param {Function} task - The task function to be executed.\n     */\n    public schedule(task: () => void): void {\n        task()\n    }\n}\n","import {Scheduler} from \"@/schedulers/Scheduler\";\n\n/**\n * A scheduler that executes tasks asynchronously using the microtask queue.\n * Implements the `Scheduler` interface and schedules tasks using `Promise.resolve().then(...)`.\n */\nexport class MicroScheduler implements Scheduler {\n    /**\n     * Schedules a task to be executed asynchronously as a microtask.\n     * Uses `Promise.resolve().then(task)` to place the task in the microtask queue.\n     * @param {Function} task - The task function to be executed.\n     */\n    public schedule(task: () => void): void {\n        Promise.resolve().then(task)\n    }\n}\n","import {Scheduler} from \"@/schedulers/Scheduler\";\n\n/**\n * A scheduler that executes tasks asynchronously using the macro task queue.\n * Implements the `Scheduler` interface and schedules tasks using `setTimeout` with a delay of `0`.\n */\nexport class MacroScheduler implements Scheduler {\n    /**\n     * Schedules a task to be executed asynchronously.\n     * Uses `setTimeout` with a delay of `0` to place the task in the macro task queue.\n     * @param {Function} task - The task function to be executed.\n     */\n    public schedule(task: () => void): void {\n        setTimeout(task, 0)\n    }\n}\n","import {CancellableScheduler} from \"@/schedulers/Scheduler\";\n\n/**\n * A scheduler that executes tasks after a specified delay.\n * Implements the `CancellableScheduler` interface, allowing scheduled tasks to be canceled.\n */\nexport class DelayScheduler implements CancellableScheduler {\n    private readonly delay: number\n\n    /**\n     * Creates a new DelayScheduler.\n     * @param {number} delay - The delay duration in milliseconds.\n     */\n    constructor(delay: number) {\n        this.delay = delay\n    }\n\n    /**\n     * Schedules a task to be executed after the specified delay.\n     * Returns an object with a cancel method to clear the timeout.\n     * @param {Function} task - The task function to be executed.\n     * @returns {Object} An object with a `cancel` method to stop the execution.\n     */\n    public schedule(task: () => void): { cancel: () => void } {\n        const id = setTimeout(task, this.delay)\n        return {\n            /**\n             * Cancels the scheduled task.\n             */\n            cancel: () => clearTimeout(id)\n        }\n    }\n}\n","import {CancellableScheduler} from \"@/schedulers/Scheduler\";\n\n/**\n * A scheduler that executes tasks multiple times with a specified interval.\n * Implements the `CancellableScheduler` interface, allowing scheduled tasks to be canceled.\n */\nexport class IntervalScheduler implements CancellableScheduler {\n    private readonly interval: number\n\n    /**\n     * Creates a new IntervalScheduler.\n     * @param {number} delay - The interval duration in milliseconds.\n     */\n    constructor(delay: number) {\n        this.interval = delay\n    }\n\n    /**\n     * Schedules a task to be executed multiple times with a specified interval.\n     * Returns an object with a cancel method to clear the timeout.\n     * @param {Function} task - The task function to be executed.\n     * @returns {Object} An object with a `cancel` method to stop the execution.\n     */\n    public schedule(task: () => void): { cancel: () => void } {\n        const id = setInterval(task, this.interval)\n        return {\n            /**\n             * Cancels the scheduled task.\n             */\n            cancel: () => clearInterval(id)\n        }\n    }\n}\n","import {ImmediateScheduler} from \"@/schedulers/ImmediateScheduler\";\nimport {MicroScheduler} from \"@/schedulers/MicroScheduler\";\nimport {MacroScheduler} from \"@/schedulers/MacroScheduler\";\nimport {DelayScheduler} from \"@/schedulers/DelayScheduler\";\nimport {IntervalScheduler} from \"@/schedulers/IntervalScheduler\";\n\nexport * from '@/schedulers/Scheduler'\n\n/**\n * A collection of commonly used schedulers for task execution.\n * Provides methods to create instances of various scheduler types.\n */\nexport const Schedulers = {\n    /**\n     * Creates an instance of `ImmediateScheduler`.\n     * Executes tasks immediately without any delay.\n     * @returns {ImmediateScheduler} An instance of ImmediateScheduler.\n     */\n    immediate: (): ImmediateScheduler => new ImmediateScheduler(),\n    /**\n     * Creates an instance of `MicroScheduler`.\n     * Executes tasks asynchronously using the microtask queue.\n     * @returns {MicroScheduler} An instance of MicroScheduler.\n     */\n    micro: (): MicroScheduler => new MicroScheduler(),\n    /**\n     * Creates an instance of `MacroScheduler`.\n     * Executes tasks asynchronously using the macro task queue (via `setTimeout`).\n     * @returns {MacroScheduler} An instance of MacroScheduler.\n     */\n    macro: (): MacroScheduler => new MacroScheduler(),\n    /**\n     * Creates an instance of `DelayScheduler` with a specified delay.\n     * Executes tasks after a given delay using `setTimeout`.\n     * @param {number} ms - The delay in milliseconds before executing the task.\n     * @returns {DelayScheduler} An instance of DelayScheduler.\n     */\n    delay: (ms: number): DelayScheduler => new DelayScheduler(ms),\n    /**\n     * Creates an instance of `IntervalScheduler` with a specified interval.\n     * Executes tasks multiple times with a given interval using `setInterval`.\n     * @param {number} ms - The interval in milliseconds between task executing.\n     * @returns {IntervalScheduler} An instance of IntervalScheduler.\n     */\n    interval: (ms: number): IntervalScheduler => new IntervalScheduler(ms)\n}","import {PipePublisher} from \"@/publishers/PipePublisher\";\nimport {Publisher} from \"@/publishers/Publisher\";\nimport {Sink} from \"@/sinks/Sink\";\nimport {Mono} from \"@/publishers/Mono\";\nimport {Subscriber} from \"@/subscriptions/Subscriber\";\nimport {Subscription} from \"@/subscriptions/Subscription\";\nimport ReplayAllSink from \"@/sinks/ReplayAllSink\";\nimport {AbstractPipePublisher} from \"@/publishers/internal/AbstractPipePublisher\";\nimport {Schedulers} from \"@/schedulers\";\nimport {Signal} from \"@/publishers/Signal\";\nimport {FluxSink} from \"@/publishers/FluxSink\";\n\n/**\n * A cold publisher of 0 to N items with full backpressure support.\n *\n * Items flow only when the downstream {@link Subscription} issues `request(n)`.\n * The convenience `subscribe(onNext, onError, onComplete)` overloads\n * automatically request `Number.MAX_SAFE_INTEGER` so items start arriving\n * without extra ceremony.\n *\n * Each `subscribe()` call creates an **independent** run of the pipeline\n * (\"cold\" semantics). Use {@link Flux.cache} or {@link Sinks} to share a\n * single run across multiple subscribers.\n *\n * @typeParam T - The type of items emitted by this Flux.\n *\n * @example\n * ```typescript\n * Flux.just(1, 2, 3)\n *   .map(n => n * 2)\n *   .filter(n => n > 2)\n *   .subscribe(v => console.log(v));\n * // 4  6\n * ```\n */\nexport class Flux<T> extends AbstractPipePublisher<T, Flux<T>> implements PipePublisher<T> {\n\n    protected constructor(source: Publisher<T>) { super(source); }\n\n    protected defaultDemand(): number { return Number.MAX_SAFE_INTEGER; }\n\n    protected wrapSource(source: Publisher<T>): Flux<T> {\n        return new Flux<T>(source);\n    }\n\n    // ─────────────────────────── Static factories ────────────────────────────\n\n    /**\n     * Wraps an existing {@link Publisher} as a `Flux`.\n     *\n     * @param publisher - Any `Publisher<T>` to adapt.\n     * @returns A `Flux<T>` backed by the given publisher.\n     */\n    public static from<T>(publisher: Publisher<T>): Flux<T> {\n        return new Flux<T>(publisher);\n    }\n\n    /**\n     * Creates a `Flux` from a generator function that pushes values imperatively.\n     *\n     * The generator receives a {@link Sink} and may call `sink.next(v)` any number\n     * of times, then `sink.complete()` or `sink.error(e)`.  Delivery is\n     * **backpressure-aware**: items pushed when demand is zero are buffered and\n     * delivered as downstream issues `request(n)`.\n     *\n     * Rule 1.3 is respected — `onSubscribe` is delivered to the subscriber\n     * **before** the generator runs.\n     *\n     * @param generator - Function that pushes items via the provided `Sink<T>`.\n     * @returns A cold `Flux<T>`.\n     *\n     * @example\n     * ```typescript\n     * Flux.generate<number>(sink => {\n     *   sink.next(1);\n     *   sink.next(2);\n     *   sink.complete();\n     * }).subscribe(v => console.log(v)); // 1  2\n     * ```\n     */\n    public static generate<T>(generator: (sink: Sink<T>) => void): Flux<T> {\n        return new Flux<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                const buffer: T[] = [];\n                let demand = 0;\n                let terminated = false;\n                let terminalDelivered = false;\n                let terminalError: Error | null = null;\n                let cancelled = false;\n                let draining = false;\n\n                const drain = () => {\n                    if (draining || cancelled) return;\n                    draining = true;\n                    try {\n                        while (demand > 0 && buffer.length > 0) {\n                            demand--;\n                            subscriber.onNext(buffer.shift()!);\n                            if (cancelled) return;\n                        }\n                        if (!terminalDelivered && buffer.length === 0 && terminated) {\n                            terminalDelivered = true;\n                            terminalError\n                                ? subscriber.onError(terminalError)\n                                : subscriber.onComplete();\n                        }\n                    } finally {\n                        draining = false;\n                    }\n                };\n\n                const sink: Sink<T> = {\n                    next(v: T) {\n                        if (terminated || cancelled) return;\n                        if (demand > 0) { demand--; subscriber.onNext(v); }\n                        else buffer.push(v);\n                    },\n                    error(err: Error) {\n                        if (terminated || cancelled) return;\n                        terminated = true;\n                        terminalError = err;\n                        drain();\n                    },\n                    complete() {\n                        if (terminated || cancelled) return;\n                        terminated = true;\n                        drain();\n                    }\n                };\n\n                const subscription: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) {\n                            subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                            return;\n                        }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        drain();\n                    },\n                    unsubscribe() {\n                        cancelled = true;\n                        buffer.length = 0;\n                    }\n                };\n\n                // Rule 1.3: onSubscribe MUST be the first signal — call it before the generator.\n                subscriber.onSubscribe(subscription);\n\n                try { generator(sink); }\n                catch (e) {\n                    if (!terminated) {\n                        terminated = true;\n                        terminalError = e instanceof Error ? e : new Error(String(e));\n                        drain();\n                    }\n                }\n\n                return subscription;\n            }\n        });\n    }\n\n    /**\n     * Creates a `Flux` that emits every element of an `Iterable` in order, then completes.\n     *\n     * @param iterable - Any `Iterable<T>` (Array, Set, Map, generator, etc.).\n     * @returns A cold `Flux<T>`.\n     *\n     * @example\n     * ```typescript\n     * Flux.fromIterable(['a', 'b', 'c']).subscribe(v => console.log(v));\n     * // a  b  c\n     * ```\n     */\n    public static fromIterable<T>(iterable: Iterable<T>): Flux<T> {\n        return Flux.generate<T>(sink => {\n            for (const item of iterable) sink.next(item);\n            sink.complete();\n        });\n    }\n\n    /**\n     * Creates a `Flux` that emits `count` sequential integers starting at `start`.\n     *\n     * @param start - First integer to emit.\n     * @param count - Number of integers to emit.\n     * @returns A cold `Flux<number>` emitting `[start, start + count)`.\n     *\n     * @example\n     * ```typescript\n     * Flux.range(0, 5).subscribe(v => console.log(v)); // 0 1 2 3 4\n     * ```\n     */\n    public static range(start: number, count: number): Flux<number> {\n        return Flux.generate<number>(sink => {\n            for (let i = 0; i < count; i++) sink.next(start + i);\n            sink.complete();\n        });\n    }\n\n    /**\n     * Creates a `Flux` that completes immediately without emitting any items.\n     *\n     * @returns An empty, completed `Flux<T>`.\n     */\n    public static empty<T = never>(): Flux<T> {\n        return new Flux<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                const sub = { request() {}, unsubscribe() {} };\n                subscriber.onSubscribe(sub);\n                subscriber.onComplete();\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Lazily creates a new `Flux` per subscription by calling `factory`.\n     *\n     * Useful when the source depends on mutable state that should be captured\n     * at subscribe time rather than at assembly time.\n     *\n     * @param factory - Called once per subscription to produce the actual `Flux<T>`.\n     * @returns A lazy `Flux<T>`.\n     */\n    public static defer<T>(factory: () => Flux<T>): Flux<T> {\n        return new Flux<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                return factory().subscribe(subscriber);\n            }\n        });\n    }\n\n    /**\n     * Creates a `Flux` that emits the provided items in order, then completes.\n     *\n     * @param items - Zero or more items to emit.\n     * @returns A cold `Flux<T>`.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3).subscribe(v => console.log(v)); // 1  2  3\n     * ```\n     */\n    public static just<T>(...items: T[]): Flux<T> {\n        return Flux.fromIterable(items);\n    }\n\n    /**\n     * Creates a `Flux` that signals `onError` immediately upon subscription.\n     *\n     * @param error - The error to signal.\n     * @returns An errored `Flux<T>`.\n     */\n    public static error<T = never>(error: Error): Flux<T> {\n        return new Flux<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                const sub = { request() {}, unsubscribe() {} };\n                subscriber.onSubscribe(sub);\n                subscriber.onError(error);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Creates a `Flux` that never emits any signal — no items, no error, no completion.\n     * Useful as a placeholder or to represent an infinite, empty stream.\n     *\n     * @returns A `Flux<T>` that stays subscribed forever.\n     */\n    public static never<T = never>(): Flux<T> {\n        return new Flux<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                const sub = { request() {}, unsubscribe() {} };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Creates a `Flux` from a generator function that **pushes** values imperatively\n     * via a {@link FluxSink}.\n     *\n     * Unlike {@link Flux.generate} (which is request-pull), `create` is designed for\n     * **push-based** sources (EventEmitter, WebSocket, DOM events, Node.js streams).\n     * Items pushed when downstream demand is zero are **buffered** and delivered as demand\n     * becomes available.\n     *\n     * Register `onRequest`, `onCancel`, and `onDispose` callbacks on the sink to respond\n     * to downstream lifecycle events.\n     *\n     * @param emitter - Called once per subscription; receives a `FluxSink<T>` for pushing values.\n     * @returns A cold `Flux<T>`.\n     *\n     * @example\n     * ```typescript\n     * const emitter = new EventEmitter();\n     * const flux = Flux.create<string>(sink => {\n     *   emitter.on('data', v => sink.next(v));\n     *   emitter.on('end',  () => sink.complete());\n     *   sink.onCancel(() => emitter.removeAllListeners());\n     * });\n     * ```\n     */\n    public static create<T>(emitter: (sink: FluxSink<T>) => void): Flux<T> {\n        return new Flux<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                const buffer: T[] = [];\n                let demand = 0;\n                let cancelled = false;\n                let terminated = false;\n                let terminalError: Error | null = null;\n                let draining = false;\n\n                const requestCbs: Array<(n: number) => void> = [];\n                const cancelCbs: Array<() => void> = [];\n                const disposeCbs: Array<() => void> = [];\n\n                const fireDispose = () => { for (const fn of disposeCbs) try { fn(); } catch (_) {} };\n\n                const drain = () => {\n                    if (draining || cancelled) return;\n                    draining = true;\n                    try {\n                        while (demand > 0 && buffer.length > 0 && !cancelled) {\n                            demand--;\n                            subscriber.onNext(buffer.shift()!);\n                        }\n                        if (terminated && buffer.length === 0 && !cancelled) {\n                            if (terminalError) subscriber.onError(terminalError);\n                            else subscriber.onComplete();\n                        }\n                    } finally { draining = false; }\n                };\n\n                const sink: FluxSink<T> = {\n                    next(value: T) {\n                        if (cancelled || terminated) return;\n                        buffer.push(value);\n                        drain();\n                    },\n                    error(error: Error) {\n                        if (cancelled || terminated) return;\n                        terminated = true;\n                        terminalError = error;\n                        fireDispose();\n                        drain();\n                    },\n                    complete() {\n                        if (cancelled || terminated) return;\n                        terminated = true;\n                        fireDispose();\n                        drain();\n                    },\n                    get requested() { return demand; },\n                    onRequest(fn) { requestCbs.push(fn); return sink; },\n                    onCancel(fn) { cancelCbs.push(fn); return sink; },\n                    onDispose(fn) { disposeCbs.push(fn); return sink; }\n                };\n\n                const sub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || (terminated && buffer.length === 0)) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        for (const fn of requestCbs) try { fn(n); } catch (_) {}\n                        drain();\n                    },\n                    unsubscribe() {\n                        if (cancelled) return;\n                        cancelled = true;\n                        buffer.length = 0;\n                        for (const fn of cancelCbs) try { fn(); } catch (_) {}\n                        fireDispose();\n                    }\n                };\n\n                // Rule 1.3: onSubscribe is the first signal delivered to the subscriber.\n                subscriber.onSubscribe(sub);\n                try { emitter(sink); }\n                catch (e) { if (!terminated && !cancelled) sink.error(e instanceof Error ? e : new Error(String(e))); }\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Creates a `Flux` that acquires a resource, uses it to build a source publisher,\n     * and guarantees the resource is cleaned up when the stream terminates or is cancelled.\n     *\n     * The cleanup runs after `onComplete`, `onError`, or `unsubscribe()` — whichever\n     * happens first.\n     *\n     * @param resourceSupplier - Called once per subscription to acquire the resource.\n     * @param sourceFactory - Builds the source publisher from the resource.\n     * @param cleanup - Called with the resource after the stream terminates.\n     * @returns A `Flux<T>` with guaranteed resource cleanup.\n     *\n     * @example\n     * ```typescript\n     * Flux.using(\n     *   () => openFile('data.txt'),\n     *   file => Flux.fromIterable(file.readLines()),\n     *   file => file.close()\n     * ).subscribe(line => console.log(line));\n     * ```\n     */\n    public static using<T, R>(\n        resourceSupplier: () => R,\n        sourceFactory: (resource: R) => Publisher<T>,\n        cleanup: (resource: R) => void\n    ): Flux<T> {\n        return Flux.defer(() => {\n            const resource = resourceSupplier();\n            return Flux.from(sourceFactory(resource))\n                .doFinally(() => { try { cleanup(resource); } catch (_) {} });\n        });\n    }\n\n    /**\n     * Merges N publishers by subscribing to all of them concurrently and interleaving\n     * their items as they arrive.\n     *\n     * The stream completes when **all** sources complete.\n     * Any error from any source terminates the merged stream immediately.\n     *\n     * @param sources - Publishers to merge.\n     * @returns A `Flux<T>` that emits items from all sources concurrently.\n     *\n     * @example\n     * ```typescript\n     * Flux.merge(Flux.just(1, 2), Flux.just(3, 4)).subscribe(v => console.log(v));\n     * // 1 2 3 4 (order may vary for async sources)\n     * ```\n     */\n    public static merge<T>(...sources: Publisher<T>[]): Flux<T> {\n        if (sources.length === 0) return Flux.empty<T>();\n        if (sources.length === 1) return Flux.from(sources[0]);\n        return new Flux<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                const n = sources.length;\n                let doneCount = 0;\n                let cancelled = false;\n                let terminated = false;\n                // Populated synchronously before onSubscribe is called (RS 1.9 guarantees\n                // that Publisher.subscribe calls onSubscribe synchronously).\n                const subs: Subscription[] = new Array(n);\n\n                const terminate = (err?: Error) => {\n                    if (terminated) return;\n                    terminated = true;\n                    for (const s of subs) s?.unsubscribe();\n                    if (err) subscriber.onError(err);\n                    else subscriber.onComplete();\n                };\n\n                const operatorSub: Subscription = {\n                    request(count: number) {\n                        if (cancelled || terminated) return;\n                        if (count <= 0) { terminate(new Error(`request must be > 0, but was ${count}`)); return; }\n                        for (const s of subs) s.request(count);\n                    },\n                    unsubscribe() { cancelled = true; for (const s of subs) s?.unsubscribe(); }\n                };\n\n                // Subscribe to all sources first so subs[] is fully populated before\n                // subscriber.onSubscribe is called — this prevents losing demand that\n                // the subscriber issues immediately inside onSubscribe (RS rule 2.7 /\n                // convenience overloads call request() from onSubscribe).\n                for (let i = 0; i < n; i++) {\n                    let inner!: Subscription;\n                    sources[i].subscribe({\n                        onSubscribe(s: Subscription) { inner = s; },\n                        onNext(v: T) { if (!cancelled && !terminated) subscriber.onNext(v); },\n                        onError(e: Error) { terminate(e); },\n                        onComplete() { if (++doneCount === n) terminate(); }\n                    });\n                    subs[i] = inner;\n                }\n\n                subscriber.onSubscribe(operatorSub);\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Subscribes to all `sources` concurrently and emits the **first value** produced\n     * by any of them. All other subscriptions are cancelled immediately after the winner emits.\n     *\n     * If all sources complete without emitting a value, the result completes empty.\n     * Errors from non-winning sources are ignored once a winner is found.\n     *\n     * @param sources - Publishers to race.\n     * @returns A `Flux<T>` that emits the first value from any source.\n     *\n     * @example\n     * ```typescript\n     * // Take whichever request responds first\n     * Flux.firstWithValue(fetchFromCDN(), fetchFromOrigin())\n     *   .subscribe(data => console.log(data));\n     * ```\n     */\n    public static firstWithValue<T>(...sources: Publisher<T>[]): Flux<T> {\n        return new Flux<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                if (sources.length === 0) {\n                    const sub = { request() {}, unsubscribe() {} };\n                    subscriber.onSubscribe(sub);\n                    subscriber.onComplete();\n                    return sub;\n                }\n\n                const n = sources.length;\n                let won = false;\n                let cancelled = false;\n                let finished = 0;\n                let lastError: Error | null = null;\n                const subs: Subscription[] = new Array(n);\n\n                const operatorSub: Subscription = {\n                    request(count: number) { if (!cancelled) for (const s of subs) s.request(count); },\n                    unsubscribe() { cancelled = true; for (const s of subs) s?.unsubscribe(); }\n                };\n\n                // Collect all subscriptions before calling subscriber.onSubscribe so that\n                // demand issued inside onSubscribe reaches every source.\n                for (let i = 0; i < n; i++) {\n                    const idx = i;\n                    let inner!: Subscription;\n                    sources[idx].subscribe({\n                        onSubscribe(s: Subscription) { inner = s; },\n                        onNext(v: T) {\n                            if (cancelled || won) return;\n                            won = true;\n                            for (let j = 0; j < n; j++) { if (j !== idx) subs[j]?.unsubscribe(); }\n                            subscriber.onNext(v);\n                            subscriber.onComplete();\n                        },\n                        onError(e: Error) {\n                            if (cancelled || won) return;\n                            lastError = e;\n                            if (++finished === n) subscriber.onError(lastError!);\n                        },\n                        onComplete() {\n                            if (cancelled || won) return;\n                            if (++finished === n) subscriber.onComplete();\n                        }\n                    });\n                    subs[idx] = inner;\n                }\n\n                subscriber.onSubscribe(operatorSub);\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Emits an ever-incrementing counter (0, 1, 2, …) at a fixed `ms` rate.\n     *\n     * Items are **dropped** when downstream has no outstanding demand (rather than\n     * buffered), matching Reactor's `Flux.interval` drop-on-overflow behaviour.\n     * The stream never completes on its own — cancel the subscription to stop it.\n     *\n     * @param ms - Interval duration in milliseconds.\n     * @returns An infinite `Flux<number>`.\n     *\n     * @example\n     * ```typescript\n     * Flux.interval(1000).take(3).subscribe(n => console.log(n)); // 0  1  2\n     * ```\n     */\n    public static interval(ms: number): Flux<number> {\n        return new Flux<number>({\n            subscribe(subscriber: Subscriber<number>): Subscription {\n                let demand = 0;\n                let counter = 0;\n                let cancelled = false;\n                const id = setInterval(() => {\n                    if (cancelled) return;\n                    if (demand > 0) {\n                        demand--;\n                        subscriber.onNext(counter++);\n                    }\n                    // demand === 0 → drop the tick (matches Reactor's interval behaviour)\n                }, ms);\n                const sub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                    },\n                    unsubscribe() { cancelled = true; clearInterval(id); }\n                };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Combines items from 2 sources positionally via `combiner`.\n     * Emits one combined value for each position; stops when the shorter source exhausts.\n     */\n    public static zip<A, B, R>(\n        sources: [Publisher<A>, Publisher<B>],\n        combiner: (a: A, b: B) => R\n    ): Flux<R>;\n\n    /**\n     * Combines items from 3 sources positionally via `combiner`.\n     */\n    public static zip<A, B, C, R>(\n        sources: [Publisher<A>, Publisher<B>, Publisher<C>],\n        combiner: (a: A, b: B, c: C) => R\n    ): Flux<R>;\n\n    /**\n     * Combines items from 4 sources positionally via `combiner`.\n     */\n    public static zip<A, B, C, D, R>(\n        sources: [Publisher<A>, Publisher<B>, Publisher<C>, Publisher<D>],\n        combiner: (a: A, b: B, c: C, d: D) => R\n    ): Flux<R>;\n\n    /**\n     * General N-source positional zip.\n     *\n     * Subscribes to each source concurrently, using a prefetch of 1 per source.\n     * Once every source has provided one item for a given position, `combiner` is\n     * called with those items and the result is emitted downstream.  The stream\n     * completes when any source completes and has no buffered items left.\n     *\n     * @param sources - Publishers to zip.\n     * @param combiner - Combines one item from each source at the same position.\n     * @returns A `Flux<R>` of combined values.\n     *\n     * @example\n     * ```typescript\n     * Flux.zip([Flux.just(1, 2), Flux.just('a', 'b')], (n, s) => `${n}${s}`)\n     *   .subscribe(v => console.log(v)); // '1a'  '2b'\n     * ```\n     */\n    public static zip<T, R>(\n        sources: Publisher<T>[],\n        combiner: (...args: T[]) => R\n    ): Flux<R>;\n\n    public static zip(\n        sources: Publisher<unknown>[],\n        combiner: (...args: unknown[]) => unknown\n    ): Flux<unknown> {\n        if (sources.length === 0) return Flux.empty();\n        return new Flux<unknown>({\n            subscribe(subscriber: Subscriber<unknown>): Subscription {\n                const n = sources.length;\n                let demand = 0;\n                let cancelled = false;\n                let terminated = false;\n                const queues: unknown[][] = Array.from({ length: n }, () => []);\n                const completed: boolean[] = new Array(n).fill(false);\n                const subs: Subscription[] = new Array(n);\n\n                const tryEmit = () => {\n                    while (!cancelled && !terminated && demand > 0 && queues.every(q => q.length > 0)) {\n                        demand--;\n                        const args = queues.map(q => q.shift()!);\n                        let result: unknown;\n                        try { result = combiner(...args); }\n                        catch (e) {\n                            terminated = true;\n                            for (const s of subs) s?.unsubscribe();\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                            return;\n                        }\n                        subscriber.onNext(result);\n                        // Re-fetch 1 from each source that just provided an item\n                        for (let i = 0; i < n; i++) {\n                            if (!completed[i]) subs[i].request(1);\n                        }\n                    }\n                    // Complete when any source is exhausted (queue empty + completed)\n                    if (!terminated && completed.some((done, i) => done && queues[i].length === 0)) {\n                        terminated = true;\n                        for (const s of subs) s?.unsubscribe();\n                        subscriber.onComplete();\n                    }\n                };\n\n                const operatorSub: Subscription = {\n                    request(count: number) {\n                        if (cancelled || terminated) return;\n                        if (count <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${count}`)); return; }\n                        demand = Math.min(demand + count, Number.MAX_SAFE_INTEGER);\n                        tryEmit();\n                    },\n                    unsubscribe() { cancelled = true; for (const s of subs) s?.unsubscribe(); }\n                };\n\n                for (let i = 0; i < n; i++) {\n                    const idx = i;\n                    let inner!: Subscription;\n                    sources[idx].subscribe({\n                        onSubscribe(s: Subscription) { inner = s; },\n                        onNext(v: unknown) {\n                            if (cancelled || terminated) return;\n                            queues[idx].push(v);\n                            tryEmit();\n                        },\n                        onError(e: Error) {\n                            if (cancelled || terminated) return;\n                            terminated = true;\n                            for (const s of subs) s?.unsubscribe();\n                            subscriber.onError(e);\n                        },\n                        onComplete() {\n                            if (cancelled || terminated) return;\n                            completed[idx] = true;\n                            tryEmit(); // triggers completion check\n                        }\n                    });\n                    subs[idx] = inner;\n                }\n\n                subscriber.onSubscribe(operatorSub);\n                // Prefetch 1 from each source\n                for (let i = 0; i < n; i++) subs[i].request(1);\n                return operatorSub;\n            }\n        }) as Flux<unknown>;\n    }\n\n    /**\n     * Combines the **latest** value from each source whenever any source emits.\n     *\n     * Does not emit until all sources have produced at least one value.\n     * Continues emitting with each new item from any source, using the latest values\n     * from all others.  Sources run at unbounded speed; downstream demand controls delivery.\n     *\n     * @param sources - Publishers to combine.\n     * @param combiner - Called with the latest value from each source.\n     * @returns A `Flux<R>` of combined values.\n     *\n     * @example\n     * ```typescript\n     * Flux.combineLatest([Flux.just(1, 2), Flux.just('a', 'b')], (n, s) => `${n}${s}`)\n     *   .subscribe(v => console.log(v)); // '1a'  '2a'  '2b'  (order depends on timing)\n     * ```\n     */\n    public static combineLatest<A, B, R>(\n        sources: [Publisher<A>, Publisher<B>],\n        combiner: (a: A, b: B) => R\n    ): Flux<R>;\n\n    public static combineLatest<A, B, C, R>(\n        sources: [Publisher<A>, Publisher<B>, Publisher<C>],\n        combiner: (a: A, b: B, c: C) => R\n    ): Flux<R>;\n\n    public static combineLatest<A, B, C, D, R>(\n        sources: [Publisher<A>, Publisher<B>, Publisher<C>, Publisher<D>],\n        combiner: (a: A, b: B, c: C, d: D) => R\n    ): Flux<R>;\n\n    public static combineLatest<T, R>(\n        sources: Publisher<T>[],\n        combiner: (...args: T[]) => R\n    ): Flux<R>;\n\n    public static combineLatest(\n        sources: Publisher<unknown>[],\n        combiner: (...args: unknown[]) => unknown\n    ): Flux<unknown> {\n        if (sources.length === 0) return Flux.empty();\n        return new Flux<unknown>({\n            subscribe(subscriber: Subscriber<unknown>): Subscription {\n                const n = sources.length;\n                let demand = 0;\n                let cancelled = false;\n                let terminated = false;\n                const pending: unknown[] = [];\n                const latest: unknown[] = new Array(n).fill(undefined);\n                const hasValue: boolean[] = new Array(n).fill(false);\n                const completed: boolean[] = new Array(n).fill(false);\n                const subs: Subscription[] = new Array(n);\n\n                const flush = () => {\n                    while (!cancelled && !terminated && demand > 0 && pending.length > 0) {\n                        demand--;\n                        subscriber.onNext(pending.shift()!);\n                    }\n                    if (!terminated && completed.every(Boolean) && pending.length === 0) {\n                        terminated = true;\n                        subscriber.onComplete();\n                    }\n                };\n\n                const operatorSub: Subscription = {\n                    request(count: number) {\n                        if (cancelled || terminated) return;\n                        if (count <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${count}`)); return; }\n                        demand = Math.min(demand + count, Number.MAX_SAFE_INTEGER);\n                        flush();\n                    },\n                    unsubscribe() { cancelled = true; for (const s of subs) s?.unsubscribe(); }\n                };\n\n                for (let i = 0; i < n; i++) {\n                    const idx = i;\n                    let inner!: Subscription;\n                    sources[idx].subscribe({\n                        onSubscribe(s: Subscription) { inner = s; },\n                        onNext(v: unknown) {\n                            if (cancelled || terminated) return;\n                            latest[idx] = v;\n                            hasValue[idx] = true;\n                            if (hasValue.every(Boolean)) {\n                                let result: unknown;\n                                try { result = combiner(...latest); }\n                                catch (e) {\n                                    terminated = true;\n                                    for (const s of subs) s?.unsubscribe();\n                                    subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                                    return;\n                                }\n                                pending.push(result);\n                                flush();\n                            }\n                        },\n                        onError(e: Error) {\n                            if (cancelled || terminated) return;\n                            terminated = true;\n                            for (const s of subs) s?.unsubscribe();\n                            subscriber.onError(e);\n                        },\n                        onComplete() {\n                            if (cancelled || terminated) return;\n                            completed[idx] = true;\n                            flush(); // may trigger completion if all done\n                        }\n                    });\n                    subs[idx] = inner;\n                }\n\n                subscriber.onSubscribe(operatorSub);\n                // Sources run unbounded; combined output is buffered by pending[] and\n                // released as downstream demand arrives.\n                for (let i = 0; i < n; i++) subs[i].request(Number.MAX_SAFE_INTEGER);\n                return operatorSub;\n            }\n        }) as Flux<unknown>;\n    }\n\n    // ─────────────────── PipePublisher operators ──────────────────\n\n    /**\n     * Transforms each item using `fn`, producing a `Flux<R>`.\n     *\n     * If `fn` throws, the exception is forwarded to `onError` and the stream terminates.\n     *\n     * @param fn - Mapping function applied to every item.\n     * @returns A new `Flux<R>`.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3).map(n => n * 10).subscribe(v => console.log(v));\n     * // 10  20  30\n     * ```\n     */\n    public map<R>(fn: (value: T) => R): Flux<R> {\n        return new Flux<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        try { subscriber.onNext(fn(v)); }\n                        catch (e) { subscriber.onError(e instanceof Error ? e : new Error(String(e))); }\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Transforms each item with `fn`, silently discarding `null`/`undefined` results.\n     *\n     * When an item is discarded, upstream demand is replenished by 1 so the\n     * downstream demand accounting stays correct.\n     *\n     * @param fn - Mapping function; returning `null` or `undefined` skips the item.\n     * @returns A `Flux<NonNullable<R>>` with nulls filtered out.\n     *\n     * @example\n     * ```typescript\n     * Flux.just('hello', '', 'world')\n     *   .mapNotNull(s => s.length > 0 ? s : null)\n     *   .subscribe(v => console.log(v));\n     * // hello  world\n     * ```\n     */\n    public mapNotNull<R>(fn: (value: T) => R | null | undefined): Flux<NonNullable<R>> {\n        return new Flux<NonNullable<R>>({\n            subscribe: (subscriber: Subscriber<NonNullable<R>>): Subscription => {\n                let sourceSub!: Subscription;\n                const sub = this.source.subscribe({\n                    onSubscribe(s) { sourceSub = s; },\n                    onNext(v) {\n                        try {\n                            const r = fn(v);\n                            if (r != null) subscriber.onNext(r as NonNullable<R>);\n                            else sourceSub.request(1); // replenish: null item skipped\n                        } catch (e) {\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                        }\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Fine-grained per-item transform: the `handler` receives each item together with\n     * a {@link Sink} and may emit **0 or 1** result items.\n     *\n     * - Calling `sink.next(r)` once emits `r` downstream.\n     * - Calling `sink.next(r)` more than once is silently ignored (0-or-1 semantics).\n     * - Calling `sink.complete()` or `sink.error(e)` terminates the stream early.\n     * - If the handler emits nothing (0 items), upstream demand is replenished by 1.\n     *\n     * This is the Flux equivalent of `reactor-core`'s `handle(BiConsumer<T, SynchronousSink<R>>)`.\n     *\n     * @param handler - Called for each upstream item with the item and an output `Sink<R>`.\n     * @returns A `Flux<R>`.\n     *\n     * @example\n     * ```typescript\n     * // Convert strings to numbers, skip non-numeric entries\n     * Flux.just('1', 'two', '3').handle<number>((s, sink) => {\n     *   const n = parseInt(s);\n     *   if (!isNaN(n)) sink.next(n);\n     * }).subscribe(v => console.log(v));\n     * // 1  3\n     * ```\n     */\n    public handle<R>(handler: (value: T, sink: Sink<R>) => void): Flux<R> {\n        return new Flux<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                let sourceSub!: Subscription;\n                let done = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(s) { sourceSub = s; },\n                    onNext(v) {\n                        if (done) return;\n                        let emitted = false;\n                        const sinkWrapper: Sink<R> = {\n                            next(r) {\n                                if (!emitted && !done) { emitted = true; subscriber.onNext(r); }\n                            },\n                            error(e) { if (!done) { done = true; subscriber.onError(e); } },\n                            complete() { if (!done) { done = true; subscriber.onComplete(); } }\n                        };\n                        try { handler(v, sinkWrapper); }\n                        catch (e) { if (!done) { done = true; subscriber.onError(e instanceof Error ? e : new Error(String(e))); } }\n                        // Replenish: item was skipped (0 emissions) — request one more from upstream\n                        if (!done && !emitted) sourceSub.request(1);\n                    },\n                    onError(e) { if (!done) subscriber.onError(e); },\n                    onComplete() { if (!done) subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Maps each item to an inner publisher and merges all inner publishers concurrently\n     * into a single `Flux<R>` (**merge** semantics).\n     *\n     * Inner publishers are subscribed to as soon as their corresponding outer item arrives.\n     * Items from different inner publishers can interleave. The resulting stream completes\n     * when the outer source completes **and** all inner publishers complete. Any error\n     * (from outer or any inner) immediately terminates the stream.\n     *\n     * @param fn - Maps each item to a `Flux<R>`, `Mono<R>`, or any `Publisher<R>`.\n     * @returns A merged `Flux<R>`.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3)\n     *   .flatMap(n => Mono.just(n * 10))\n     *   .subscribe(v => console.log(v));\n     * // 10  20  30  (order may vary with async inner publishers)\n     * ```\n     */\n    public flatMap<R>(fn: (value: T) => Flux<R>): Flux<R>;\n    public flatMap<R>(fn: (value: T) => Mono<R>): Flux<R>;\n    public flatMap<R>(fn: (value: T) => Publisher<R>): Flux<R>;\n    public flatMap<R>(fn: (value: T) => Publisher<R>): Flux<R> {\n        return new Flux<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                let outerSub: Subscription = { request() {}, unsubscribe() {} };\n                const innerSubs = new Set<Subscription>();\n                let cancelled = false;\n                let terminated = false;\n                let outerDone = false;\n                let demand = 0;\n\n                // Cancel all upstream sources and signal terminal to downstream exactly once.\n                const terminate = (err?: Error) => {\n                    if (terminated) return;\n                    terminated = true;\n                    outerSub.unsubscribe();\n                    for (const s of innerSubs) s.unsubscribe();\n                    innerSubs.clear();\n                    if (err) subscriber.onError(err);\n                    else subscriber.onComplete();\n                };\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { terminate(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        for (const s of innerSubs) s.request(n);\n                    },\n                    unsubscribe() {\n                        cancelled = true;\n                        outerSub.unsubscribe();\n                        for (const s of innerSubs) s.unsubscribe();\n                        innerSubs.clear();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(sourceSub: Subscription) {\n                        outerSub = sourceSub;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (cancelled || terminated) return;\n                        let inner: Publisher<R>;\n                        try { inner = fn(v); }\n                        catch (e) { terminate(e instanceof Error ? e : new Error(String(e))); return; }\n                        const innerSub = inner.subscribe({\n                            onSubscribe(_s) {},\n                            onNext(r) { if (!cancelled && !terminated) subscriber.onNext(r); },\n                            onError(e) { terminate(e); },\n                            onComplete() {\n                                innerSubs.delete(innerSub);\n                                if (!terminated && outerDone && innerSubs.size === 0) terminate();\n                            }\n                        });\n                        innerSubs.add(innerSub);\n                        if (demand > 0) innerSub.request(demand);\n                    },\n                    onError(e) { terminate(e); },\n                    onComplete() {\n                        outerDone = true;\n                        if (!terminated && innerSubs.size === 0) terminate();\n                    }\n                });\n                outerSub.request(Number.MAX_SAFE_INTEGER);\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Maps each item to an inner publisher and subscribes to them **sequentially**,\n     * preserving order (**concat** semantics).\n     *\n     * The next inner publisher is subscribed to only after the previous one completes.\n     * This guarantees item ordering but has no concurrency.\n     *\n     * @param fn - Maps each item to a `Flux<R>`, `Mono<R>`, or any `Publisher<R>`.\n     * @returns An ordered, sequential `Flux<R>`.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3)\n     *   .concatMap(n => Mono.just(`item-${n}`))\n     *   .subscribe(v => console.log(v));\n     * // item-1  item-2  item-3\n     * ```\n     */\n    public concatMap<R>(fn: (value: T) => Flux<R>): Flux<R>;\n    public concatMap<R>(fn: (value: T) => Mono<R>): Flux<R>;\n    public concatMap<R>(fn: (value: T) => Publisher<R>): Flux<R>;\n    public concatMap<R>(fn: (value: T) => Publisher<R>): Flux<R> {\n        return new Flux<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                let outerSub!: Subscription;\n                let innerSub: Subscription | null = null;\n                let cancelled = false;\n                let terminated = false;\n                let outerDone = false;\n\n                const terminate = (err?: Error) => {\n                    if (terminated) return;\n                    terminated = true;\n                    outerSub?.unsubscribe();\n                    innerSub?.unsubscribe();\n                    innerSub = null;\n                    if (err) subscriber.onError(err);\n                    else subscriber.onComplete();\n                };\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { terminate(new Error(`request must be > 0, but was ${n}`)); return; }\n                        if (innerSub) innerSub.request(n);\n                        else outerSub.request(1);\n                    },\n                    unsubscribe() { cancelled = true; outerSub?.unsubscribe(); innerSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        outerSub = s;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (cancelled || terminated) return;\n                        let inner: Publisher<R>;\n                        try { inner = fn(v); }\n                        catch (e) { terminate(e instanceof Error ? e : new Error(String(e))); return; }\n                        inner.subscribe({\n                            onSubscribe(s) { innerSub = s; s.request(Number.MAX_SAFE_INTEGER); },\n                            onNext(r) { if (!cancelled && !terminated) subscriber.onNext(r); },\n                            onError(e) { terminate(e); },\n                            onComplete() {\n                                if (cancelled || terminated) return;\n                                innerSub = null;\n                                if (outerDone) terminate();\n                                else outerSub.request(1);\n                            }\n                        });\n                    },\n                    onError(e) { terminate(e); },\n                    onComplete() {\n                        outerDone = true;\n                        if (innerSub === null) terminate();\n                    }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Maps each item to an inner publisher, **cancelling** the previous inner subscription\n     * whenever a new outer item arrives (**switch** semantics).\n     *\n     * Only the most recently started inner publisher is active at any point. This is\n     * useful for patterns like \"search as you type\" where stale results should be\n     * discarded when a newer request supersedes them.\n     *\n     * @param fn - Maps each item to a `Flux<R>`, `Mono<R>`, or any `Publisher<R>`.\n     * @returns A `Flux<R>` that tracks only the latest inner publisher.\n     */\n    public switchMap<R>(fn: (value: T) => Flux<R>): Flux<R>;\n    public switchMap<R>(fn: (value: T) => Mono<R>): Flux<R>;\n    public switchMap<R>(fn: (value: T) => Publisher<R>): Flux<R>;\n    public switchMap<R>(fn: (value: T) => Publisher<R>): Flux<R> {\n        return new Flux<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                let outerSub!: Subscription;\n                let innerSub: Subscription | null = null;\n                let cancelled = false;\n                let terminated = false;\n                let outerDone = false;\n                let demand = 0;\n                let generation = 0;\n\n                const terminate = (err?: Error) => {\n                    if (terminated) return;\n                    terminated = true;\n                    outerSub?.unsubscribe();\n                    innerSub?.unsubscribe();\n                    innerSub = null;\n                    if (err) subscriber.onError(err);\n                    else subscriber.onComplete();\n                };\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { terminate(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (innerSub) innerSub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; outerSub?.unsubscribe(); innerSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        outerSub = s;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (cancelled || terminated) return;\n                        innerSub?.unsubscribe();\n                        innerSub = null;\n                        const myGen = ++generation;\n                        let inner: Publisher<R>;\n                        try { inner = fn(v); }\n                        catch (e) { terminate(e instanceof Error ? e : new Error(String(e))); return; }\n                        inner.subscribe({\n                            onSubscribe(s) {\n                                if (generation !== myGen || cancelled || terminated) { s.unsubscribe(); return; }\n                                innerSub = s;\n                                if (demand > 0) s.request(demand);\n                            },\n                            onNext(r) { if (generation === myGen && !cancelled && !terminated) subscriber.onNext(r); },\n                            onError(e) { if (generation === myGen) terminate(e); },\n                            onComplete() {\n                                if (generation !== myGen || cancelled || terminated) return;\n                                innerSub = null;\n                                if (outerDone) terminate();\n                            }\n                        });\n                    },\n                    onError(e) { terminate(e); },\n                    onComplete() {\n                        outerDone = true;\n                        if (innerSub === null) terminate();\n                    }\n                });\n                outerSub.request(Number.MAX_SAFE_INTEGER);\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Passes only items for which `predicate` returns `true`.\n     *\n     * Each dropped item replenishes upstream demand by 1 to keep the total\n     * outstanding demand accurate.\n     *\n     * @param predicate - Synchronous test applied to each item.\n     * @returns A filtered `Flux<T>`.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3, 4).filter(n => n % 2 === 0).subscribe(v => console.log(v));\n     * // 2  4\n     * ```\n     */\n    public filter(predicate: (value: T) => boolean): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let sourceSub!: Subscription;\n                const sub = this.source.subscribe({\n                    onSubscribe(s) { sourceSub = s; },\n                    onNext(v) {\n                        try {\n                            if (predicate(v)) subscriber.onNext(v);\n                            else sourceSub.request(1); // replenish: item skipped\n                        } catch (e) { subscriber.onError(e instanceof Error ? e : new Error(String(e))); }\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Asynchronous filter: for each item, subscribes to `predicate(item)` and forwards\n     * the item downstream only if the predicate publisher emits `true`.\n     *\n     * Implemented via {@link concatMap} — predicates run sequentially.\n     *\n     * @param predicate - Returns a `Publisher<boolean>` for each item.\n     * @returns A filtered `Flux<T>`.\n     */\n    public filterWhen(predicate: (value: T) => Publisher<boolean>): Flux<T> {\n        return this.concatMap(v =>\n            Flux.from(predicate(v))\n                .filter(pass => pass)\n                .map(() => v)\n        );\n    }\n\n    /**\n     * Unsafe type cast — changes the declared element type to `R` without any\n     * runtime conversion.  Use only when you are certain the actual runtime\n     * type is compatible.\n     *\n     * @typeParam R - The target element type.\n     * @returns This `Flux` re-typed as `Flux<R>`.\n     */\n    public cast<R>(): Flux<R> { return new Flux<R>(this.source as unknown as Publisher<R>); }\n\n    /**\n     * Emits at most `n` items, then cancels the upstream subscription and completes.\n     *\n     * If `n ≤ 0`, returns an empty `Flux` immediately.\n     *\n     * @param n - Maximum number of items to emit.\n     * @returns A bounded `Flux<T>`.\n     */\n    public take(n: number): Flux<T> {\n        if (n <= 0) return Flux.empty<T>();\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let sourceSub!: Subscription;\n                let count = 0;\n                let done = false;\n\n                const operatorSub: Subscription = {\n                    request(r: number) { if (!done) sourceSub?.request(r); },\n                    unsubscribe() { done = true; sourceSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        sourceSub = s;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (done) return;\n                        subscriber.onNext(v);\n                        if (++count >= n) {\n                            done = true;\n                            sourceSub.unsubscribe();\n                            subscriber.onComplete();\n                        }\n                    },\n                    onError(e: Error) { if (!done) subscriber.onError(e); },\n                    onComplete() { if (!done) subscriber.onComplete(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Emits items while `predicate(item)` returns `true`.\n     * Completes (and cancels upstream) on the first item for which it returns `false`.\n     *\n     * @param predicate - Tested synchronously for each item.\n     * @returns A `Flux<T>` that stops on the first `false`.\n     */\n    public takeWhile(predicate: (value: T) => boolean): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let sourceSub!: Subscription;\n                let done = false;\n\n                const operatorSub: Subscription = {\n                    request(n: number) { if (!done) sourceSub?.request(n); },\n                    unsubscribe() { done = true; sourceSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        sourceSub = s;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (done) return;\n                        try {\n                            if (predicate(v)) {\n                                subscriber.onNext(v);\n                            } else {\n                                done = true;\n                                sourceSub.unsubscribe();\n                                subscriber.onComplete();\n                            }\n                        } catch (e) {\n                            done = true;\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                        }\n                    },\n                    onError(e: Error) { if (!done) subscriber.onError(e); },\n                    onComplete() { if (!done) subscriber.onComplete(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Forwards items from this `Flux` until `trigger` emits its first item (or completes),\n     * then cancels the source and completes downstream.\n     *\n     * If `trigger` signals an error, that error is forwarded to the subscriber.\n     *\n     * @param trigger - A `Publisher` whose first emission ends this stream.\n     * @returns A `Flux<T>` that stops when the trigger fires.\n     */\n    public takeUntilOther(trigger: Publisher<unknown>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let sourceSub!: Subscription;\n                let triggerSub: Subscription;\n                let done = false;\n\n                const operatorSub: Subscription = {\n                    request(n: number) { if (!done) sourceSub?.request(n); },\n                    unsubscribe() { done = true; sourceSub?.unsubscribe(); triggerSub?.unsubscribe(); }\n                };\n\n                triggerSub = trigger.subscribe({\n                    onSubscribe(s) { triggerSub = s; s.request(1); },\n                    onNext(_v) {\n                        if (done) return;\n                        done = true;\n                        sourceSub?.unsubscribe();\n                        subscriber.onComplete();\n                    },\n                    onError(e) { if (!done) { done = true; subscriber.onError(e); } },\n                    onComplete() {}\n                });\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        sourceSub = s;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) { if (!done) subscriber.onNext(v); },\n                    onError(e: Error) { if (!done) subscriber.onError(e); },\n                    onComplete() { if (!done) { done = true; triggerSub?.unsubscribe(); subscriber.onComplete(); } }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /** Emit defaultValue if source completes without emitting any item. */\n    /**\n     * Emits `value` if the source completes without having emitted any items,\n     * then completes.  If the source does emit items, they pass through unchanged.\n     *\n     * @param value - Fallback item to emit when the source is empty.\n     * @returns A `Flux<T>` that is never empty.\n     */\n    public defaultIfEmpty(value: T): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let hasValue = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { hasValue = true; subscriber.onNext(v); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() {\n                        if (!hasValue) subscriber.onNext(value);\n                        subscriber.onComplete();\n                    }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Re-subscribes to the source on `onError`, up to `maxRetries` times.\n     *\n     * Accumulated downstream demand from previous attempts is preserved across retries.\n     * If the error persists after all retries are exhausted, it is forwarded to downstream.\n     *\n     * @param maxRetries - Maximum number of retry attempts (default: `Number.MAX_SAFE_INTEGER`).\n     * @returns A `Flux<T>` with automatic retry on error.\n     */\n    public retry(maxRetries: number = Number.MAX_SAFE_INTEGER): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let currentSub: Subscription = { request() {}, unsubscribe() {} };\n                let demand = 0;\n                let cancelled = false;\n                let retries = 0;\n                // Generation counter prevents stale onSubscribe callbacks (from earlier failed\n                // attempts) from overwriting currentSub after recursive attempt() calls return.\n                let generation = 0;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        currentSub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; currentSub.unsubscribe(); }\n                };\n\n                const attempt = () => {\n                    const myGen = ++generation;\n                    this.source.subscribe({\n                        onSubscribe(s: Subscription) {\n                            // Only accept if this is still the active attempt\n                            if (myGen !== generation) { s.unsubscribe(); return; }\n                            currentSub = s;\n                            if (demand > 0) s.request(demand);\n                        },\n                        onNext(v: T) { if (!cancelled && myGen === generation) subscriber.onNext(v); },\n                        onError(e: Error) {\n                            if (cancelled || myGen !== generation) return;\n                            if (retries < maxRetries) { retries++; attempt(); }\n                            else subscriber.onError(e);\n                        },\n                        onComplete() { if (!cancelled && myGen === generation) subscriber.onComplete(); }\n                    });\n                };\n\n                subscriber.onSubscribe(operatorSub);\n                attempt();\n\n                return operatorSub;\n            }\n        });\n    }\n\n    // ──────────────────── Scan / Zip ────────────────────────────────\n\n    /**\n     * Emits a running accumulation of the stream.\n     *\n     * The first item is emitted as-is and becomes the initial accumulator.\n     * Each subsequent item is combined with the running accumulator using `reducer`,\n     * and the result is emitted downstream.\n     *\n     * @param reducer - Combines the running accumulator with the next item.\n     * @returns A `Flux<T>` of intermediate accumulation results.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3, 4).scan((acc, n) => acc + n).subscribe(v => console.log(v));\n     * // 1  3  6  10\n     * ```\n     */\n    public scan(reducer: (acc: T, next: T) => T): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let acc: T | undefined;\n                let hasAcc = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        acc = hasAcc ? reducer(acc as T, v) : v;\n                        hasAcc = true;\n                        subscriber.onNext(acc);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Emits a running accumulation of the stream with an explicit seed value.\n     *\n     * `seedFactory` is called once per subscription to produce the initial accumulator.\n     * Each upstream item is folded into the accumulator and the intermediate result is\n     * emitted downstream.\n     *\n     * @param seedFactory - Called per subscription to produce the initial accumulator of type `A`.\n     * @param reducer - Combines the current accumulator with the next item.\n     * @returns A `Flux<A>` of intermediate accumulation results.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3).scanWith(() => 0, (acc, n) => acc + n).subscribe(v => console.log(v));\n     * // 1  3  6\n     * ```\n     */\n    public scanWith<A>(seedFactory: () => A, reducer: (acc: A, next: T) => A): Flux<A> {\n        return new Flux<A>({\n            subscribe: (subscriber: Subscriber<A>): Subscription => {\n                let acc = seedFactory();\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { acc = reducer(acc, v); subscriber.onNext(acc); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Pair-wise combines items from this `Flux` and `other` using `combiner`.\n     *\n     * Items are matched by position: the first item from each source is combined, then the second, etc.\n     * The stream completes when either source completes. If either source errors, the error is forwarded.\n     *\n     * @param other - The second publisher to zip with.\n     * @param combiner - Combines one item from each source into a result item.\n     * @returns A `Flux<V>` of combined pairs.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3)\n     *   .zipWith(Flux.just('a', 'b', 'c'), (n, s) => `${n}${s}`)\n     *   .subscribe(v => console.log(v));\n     * // 1a  2b  3c\n     * ```\n     */\n    public zipWith<R, V>(other: Publisher<R>, combiner: (a: T, b: R) => V): Flux<V> {\n        return new Flux<V>({\n            subscribe: (subscriber: Subscriber<V>): Subscription => {\n                const leftQueue: T[] = [];\n                const rightQueue: R[] = [];\n                let leftDone = false;\n                let rightDone = false;\n                let cancelled = false;\n                let terminated = false;\n\n                let leftSub: Subscription = { request() {}, unsubscribe() {} };\n                let rightSub: Subscription = { request() {}, unsubscribe() {} };\n\n                const terminate = (err?: Error) => {\n                    if (terminated) return;\n                    terminated = true;\n                    leftSub.unsubscribe();\n                    rightSub.unsubscribe();\n                    if (err) subscriber.onError(err);\n                    else subscriber.onComplete();\n                };\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { terminate(new Error(`request must be > 0, but was ${n}`)); return; }\n                        leftSub.request(n);\n                        rightSub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; leftSub.unsubscribe(); rightSub.unsubscribe(); }\n                };\n\n                const tryEmit = () => {\n                    while (leftQueue.length > 0 && rightQueue.length > 0) {\n                        if (cancelled || terminated) return;\n                        const l = leftQueue.shift()!;\n                        const r = rightQueue.shift()!;\n                        try { subscriber.onNext(combiner(l, r)); }\n                        catch (e) { terminate(e instanceof Error ? e : new Error(String(e))); return; }\n                    }\n                    if ((leftDone && leftQueue.length === 0) || (rightDone && rightQueue.length === 0)) {\n                        terminate();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        leftSub = s;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) { if (!cancelled && !terminated) { leftQueue.push(v); tryEmit(); } },\n                    onError(e: Error) { terminate(e); },\n                    onComplete() { if (!cancelled && !terminated) { leftDone = true; tryEmit(); } }\n                });\n\n                rightSub = other.subscribe({\n                    onSubscribe(s: Subscription) { rightSub = s; },\n                    onNext(v: R) { if (!cancelled && !terminated) { rightQueue.push(v); tryEmit(); } },\n                    onError(e: Error) { terminate(e); },\n                    onComplete() { if (!cancelled && !terminated) { rightDone = true; tryEmit(); } }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    // ──────────────────── Side effects ───────────────────────────────\n\n    /**\n     * Executes a side-effect function when the source completes normally.\n     *\n     * The function runs just before `onComplete` is forwarded to the downstream subscriber.\n     * Any exception thrown by `fn` is silently swallowed.\n     *\n     * @param fn - Side-effect to run on normal completion.\n     * @returns A `Flux<T>` with the side effect attached.\n     */\n    public doOnComplete(fn: () => void): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { try { fn(); } catch (_) {} subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Executes a side-effect function when the source terminates — either normally (`onComplete`)\n     * or with an error (`onError`).\n     *\n     * The function runs before the terminal signal is forwarded downstream.\n     * Any exception thrown by `fn` is silently swallowed.\n     *\n     * @param fn - Side-effect to run on any terminal signal.\n     * @returns A `Flux<T>` with the side effect attached.\n     */\n    public doOnTerminate(fn: () => void): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) { try { fn(); } catch (_) {} subscriber.onError(e); },\n                    onComplete() { try { fn(); } catch (_) {} subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Executes a side-effect function when the downstream subscriber cancels\n     * (calls `unsubscribe()`).\n     *\n     * Any exception thrown by `fn` is silently swallowed.\n     *\n     * @param fn - Side-effect to run on cancellation.\n     * @returns A `Flux<T>` with the side effect attached.\n     */\n    public doOnCancel(fn: () => void): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const inner = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                const sub: Subscription = {\n                    request(n) { inner.request(n); },\n                    unsubscribe() { try { fn(); } catch (_) {} inner.unsubscribe(); }\n                };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Executes a side-effect function after the stream ends for **any** reason —\n     * normal completion, error, or cancellation.\n     *\n     * Any exception thrown by `fn` is silently swallowed.\n     *\n     * @param fn - Side-effect to run after any terminal event or cancellation.\n     * @returns A `Flux<T>` with the side effect attached.\n     */\n    public doFinally(fn: () => void): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const inner = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) { try { fn(); } catch (_) {} subscriber.onError(e); },\n                    onComplete() { try { fn(); } catch (_) {} subscriber.onComplete(); }\n                });\n                const sub: Subscription = {\n                    request(n) { inner.request(n); },\n                    unsubscribe() { try { fn(); } catch (_) {} inner.unsubscribe(); }\n                };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    // ──────────────────── Scheduling ────────────────────────────────\n\n    /**\n     * Low-level escape hatch for bridging imperative push-based sources.\n     *\n     * The `producer` receives three callbacks and must call them to drive the stream.\n     * `onRequest` and `onUnsubscribe` let the caller respond to downstream demand and\n     * cancellation respectively.\n     *\n     * @param producer - Callback that receives `(onNext, onError, onComplete)` and drives the stream.\n     * @param onRequest - Called when the downstream subscriber requests `n` more items.\n     * @param onUnsubscribe - Called when the downstream subscriber cancels.\n     * @returns A `Flux<R>` backed by the imperative producer.\n     */\n    public pipe<R>(\n        producer: (onNext: (value: R) => void, onError: (error: Error) => void, onComplete: () => void) => void,\n        onRequest: (request: number) => void,\n        onUnsubscribe: () => void\n    ): Flux<R> {\n        return new Flux<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                producer(v => subscriber.onNext(v), e => subscriber.onError(e), () => subscriber.onComplete());\n                const sub = { request: onRequest, unsubscribe: onUnsubscribe };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    // ──────────────────── Flux-specific operators ────────────────────────\n\n    /**\n     * Returns the first item of this `Flux` as a `Mono`.\n     *\n     * If the source is empty, the resulting `Mono` completes without emitting a value.\n     * The source subscription is cancelled immediately after the first item is received.\n     *\n     * @returns A `Mono<T>` that emits the first item, or completes empty.\n     */\n    public first(): Mono<T> {\n        return Mono.generate<T>(sink => {\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) { sub.unsubscribe(); sink.next(v); },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.complete(); }\n            });\n            sub.request(1);\n        });\n    }\n\n    /**\n     * Returns the last item of this `Flux` as a `Mono`.\n     *\n     * The source is fully consumed before the value is emitted.\n     * If the source is empty, the resulting `Mono` completes without emitting a value.\n     *\n     * @returns A `Mono<T>` that emits the last item, or completes empty.\n     */\n    public last(): Mono<T> {\n        return Mono.generate<T>(sink => {\n            let last: T | undefined;\n            let hasValue = false;\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) { last = v; hasValue = true; },\n                onError(e) { sink.error(e); },\n                onComplete() {\n                    if (hasValue) sink.next(last as T);\n                    else sink.complete();\n                }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Counts all items emitted by this `Flux` and emits the total as a `Mono<number>`.\n     *\n     * The source is fully consumed before the count is emitted.\n     *\n     * @returns A `Mono<number>` emitting the number of items.\n     */\n    public count(): Mono<number> {\n        return Mono.generate<number>(sink => {\n            let n = 0;\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(_v) { n++; },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.next(n); }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Emits `true` if this `Flux` emits at least one item, `false` if it completes empty.\n     *\n     * The source subscription is cancelled as soon as the first item is observed.\n     *\n     * @returns A `Mono<boolean>`.\n     */\n    public hasElements(): Mono<boolean> {\n        return Mono.generate<boolean>(sink => {\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(_v) { sub.unsubscribe(); sink.next(true); },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.next(false); }\n            });\n            sub.request(1);\n        });\n    }\n\n    /**\n     * Emits `true` if any item matches `predicate`, `false` if none do.\n     *\n     * Short-circuits: cancels the source and emits `true` on the first matching item.\n     * If `predicate` throws, the error is forwarded to the subscriber.\n     *\n     * @param predicate - Test applied to each item.\n     * @returns A `Mono<boolean>`.\n     */\n    public any(predicate: (value: T) => boolean): Mono<boolean> {\n        return Mono.generate<boolean>(sink => {\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) {\n                    try {\n                        if (predicate(v)) { sub.unsubscribe(); sink.next(true); }\n                    } catch (e) { sink.error(e instanceof Error ? e : new Error(String(e))); }\n                },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.next(false); }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Emits `true` if every item matches `predicate`, `false` if any item does not.\n     *\n     * Short-circuits: cancels the source and emits `false` on the first non-matching item.\n     * If `predicate` throws, the error is forwarded to the subscriber.\n     *\n     * @param predicate - Test applied to each item.\n     * @returns A `Mono<boolean>`.\n     */\n    public all(predicate: (value: T) => boolean): Mono<boolean> {\n        return Mono.generate<boolean>(sink => {\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) {\n                    try {\n                        if (!predicate(v)) { sub.unsubscribe(); sink.next(false); }\n                    } catch (e) { sink.error(e instanceof Error ? e : new Error(String(e))); }\n                },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.next(true); }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Emits `true` if no item matches `predicate`, `false` if any item does.\n     *\n     * This is the logical negation of {@link any}.\n     *\n     * @param predicate - Test applied to each item.\n     * @returns A `Mono<boolean>`.\n     */\n    public none(predicate: (value: T) => boolean): Mono<boolean> {\n        return this.any(predicate).map(v => !v);\n    }\n\n    /**\n     * Returns the item at zero-based `index` as a `Mono<T>`.\n     *\n     * If the source completes before reaching `index`, emits `defaultValue` if provided,\n     * otherwise completes empty.\n     *\n     * @param index - Zero-based position of the desired item.\n     * @param defaultValue - Optional fallback value emitted if the index is out of range.\n     * @returns A `Mono<T>`.\n     */\n    public elementAt(index: number, defaultValue?: T): Mono<T> {\n        return Mono.generate<T>(sink => {\n            let i = 0;\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) {\n                    if (i++ === index) { sub.unsubscribe(); sink.next(v); }\n                },\n                onError(e) { sink.error(e); },\n                onComplete() {\n                    if (defaultValue !== undefined) sink.next(defaultValue);\n                    else sink.complete();\n                }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Collects all items into an array and emits the complete array as a `Mono<T[]>`.\n     *\n     * The source is fully consumed before the array is emitted.\n     *\n     * @returns A `Mono<T[]>` containing all emitted items.\n     */\n    public collect(_force: boolean = false): Mono<T[]> {\n        return Mono.generate<T[]>(sink => {\n            const items: T[] = [];\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) { items.push(v); },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.next(items); }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Alias for {@link collect}.\n     *\n     * @returns A `Mono<T[]>` containing all emitted items.\n     */\n    public collectList(): Mono<T[]> {\n        return this.collect();\n    }\n\n    /**\n     * Collects all items, sorts them, and re-emits them as a `Flux<T>`.\n     *\n     * Uses the native `Array.sort` algorithm. When no `comparator` is provided the\n     * default lexicographic sort order is used.\n     *\n     * @param comparator - Optional comparison function (same signature as `Array.sort`).\n     * @returns A `Flux<T>` that emits items in sorted order after the source completes.\n     */\n    public sort(comparator?: (a: T, b: T) => number): Flux<T> {\n        return Flux.defer(() =>\n            Flux.from(this.collect().map(arr => {\n                arr.sort(comparator);\n                return arr;\n            }).flatMapMany(arr => Flux.fromIterable(arr)))\n        );\n    }\n\n    /**\n     * Collects items into fixed-size arrays and emits each batch as a `T[]`.\n     *\n     * A batch is emitted as soon as it reaches `maxSize` items.\n     * The final (potentially partial) batch is emitted when the source completes.\n     *\n     * @param maxSize - Maximum number of items per batch.\n     * @returns A `Flux<T[]>` of item batches.\n     *\n     * @example\n     * ```typescript\n     * Flux.range(1, 5).buffer(2).subscribe(v => console.log(v));\n     * // [1, 2]  [3, 4]  [5]\n     * ```\n     */\n    public buffer(maxSize: number): Flux<T[]> {\n        return new Flux<T[]>({\n            subscribe: (subscriber: Subscriber<T[]>): Subscription => {\n                let batch: T[] = [];\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        batch.push(v);\n                        if (batch.length >= maxSize) {\n                            subscriber.onNext(batch);\n                            batch = [];\n                        }\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() {\n                        if (batch.length > 0) subscriber.onNext(batch);\n                        subscriber.onComplete();\n                    }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Caches all emitted items and replays them to each new subscriber.\n     *\n     * The source is subscribed to on the **first** downstream subscription (lazy connect).\n     * Subsequent subscribers receive a replay of all previously emitted items from the cache.\n     *\n     * @returns A cached, replayable `Flux<T>`.\n     */\n    public cache(): Flux<T> {\n        const sink = new ReplayAllSink<T>();\n        let connected = false;\n\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                if (!connected) {\n                    connected = true;\n                    this.source.subscribe({\n                        onSubscribe(s) { s.request(Number.MAX_SAFE_INTEGER); },\n                        onNext(v) { sink.next(v); },\n                        onError(e) { sink.error(e); },\n                        onComplete() { sink.complete(); }\n                    });\n                }\n                return sink.subscribe(subscriber);\n            }\n        });\n    }\n\n    /**\n     * Multicasts this `Flux` to all current subscribers using a refCounting strategy.\n     *\n     * The upstream is subscribed to when the **first** subscriber joins and cancelled\n     * when the **last** subscriber leaves. If a new subscriber arrives after all others\n     * have cancelled, a fresh upstream subscription is created.\n     *\n     * Items are delivered on a best-effort basis: a subscriber that has no outstanding\n     * demand when an item arrives simply misses that item (no buffering). Once the upstream\n     * terminates (complete or error), the terminal signal is replayed to any future subscriber.\n     *\n     * @returns A hot `Flux<T>` that shares a single upstream subscription.\n     *\n     * @example\n     * ```typescript\n     * const shared = Flux.interval(100).share();\n     * shared.subscribe(v => console.log('A', v));\n     * setTimeout(() => shared.subscribe(v => console.log('B', v)), 250);\n     * // A 0, A 1, A 2, B 2, A 3, B 3 ...\n     * ```\n     */\n    public share(): Flux<T> {\n        type Entry = { demand: number; cancelled: boolean };\n        const entries = new Map<Subscriber<T>, Entry>();\n        let upstreamSub: Subscription | null = null;\n        let terminated = false;\n        let terminalError: Error | null = null;\n\n        const source = this.source;\n\n        const connect = () => {\n            terminated = false;\n            terminalError = null;\n            source.subscribe({\n                onSubscribe(s) {\n                    upstreamSub = s;\n                    s.request(Number.MAX_SAFE_INTEGER);\n                },\n                onNext(v: T) {\n                    for (const [sub, entry] of entries) {\n                        if (!entry.cancelled && entry.demand > 0) {\n                            entry.demand--;\n                            sub.onNext(v);\n                        }\n                    }\n                },\n                onError(e: Error) {\n                    terminated = true;\n                    terminalError = e;\n                    upstreamSub = null;\n                    for (const [sub, entry] of entries) {\n                        if (!entry.cancelled) sub.onError(e);\n                    }\n                    entries.clear();\n                },\n                onComplete() {\n                    terminated = true;\n                    upstreamSub = null;\n                    for (const [sub, entry] of entries) {\n                        if (!entry.cancelled) sub.onComplete();\n                    }\n                    entries.clear();\n                }\n            });\n        };\n\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                if (terminated) {\n                    const sub = { request() {}, unsubscribe() {} };\n                    subscriber.onSubscribe(sub);\n                    terminalError ? subscriber.onError(terminalError) : subscriber.onComplete();\n                    return sub;\n                }\n\n                const entry: Entry = { demand: 0, cancelled: false };\n                entries.set(subscriber, entry);\n\n                const sub: Subscription = {\n                    request(n: number) {\n                        if (entry.cancelled) return;\n                        if (n <= 0) {\n                            entry.cancelled = true;\n                            entries.delete(subscriber);\n                            subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                            return;\n                        }\n                        entry.demand = Math.min(entry.demand + n, Number.MAX_SAFE_INTEGER);\n                        if (!upstreamSub && !terminated) {\n                            connect();\n                        }\n                    },\n                    unsubscribe() {\n                        if (entry.cancelled) return;\n                        entry.cancelled = true;\n                        entries.delete(subscriber);\n                        if (entries.size === 0 && upstreamSub) {\n                            upstreamSub.unsubscribe();\n                            upstreamSub = null;\n                        }\n                    }\n                };\n\n                subscriber.onSubscribe(sub);\n\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Pairs each item with its zero-based index, emitting `[index, item]` tuples.\n     *\n     * @returns A `Flux<[number, T]>` where the first element is the zero-based index.\n     *\n     * @example\n     * ```typescript\n     * Flux.just('a', 'b', 'c').indexed().subscribe(([i, v]) => console.log(i, v));\n     * // 0 a  1 b  2 c\n     * ```\n     */\n    public indexed(): Flux<[number, T]> {\n        return new Flux<[number, T]>({\n            subscribe: (subscriber: Subscriber<[number, T]>): Subscription => {\n                let index = 0;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext([index++, v]); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Skips the first `n` items from the source, then forwards the rest.\n     *\n     * Skipped items replenish upstream demand so the overall demand accounting stays correct.\n     *\n     * @param n - Number of leading items to skip.\n     * @returns A `Flux<T>` without the first `n` items.\n     */\n    public skip(n: number): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let skipped = 0;\n                let sourceSub!: Subscription;\n                const sub = this.source.subscribe({\n                    onSubscribe(s) { sourceSub = s; },\n                    onNext(v) {\n                        if (skipped++ < n) sourceSub.request(1); // replenish: item skipped\n                        else subscriber.onNext(v);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Skips items while `predicate` returns `true`, then forwards all subsequent items\n     * regardless of the predicate.\n     *\n     * Skipped items replenish upstream demand. Once the predicate returns `false`, it is\n     * never evaluated again.\n     *\n     * @param predicate - Tested against each item until it returns `false`.\n     * @returns A `Flux<T>` that starts forwarding items after the first predicate failure.\n     */\n    public skipWhile(predicate: (value: T) => boolean): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let skipping = true;\n                let sourceSub!: Subscription;\n                const sub = this.source.subscribe({\n                    onSubscribe(s) { sourceSub = s; },\n                    onNext(v) {\n                        if (skipping && predicate(v)) { sourceSub.request(1); return; }\n                        skipping = false;\n                        subscriber.onNext(v);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Gates items from this `Flux` until `other` emits its first item.\n     *\n     * Items arriving before the gate opens are silently dropped (demand is replenished).\n     * If `other` signals an error, the error is forwarded to downstream.\n     *\n     * @param other - A `Publisher` whose first emission opens the gate.\n     * @returns A `Flux<T>` that starts forwarding items once `other` emits.\n     */\n    public skipUntil(other: Publisher<unknown>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let gating = true;\n                let primarySub: Subscription;\n                const triggerSub = other.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(_v) { gating = false; triggerSub.unsubscribe(); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() {}\n                });\n                triggerSub.request(1);\n                primarySub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { if (!gating) subscriber.onNext(v); else primarySub.request(1); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe({\n                    request(n) { primarySub.request(n); },\n                    unsubscribe() { primarySub.unsubscribe(); triggerSub.unsubscribe(); }\n                });\n                return { request(n) { primarySub.request(n); }, unsubscribe() { primarySub.unsubscribe(); triggerSub.unsubscribe(); } };\n            }\n        });\n    }\n\n    /**\n     * Filters out duplicate items, forwarding only items not seen before.\n     *\n     * Uses a `Set` with reference equality (`===`) to track seen values.\n     * Duplicates replenish upstream demand.\n     *\n     * @returns A `Flux<T>` with all duplicate items removed.\n     */\n    public distinct(): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const seen = new Set<T>();\n                let sourceSub!: Subscription;\n                const sub = this.source.subscribe({\n                    onSubscribe(s) { sourceSub = s; },\n                    onNext(v) { if (!seen.has(v)) { seen.add(v); subscriber.onNext(v); } else sourceSub.request(1); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Suppresses consecutive duplicate items.\n     *\n     * An item is forwarded only when it is different from the immediately preceding item\n     * as determined by `comparator`. The default comparator uses `!==`.\n     * Suppressed items replenish upstream demand.\n     *\n     * @param comparator - Returns `true` when two consecutive items are considered different\n     *                     (default: `(a, b) => a !== b`).\n     * @returns A `Flux<T>` without consecutive duplicates.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 1, 2, 2, 3).distinctUntilChanged().subscribe(v => console.log(v));\n     * // 1  2  3\n     * ```\n     */\n    public distinctUntilChanged(comparator: (a: T, b: T) => boolean = (a, b) => a !== b): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let prev: T | undefined;\n                let first = true;\n                let sourceSub!: Subscription;\n                const sub = this.source.subscribe({\n                    onSubscribe(s) { sourceSub = s; },\n                    onNext(v) {\n                        if (first || comparator(prev as T, v)) {\n                            first = false;\n                            prev = v;\n                            subscriber.onNext(v);\n                        } else sourceSub.request(1);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Delays the delivery of each item by `ms` milliseconds.\n     *\n     * Items are processed **one at a time**: the next item is requested from the source\n     * only after the previous delayed item has been delivered downstream.  This guarantees\n     * items are spaced at least `ms` apart and that `onComplete` fires only after the last\n     * delayed item has been delivered.\n     *\n     * Errors are forwarded immediately without delay, cancelling any pending timer.\n     *\n     * @param ms - Delay in milliseconds between consecutive item deliveries.\n     * @returns A `Flux<T>` where each item is delayed by `ms` before being forwarded.\n     */\n    public delayElements(ms: number): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let sourceSub: Subscription = { request() {}, unsubscribe() {} };\n                let pending: { cancel(): void } | null = null;\n                let cancelled = false;\n                let demand = 0;\n                let sourceCompleted = false;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        const wasZero = demand === 0;\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        // Only pull from source if no item is currently in-flight (timer pending).\n                        if (wasZero && pending === null) sourceSub.request(1);\n                    },\n                    unsubscribe() {\n                        cancelled = true;\n                        pending?.cancel();\n                        pending = null;\n                        sourceSub.unsubscribe();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        sourceSub = s;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        pending = Schedulers.delay(ms).schedule(() => {\n                            pending = null;\n                            if (cancelled) return;\n                            demand--;\n                            subscriber.onNext(v);\n                            if (cancelled) return;\n                            if (sourceCompleted) {\n                                subscriber.onComplete();\n                            } else if (demand > 0) {\n                                sourceSub.request(1);\n                            }\n                        });\n                    },\n                    onError(e: Error) {\n                        pending?.cancel();\n                        pending = null;\n                        subscriber.onError(e);\n                    },\n                    onComplete() {\n                        sourceCompleted = true;\n                        // If no item is in-flight, complete immediately.\n                        // Otherwise the pending timer will deliver the last item and then complete.\n                        if (pending === null && !cancelled) subscriber.onComplete();\n                    }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Appends `other` to this `Flux`, subscribing to `other` only after this source completes.\n     *\n     * Items from this source are emitted first, in order.  Once this source completes,\n     * items from `other` are emitted.  If either source errors, the error is forwarded\n     * and `other` is not subscribed to.\n     *\n     * @param other - The publisher to concatenate after this source.\n     * @returns A `Flux<T>` that emits items from both sources sequentially.\n     */\n    public concatWith(other: Publisher<T>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let primarySub: Subscription = { request() {}, unsubscribe() {} };\n                let otherSub: Subscription | null = null;\n                let cancelled = false;\n                let demand = 0;\n\n                const operatorSub: Subscription = {\n                    request(n) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (otherSub) otherSub.request(n); else primarySub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; primarySub.unsubscribe(); otherSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(sourceSub: Subscription) {\n                        primarySub = sourceSub;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() {\n                        if (cancelled) return;\n                        otherSub = other.subscribe({\n                            onSubscribe(otherSourceSub: Subscription) {\n                                otherSub = otherSourceSub;\n                                if (demand > 0) otherSub.request(demand);\n                            },\n                            onNext(v) { subscriber.onNext(v); },\n                            onError(e) { subscriber.onError(e); },\n                            onComplete() { subscriber.onComplete(); }\n                        });\n                    }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Merges this `Flux` with `other`, subscribing to both concurrently.\n     *\n     * Items from both sources are interleaved as they arrive. The resulting stream\n     * completes when **both** sources complete. Any error from either source terminates\n     * the merged stream immediately.\n     *\n     * @param other - The publisher to merge with this source.\n     * @returns A `Flux<T>` that emits items from both sources concurrently.\n     */\n    public mergeWith(other: Publisher<T>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let doneCount = 0;\n                let cancelled = false;\n                let terminated = false;\n\n                let primarySub: Subscription = { request() {}, unsubscribe() {} };\n                let otherSubRef: Subscription = { request() {}, unsubscribe() {} };\n\n                const terminate = (err?: Error) => {\n                    if (terminated) return;\n                    terminated = true;\n                    primarySub.unsubscribe();\n                    otherSubRef.unsubscribe();\n                    if (err) subscriber.onError(err);\n                    else subscriber.onComplete();\n                };\n\n                const done = () => { if (!terminated && ++doneCount === 2) terminate(); };\n\n                const operatorSub: Subscription = {\n                    request(n) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { terminate(new Error(`request must be > 0, but was ${n}`)); return; }\n                        primarySub.request(n);\n                        otherSubRef.request(n);\n                    },\n                    unsubscribe() { cancelled = true; primarySub.unsubscribe(); otherSubRef.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(sourceSub: Subscription) {\n                        primarySub = sourceSub;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v) { if (!cancelled && !terminated) subscriber.onNext(v); },\n                    onError(e) { terminate(e); },\n                    onComplete() { done(); }\n                });\n\n                otherSubRef = other.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { if (!cancelled && !terminated) subscriber.onNext(v); },\n                    onError(e) { terminate(e); },\n                    onComplete() { done(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Reduces the stream to a single value using `reducer`, emitting the final result as a `Mono<T>`.\n     *\n     * The first item becomes the initial accumulator. If the source is empty, the resulting\n     * `Mono` completes without emitting a value.\n     *\n     * @param reducer - Combines the running accumulator with the next item.\n     * @returns A `Mono<T>` emitting the final reduced value.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3, 4).reduce((acc, n) => acc + n).subscribe(v => console.log(v));\n     * // 10\n     * ```\n     */\n    public reduce(reducer: (acc: T, next: T) => T): Mono<T> {\n        return Mono.generate<T>(sink => {\n            let acc: T | undefined;\n            let hasValue = false;\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) { acc = hasValue ? reducer(acc as T, v) : v; hasValue = true; },\n                onError(e) { sink.error(e); },\n                onComplete() {\n                    if (hasValue) sink.next(acc as T);\n                    else sink.complete();\n                }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Reduces the stream to a single value of type `A`, using an explicit seed, and emits it as `Mono<A>`.\n     *\n     * `seedFactory` is called once per subscription to produce the initial accumulator.\n     * Unlike {@link reduce}, this always emits a value even if the source is empty (the seed).\n     *\n     * @param seedFactory - Produces the initial accumulator value per subscription.\n     * @param reducer - Combines the running accumulator with the next item.\n     * @returns A `Mono<A>` emitting the final reduced value.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3)\n     *   .reduceWith(() => '', (acc, n) => acc + n)\n     *   .subscribe(v => console.log(v)); // '123'\n     * ```\n     */\n    public reduceWith<A>(seedFactory: () => A, reducer: (acc: A, next: T) => A): Mono<A> {\n        return Mono.generate<A>(sink => {\n            let acc = seedFactory();\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) { acc = reducer(acc, v); },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.next(acc); }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Ignores all items from this `Flux` and emits a single `void` value on completion.\n     *\n     * Useful when you care only about the completion signal, not about the emitted items.\n     * If the source errors, the error is forwarded.\n     *\n     * @returns A `Mono<void>` that signals when this `Flux` completes.\n     */\n    public then(): Mono<void> {\n        return Mono.generate<void>(sink => {\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(_v) {},\n                onError(e) { sink.error(e); },\n                onComplete() { sink.next(undefined); }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    /**\n     * Ignores all items from this `Flux`, then subscribes to `other` after this source completes,\n     * draining `other` completely and returning a `Mono<void>`.\n     *\n     * If this source or `other` errors, the error is forwarded.\n     *\n     * @param other - A `Publisher` to subscribe to after this source completes.\n     * @returns A `Mono<void>` that completes once `other` completes.\n     */\n    public thenEmpty(other: Publisher<unknown>): Mono<void> {\n        return this.then().flatMap(() => Mono.from<void>({\n            subscribe(subscriber: Subscriber<void>): Subscription {\n                const sub = other.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(_v) {},\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onNext(undefined); subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        }));\n    }\n\n    // ──────────────────── Advanced / Flux-specific operators ─────────────────\n\n    /**\n     * Re-subscribes to the source when the publisher returned by `fn` emits,\n     * enabling controlled retry with strategies like exponential back-off.\n     *\n     * `fn` receives a `Flux<Error>` — the stream of errors emitted by each failed attempt.\n     * Each emission from the returned publisher triggers a retry.\n     * When the returned publisher completes or errors, the retry loop stops.\n     *\n     * @param fn - Receives an error stream and returns a control publisher.\n     * @returns A `Flux<T>` with dynamic retry behaviour.\n     *\n     * @example\n     * ```typescript\n     * // Exponential back-off: wait 2^n × 100ms between retries, max 3 retries\n     * flux.retryWhen(errors =>\n     *   errors.zipWith(Flux.range(1, 3), (_, n) => n)\n     *         .flatMap(n => Mono.delay(n * 100))\n     * );\n     * ```\n     */\n    public retryWhen(fn: (errors: Flux<Error>) => Publisher<unknown>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const errBuf: Error[] = [];\n                let errSub: Subscriber<Error> | null = null;\n                let errDemand = 0;\n\n                const pushErr = (e: Error) => {\n                    errBuf.push(e);\n                    drainErrs();\n                };\n                const drainErrs = () => {\n                    while (errDemand > 0 && errBuf.length > 0 && errSub) {\n                        errDemand--;\n                        errSub.onNext(errBuf.shift()!);\n                    }\n                };\n\n                const errorFlux = new Flux<Error>({\n                    subscribe(sub: Subscriber<Error>): Subscription {\n                        errSub = sub;\n                        const relay: Subscription = {\n                            request(n) { errDemand = Math.min(errDemand + n, Number.MAX_SAFE_INTEGER); drainErrs(); },\n                            unsubscribe() { errSub = null; }\n                        };\n                        sub.onSubscribe(relay);\n                        return relay;\n                    }\n                });\n\n                let currentSub: Subscription = { request() {}, unsubscribe() {} };\n                let demand = 0;\n                let cancelled = false;\n                let terminated = false;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        currentSub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; currentSub.unsubscribe(); }\n                };\n\n                const attempt = () => {\n                    this.source.subscribe({\n                        onSubscribe(s: Subscription) { currentSub = s; if (demand > 0) s.request(demand); },\n                        onNext(v: T) { if (!cancelled && !terminated) subscriber.onNext(v); },\n                        onError(e: Error) { if (!cancelled && !terminated) pushErr(e); },\n                        onComplete() {\n                            if (!cancelled && !terminated) {\n                                terminated = true;\n                                errSub?.onComplete();\n                                subscriber.onComplete();\n                            }\n                        }\n                    });\n                };\n\n                fn(errorFlux).subscribe({\n                    onSubscribe(s) { s.request(Number.MAX_SAFE_INTEGER); },\n                    onNext(_v) { if (!cancelled && !terminated) { currentSub.unsubscribe(); attempt(); } },\n                    onError(e: Error) { if (!cancelled && !terminated) { terminated = true; subscriber.onError(e); } },\n                    onComplete() { if (!cancelled && !terminated) { terminated = true; subscriber.onComplete(); } }\n                });\n\n                subscriber.onSubscribe(operatorSub);\n                attempt();\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Re-subscribes to the source each time it completes normally, as controlled by\n     * the publisher returned by `fn` (**polling** semantics).\n     *\n     * `fn` receives a `Flux<void>` — one emission per completion. Each emission triggers\n     * a repeat. When the control publisher completes or errors, the loop stops.\n     *\n     * @param fn - Receives a completion-signal stream and returns a control publisher.\n     * @returns A `Flux<T>` that repeats under the control of `fn`.\n     *\n     * @example\n     * ```typescript\n     * // Poll every second, stop after 5 times\n     * fetchLatest()\n     *   .toFlux()\n     *   .repeatWhen(completes => completes.zipWith(Flux.range(1, 5), (_, n) => n)\n     *                                     .flatMap(() => Mono.delay(1000)));\n     * ```\n     */\n    public repeatWhen(fn: (completes: Flux<void>) => Publisher<unknown>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const compBuf: void[] = [];\n                let compSub: Subscriber<void> | null = null;\n                let compDemand = 0;\n                let drainingComps = false;\n\n                const drainComps = () => {\n                    if (drainingComps) return;\n                    drainingComps = true;\n                    try {\n                        while (!terminated && !cancelled && compDemand > 0 && compBuf.length > 0 && compSub) {\n                            compDemand--;\n                            compSub.onNext(compBuf.shift()!);\n                        }\n                    } finally { drainingComps = false; }\n                };\n\n                const pushComp = () => {\n                    compBuf.push(undefined);\n                    drainComps();\n                };\n\n                const completeFlux = new Flux<void>({\n                    subscribe(sub: Subscriber<void>): Subscription {\n                        compSub = sub;\n                        const relay: Subscription = {\n                            request(n) { compDemand = Math.min(compDemand + n, Number.MAX_SAFE_INTEGER); drainComps(); },\n                            unsubscribe() { compSub = null; }\n                        };\n                        sub.onSubscribe(relay);\n                        return relay;\n                    }\n                });\n\n                let currentSub: Subscription = { request() {}, unsubscribe() {} };\n                let demand = 0;\n                let cancelled = false;\n                let terminated = false;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        currentSub.request(n);\n                    },\n                    unsubscribe() { cancelled = true; currentSub.unsubscribe(); }\n                };\n\n                const attempt = () => {\n                    this.source.subscribe({\n                        onSubscribe(s: Subscription) { currentSub = s; if (demand > 0) s.request(demand); },\n                        onNext(v: T) { if (!cancelled && !terminated) subscriber.onNext(v); },\n                        onError(e: Error) { if (!cancelled && !terminated) { terminated = true; subscriber.onError(e); } },\n                        onComplete() { if (!cancelled && !terminated) pushComp(); }\n                    });\n                };\n\n                fn(completeFlux).subscribe({\n                    onSubscribe(s) { s.request(Number.MAX_SAFE_INTEGER); },\n                    onNext(_v) { if (!cancelled && !terminated) { currentSub.unsubscribe(); attempt(); } },\n                    onError(e: Error) { if (!cancelled && !terminated) { terminated = true; subscriber.onError(e); } },\n                    onComplete() { if (!cancelled && !terminated) { terminated = true; subscriber.onComplete(); } }\n                });\n\n                subscriber.onSubscribe(operatorSub);\n                attempt();\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Groups items by a key derived from `keyFn`, emitting a {@link GroupedFlux} per\n     * unique key. Each `GroupedFlux` is itself a `Flux<T>` exposing the group `key`.\n     *\n     * The source is consumed at full speed. Items are routed to the corresponding group's\n     * buffer and replayed to any subscriber of that group.\n     *\n     * @param keyFn - Extracts the group key from each item.\n     * @returns A `Flux<GroupedFlux<K, T>>` emitting one group per unique key.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3, 4, 5)\n     *   .groupBy(n => n % 2 === 0 ? 'even' : 'odd')\n     *   .flatMap(group => group.collectList().map(items => ({ key: group.key, items })))\n     *   .subscribe(v => console.log(v));\n     * // { key: 'odd', items: [1, 3, 5] }\n     * // { key: 'even', items: [2, 4] }\n     * ```\n     */\n    public groupBy<K>(keyFn: (value: T) => K): Flux<GroupedFlux<K, T>> {\n        return new Flux<GroupedFlux<K, T>>({\n            subscribe: (subscriber: Subscriber<GroupedFlux<K, T>>): Subscription => {\n                const groups = new Map<K, ReplayAllSink<T>>();\n                let cancelled = false;\n                let sourceSub: Subscription = { request() {}, unsubscribe() {} };\n\n                const operatorSub: Subscription = {\n                    request(_n: number) { /* source runs at full speed */ },\n                    unsubscribe() { cancelled = true; sourceSub.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        sourceSub = s;\n                        s.request(Number.MAX_SAFE_INTEGER);\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        let key: K;\n                        try { key = keyFn(v); }\n                        catch (e) { subscriber.onError(e instanceof Error ? e : new Error(String(e))); return; }\n                        let sink = groups.get(key);\n                        if (!sink) {\n                            sink = new ReplayAllSink<T>();\n                            groups.set(key, sink);\n                            subscriber.onNext(Object.assign(Flux.from<T>(sink), { key }) as GroupedFlux<K, T>);\n                        }\n                        sink.next(v);\n                    },\n                    onError(e: Error) {\n                        if (cancelled) return;\n                        for (const g of groups.values()) g.error(e);\n                        subscriber.onError(e);\n                    },\n                    onComplete() {\n                        if (cancelled) return;\n                        for (const g of groups.values()) g.complete();\n                        subscriber.onComplete();\n                    }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Buffers items into arrays emitted when either `maxSize` items accumulate\n     * **or** `ms` milliseconds elapse since the last flush — whichever comes first.\n     *\n     * @param maxSize - Maximum items per batch.\n     * @param ms - Maximum time (ms) to wait before flushing a partial batch.\n     * @returns A `Flux<T[]>` of batches.\n     *\n     * @example\n     * ```typescript\n     * // Batch up to 10 items or flush every 500ms\n     * eventStream.bufferTimeout(10, 500).subscribe(batch => sendBatch(batch));\n     * ```\n     */\n    public bufferTimeout(maxSize: number, ms: number): Flux<T[]> {\n        return new Flux<T[]>({\n            subscribe: (subscriber: Subscriber<T[]>): Subscription => {\n                let batch: T[] = [];\n                let timer: ReturnType<typeof setTimeout> | null = null;\n                let cancelled = false;\n\n                const flush = () => {\n                    if (timer !== null) { clearTimeout(timer); timer = null; }\n                    if (batch.length > 0 && !cancelled) {\n                        const toEmit = batch;\n                        batch = [];\n                        subscriber.onNext(toEmit);\n                    }\n                };\n\n                const resetTimer = () => {\n                    if (timer !== null) clearTimeout(timer);\n                    timer = setTimeout(() => { if (!cancelled) flush(); }, ms);\n                };\n\n                const sourceSub = this.source.subscribe({\n                    onSubscribe(s: Subscription) { s.request(Number.MAX_SAFE_INTEGER); },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        batch.push(v);\n                        if (batch.length >= maxSize) flush();\n                        else resetTimer();\n                    },\n                    onError(e: Error) {\n                        if (!cancelled) { if (timer !== null) clearTimeout(timer); subscriber.onError(e); }\n                    },\n                    onComplete() {\n                        if (!cancelled) {\n                            if (timer !== null) { clearTimeout(timer); timer = null; }\n                            if (batch.length > 0) subscriber.onNext(batch);\n                            subscriber.onComplete();\n                        }\n                    }\n                });\n\n                const sub: Subscription = {\n                    request(n: number) { sourceSub.request(n); },\n                    unsubscribe() { cancelled = true; if (timer !== null) clearTimeout(timer); sourceSub.unsubscribe(); }\n                };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Samples this `Flux`, emitting the **most recent** item whenever `trigger` emits.\n     *\n     * If no item has arrived since the last sample, the trigger emission is ignored.\n     * Useful for rate-limiting with external signals (scroll, resize, `requestAnimationFrame`).\n     *\n     * @param trigger - Controls when to sample; its value is ignored.\n     * @returns A `Flux<T>` emitting the latest value at each trigger tick.\n     */\n    public sample(trigger: Publisher<unknown>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let latest: T | undefined;\n                let hasValue = false;\n                let cancelled = false;\n                let sourceSub: Subscription = { request() {}, unsubscribe() {} };\n                let triggerSub: Subscription = { request() {}, unsubscribe() {} };\n\n                const operatorSub: Subscription = {\n                    request(n: number) { if (!cancelled) sourceSub.request(n); },\n                    unsubscribe() { cancelled = true; sourceSub.unsubscribe(); triggerSub.unsubscribe(); }\n                };\n\n                triggerSub = trigger.subscribe({\n                    onSubscribe(s: Subscription) { triggerSub = s; s.request(Number.MAX_SAFE_INTEGER); },\n                    onNext(_v) {\n                        if (cancelled || !hasValue) return;\n                        const val = latest!;\n                        hasValue = false;\n                        latest = undefined;\n                        subscriber.onNext(val);\n                    },\n                    onError(e: Error) { if (!cancelled) subscriber.onError(e); },\n                    onComplete() {}\n                });\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) { sourceSub = s; subscriber.onSubscribe(operatorSub); },\n                    onNext(v: T) { if (!cancelled) { latest = v; hasValue = true; } },\n                    onError(e: Error) { if (!cancelled) subscriber.onError(e); },\n                    onComplete() { if (!cancelled) subscriber.onComplete(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * For each item, subscribes to `triggerFn(item)` and waits for it to emit or complete\n     * before forwarding the item downstream (**delayUntil** semantics).\n     *\n     * Triggers are executed sequentially (concatMap semantics). The trigger's value\n     * is ignored — only its timing matters.\n     *\n     * @param triggerFn - Returns a publisher whose first signal releases the item.\n     * @returns A `Flux<T>` where each item is held until its trigger fires.\n     *\n     * @example\n     * ```typescript\n     * Flux.just(1, 2, 3)\n     *   .delayUntil(() => Mono.delay(100))\n     *   .subscribe(v => console.log(v)); // each item delayed 100ms\n     * ```\n     */\n    public delayUntil(triggerFn: (value: T) => Publisher<unknown>): Flux<T> {\n        return this.concatMap(v =>\n            Flux.from<T>({\n                subscribe(subscriber: Subscriber<T>): Subscription {\n                    let done = false;\n                    let innerSub: Subscription = { request() {}, unsubscribe() {} };\n                    innerSub = triggerFn(v).subscribe({\n                        onSubscribe(s: Subscription) { innerSub = s; s.request(Number.MAX_SAFE_INTEGER); },\n                        onNext(_r) {\n                            if (!done) {\n                                done = true;\n                                innerSub.unsubscribe();\n                                subscriber.onNext(v);\n                                subscriber.onComplete();\n                            }\n                        },\n                        onError(e: Error) { if (!done) { done = true; subscriber.onError(e); } },\n                        onComplete() {\n                            if (!done) { done = true; subscriber.onNext(v); subscriber.onComplete(); }\n                        }\n                    });\n                    subscriber.onSubscribe(innerSub);\n                    return innerSub;\n                }\n            })\n        );\n    }\n\n    /**\n     * Recursively expands each item using `fn`, emitting both the original items and\n     * all items produced by the expansion (**breadth-first** order).\n     *\n     * Useful for **pagination**: call `fn` with the current page to fetch the next,\n     * until `fn` returns empty.\n     *\n     * @param fn - Receives an item; returns a publisher of zero or more new items to expand.\n     * @returns A `Flux<T>` of all original and expanded items.\n     *\n     * @example\n     * ```typescript\n     * // Fetch all pages recursively\n     * fetchPage(1)\n     *   .toFlux()\n     *   .expand(page => page.hasNext ? fetchPage(page.nextId).toFlux() : Flux.empty())\n     *   .subscribe(page => process(page));\n     * ```\n     */\n    public expand(fn: (value: T) => Publisher<T>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const pending: T[] = [];\n                let active = false;\n                let sourceDone = false;\n                let cancelled = false;\n                let terminated = false;\n                let demand = 0;\n\n                const terminate = (err?: Error) => {\n                    if (terminated) return;\n                    terminated = true;\n                    if (err) subscriber.onError(err);\n                    else subscriber.onComplete();\n                };\n\n                const drain = () => {\n                    if (active || cancelled || terminated) return;\n                    if (demand <= 0 || pending.length === 0) {\n                        if (sourceDone && pending.length === 0) terminate();\n                        return;\n                    }\n                    active = true;\n                    const v = pending.shift()!;\n                    demand--;\n                    subscriber.onNext(v);\n                    if (cancelled || terminated) { active = false; return; }\n\n                    let inner: Publisher<T>;\n                    try { inner = fn(v); }\n                    catch (e) { active = false; terminate(e instanceof Error ? e : new Error(String(e))); return; }\n\n                    inner.subscribe({\n                        onSubscribe(s: Subscription) { s.request(Number.MAX_SAFE_INTEGER); },\n                        onNext(r: T) { if (!cancelled && !terminated) pending.push(r); },\n                        onError(e: Error) { active = false; terminate(e); },\n                        onComplete() { active = false; drain(); }\n                    });\n                };\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { terminate(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        drain();\n                    },\n                    unsubscribe() { cancelled = true; }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        s.request(Number.MAX_SAFE_INTEGER);\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) { if (!cancelled && !terminated) { pending.push(v); drain(); } },\n                    onError(e: Error) { terminate(e); },\n                    onComplete() { sourceDone = true; if (!active && pending.length === 0) terminate(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Recursively expands each item using `fn`, emitting both the original items and\n     * all items produced by the expansion (**depth-first** order).\n     *\n     * Unlike {@link expand} (breadth-first), each item's children are emitted immediately\n     * after the item itself, before any sibling items are processed. This mirrors a\n     * recursive pre-order tree traversal.\n     *\n     * @param fn - Receives an item; returns a publisher of zero or more new items to expand.\n     * @returns A `Flux<T>` of all original and expanded items in depth-first order.\n     *\n     * @example\n     * ```typescript\n     * // Tree: 1 → [2, 3], 2 → [4, 5], others → empty\n     * Flux.just(1)\n     *   .expandDeep(n =>\n     *     n === 1 ? Flux.just(2, 3) :\n     *     n === 2 ? Flux.just(4, 5) :\n     *     Flux.empty()\n     *   )\n     *   .subscribe(v => console.log(v));\n     * // 1 2 4 5 3  (depth-first pre-order)\n     * ```\n     */\n    public expandDeep(fn: (value: T) => Publisher<T>): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const pending: T[] = [];\n                let active = false;\n                let sourceDone = false;\n                let cancelled = false;\n                let terminated = false;\n                let demand = 0;\n\n                const terminate = (err?: Error) => {\n                    if (terminated) return;\n                    terminated = true;\n                    if (err) subscriber.onError(err);\n                    else subscriber.onComplete();\n                };\n\n                const drain = () => {\n                    if (active || cancelled || terminated) return;\n                    if (demand <= 0 || pending.length === 0) {\n                        if (sourceDone && pending.length === 0) terminate();\n                        return;\n                    }\n                    active = true;\n                    const v = pending.shift()!;\n                    demand--;\n                    subscriber.onNext(v);\n                    if (cancelled || terminated) { active = false; return; }\n\n                    let inner: Publisher<T>;\n                    try { inner = fn(v); }\n                    catch (e) { active = false; terminate(e instanceof Error ? e : new Error(String(e))); return; }\n\n                    const children: T[] = [];\n                    inner.subscribe({\n                        onSubscribe(s: Subscription) { s.request(Number.MAX_SAFE_INTEGER); },\n                        onNext(r: T) { if (!cancelled && !terminated) children.push(r); },\n                        onError(e: Error) { active = false; terminate(e); },\n                        onComplete() {\n                            // Depth-first: prepend children so they are processed before siblings.\n                            if (!cancelled && !terminated) pending.unshift(...children);\n                            active = false;\n                            drain();\n                        }\n                    });\n                };\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || terminated) return;\n                        if (n <= 0) { terminate(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        drain();\n                    },\n                    unsubscribe() { cancelled = true; }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) {\n                        s.request(Number.MAX_SAFE_INTEGER);\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) { if (!cancelled && !terminated) { pending.push(v); drain(); } },\n                    onError(e: Error) { terminate(e); },\n                    onComplete() { sourceDone = true; if (!active && pending.length === 0) terminate(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Pairs each item with the time elapsed (in ms) since the **previous** item\n     * (or since subscription for the first item).\n     *\n     * @returns A `Flux<[number, T]>` where the first element is elapsed milliseconds.\n     *\n     * @example\n     * ```typescript\n     * Flux.interval(100).take(3).elapsed().subscribe(([ms, n]) => console.log(ms, n));\n     * // ~100 0   ~100 1   ~100 2\n     * ```\n     */\n    public elapsed(): Flux<[number, T]> {\n        return new Flux<[number, T]>({\n            subscribe: (subscriber: Subscriber<[number, T]>): Subscription => {\n                let lastTime = Date.now();\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) { lastTime = Date.now(); },\n                    onNext(v: T) {\n                        const now = Date.now();\n                        const ms = now - lastTime;\n                        lastTime = now;\n                        subscriber.onNext([ms, v]);\n                    },\n                    onError(e: Error) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Attaches a `Date.now()` timestamp (in ms since epoch) to each item.\n     *\n     * @returns A `Flux<[number, T]>` where the first element is the Unix timestamp in ms.\n     */\n    public timestamp(): Flux<[number, T]> {\n        return this.map(v => [Date.now(), v] as [number, T]);\n    }\n\n    /**\n     * Wraps each signal (next, error, complete) into a {@link Signal} data object,\n     * emitting them all as `onNext` items on a `Flux<Signal<T>>`.\n     *\n     * After materializing, the resulting `Flux` always completes normally (errors become\n     * `Signal.error` items rather than `onError` signals).\n     * Use {@link dematerialize} to convert back.\n     *\n     * @returns A `Flux<Signal<T>>` where every event is represented as a data item.\n     */\n    public materialize(): Flux<Signal<T>> {\n        return new Flux<Signal<T>>({\n            subscribe: (subscriber: Subscriber<Signal<T>>): Subscription => {\n                let done = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v: T) { if (!done) subscriber.onNext(Signal.next(v)); },\n                    onError(e: Error) {\n                        if (done) return;\n                        done = true;\n                        subscriber.onNext(Signal.error<T>(e));\n                        subscriber.onComplete();\n                    },\n                    onComplete() {\n                        if (done) return;\n                        done = true;\n                        subscriber.onNext(Signal.complete<T>());\n                        subscriber.onComplete();\n                    }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Unwraps a `Flux<Signal<R>>` back into a regular `Flux<R>`, restoring\n     * `error` and `complete` signals from their materialized form.\n     *\n     * This is the inverse of {@link materialize}.\n     *\n     * @returns A `Flux<R>` with signals restored from the `Signal` wrappers.\n     */\n    public dematerialize<R>(this: Flux<Signal<R>>): Flux<R> {\n        return new Flux<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                let done = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(signal: Signal<R>) {\n                        if (done) return;\n                        if (signal.kind === 'next') subscriber.onNext(signal.value);\n                        else if (signal.kind === 'error') { done = true; subscriber.onError(signal.error); }\n                        else { done = true; subscriber.onComplete(); }\n                    },\n                    onError(e: Error) { if (!done) { done = true; subscriber.onError(e); } },\n                    onComplete() { if (!done) { done = true; subscriber.onComplete(); } }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Buffers all upstream items regardless of downstream demand, delivering them\n     * when demand becomes available.\n     *\n     * If `maxSize` is exceeded, an overflow error is signalled downstream.\n     *\n     * @param maxSize - Maximum buffer capacity (default: unbounded).\n     * @returns A `Flux<T>` with explicit backpressure buffering.\n     */\n    public onBackpressureBuffer(maxSize: number = Number.MAX_SAFE_INTEGER): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const buffer: T[] = [];\n                let demand = 0;\n                let cancelled = false;\n                let terminated = false;\n                let terminalError: Error | null = null;\n                let draining = false;\n\n                const drain = () => {\n                    if (draining || cancelled) return;\n                    draining = true;\n                    try {\n                        while (demand > 0 && buffer.length > 0 && !cancelled) {\n                            demand--;\n                            subscriber.onNext(buffer.shift()!);\n                        }\n                        if (terminated && buffer.length === 0 && !cancelled) {\n                            if (terminalError) subscriber.onError(terminalError);\n                            else subscriber.onComplete();\n                        }\n                    } finally { draining = false; }\n                };\n\n                const sourceSub = this.source.subscribe({\n                    onSubscribe(s: Subscription) { s.request(Number.MAX_SAFE_INTEGER); },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        if (buffer.length >= maxSize) {\n                            subscriber.onError(new Error(`onBackpressureBuffer overflow (maxSize=${maxSize})`));\n                            return;\n                        }\n                        buffer.push(v);\n                        drain();\n                    },\n                    onError(e: Error) { if (!cancelled) { terminated = true; terminalError = e; drain(); } },\n                    onComplete() { if (!cancelled) { terminated = true; drain(); } }\n                });\n\n                const sub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || (terminated && buffer.length === 0)) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        drain();\n                    },\n                    unsubscribe() { cancelled = true; buffer.length = 0; sourceSub.unsubscribe(); }\n                };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Drops upstream items that arrive when downstream has no outstanding demand.\n     *\n     * An optional `onDrop` callback is invoked for each dropped item.\n     *\n     * @param onDrop - Optional callback called with each dropped item.\n     * @returns A `Flux<T>` with drop backpressure strategy.\n     */\n    public onBackpressureDrop(onDrop?: (value: T) => void): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let demand = 0;\n                let cancelled = false;\n\n                const sourceSub = this.source.subscribe({\n                    onSubscribe(s: Subscription) { s.request(Number.MAX_SAFE_INTEGER); },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        if (demand > 0) { demand--; subscriber.onNext(v); }\n                        else { try { onDrop?.(v); } catch (_) {} }\n                    },\n                    onError(e: Error) { if (!cancelled) subscriber.onError(e); },\n                    onComplete() { if (!cancelled) subscriber.onComplete(); }\n                });\n\n                const sub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                    },\n                    unsubscribe() { cancelled = true; sourceSub.unsubscribe(); }\n                };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Keeps only the **latest** upstream item when downstream has no demand;\n     * older buffered items are overwritten as new ones arrive.\n     *\n     * @returns A `Flux<T>` with latest-value backpressure strategy.\n     */\n    public onBackpressureLatest(): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let latest: T | undefined;\n                let hasLatest = false;\n                let demand = 0;\n                let cancelled = false;\n                let terminated = false;\n                let terminalError: Error | null = null;\n\n                const drain = () => {\n                    if (cancelled) return;\n                    if (demand > 0 && hasLatest) {\n                        demand--;\n                        const v = latest!;\n                        hasLatest = false;\n                        latest = undefined;\n                        subscriber.onNext(v);\n                    }\n                    if (terminated && !hasLatest && !cancelled) {\n                        if (terminalError) subscriber.onError(terminalError);\n                        else subscriber.onComplete();\n                    }\n                };\n\n                const sourceSub = this.source.subscribe({\n                    onSubscribe(s: Subscription) { s.request(Number.MAX_SAFE_INTEGER); },\n                    onNext(v: T) { if (!cancelled) { latest = v; hasLatest = true; drain(); } },\n                    onError(e: Error) { if (!cancelled) { terminated = true; terminalError = e; drain(); } },\n                    onComplete() { if (!cancelled) { terminated = true; drain(); } }\n                });\n\n                const sub: Subscription = {\n                    request(n: number) {\n                        if (cancelled || (terminated && !hasLatest)) return;\n                        if (n <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${n}`)); return; }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        drain();\n                    },\n                    unsubscribe() { cancelled = true; sourceSub.unsubscribe(); }\n                };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Requests items from upstream in batches of `n`, replenishing when 75% of\n     * the batch has been consumed (**prefetch** / **limitRate** semantics).\n     *\n     * Prevents requesting all items at once from expensive sources.\n     *\n     * @param n - Prefetch batch size.\n     * @returns A `Flux<T>` with controlled upstream demand.\n     */\n    public limitRate(n: number): Flux<T> {\n        return new Flux<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const prefetch = Math.max(1, n);\n                const replenish = Math.max(1, Math.floor(prefetch * 0.75));\n                let sourceSub!: Subscription;\n                let pending = 0;\n                let consumed = 0;\n                let cancelled = false;\n\n                const requestMore = () => {\n                    const toRequest = prefetch - pending;\n                    if (toRequest > 0) { pending += toRequest; sourceSub.request(toRequest); }\n                };\n\n                const operatorSub: Subscription = {\n                    request(count: number) {\n                        if (cancelled) return;\n                        if (count <= 0) { subscriber.onError(new Error(`request must be > 0, but was ${count}`)); return; }\n                        requestMore();\n                    },\n                    unsubscribe() { cancelled = true; sourceSub?.unsubscribe(); }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s: Subscription) { sourceSub = s; subscriber.onSubscribe(operatorSub); },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        pending = Math.max(0, pending - 1);\n                        consumed++;\n                        subscriber.onNext(v);\n                        if (consumed >= replenish) { consumed = 0; requestMore(); }\n                    },\n                    onError(e: Error) { if (!cancelled) subscriber.onError(e); },\n                    onComplete() { if (!cancelled) subscriber.onComplete(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Filters items by runtime type, passing only items that are instances of `constructor`.\n     *\n     * @typeParam R - The target subtype.\n     * @param constructor - The class/constructor to filter by.\n     * @returns A `Flux<R>` containing only items that pass `instanceof`.\n     *\n     * @example\n     * ```typescript\n     * class Cat { meow() {} }\n     * class Dog { bark() {} }\n     * Flux.just(new Cat(), new Dog(), new Cat())\n     *   .ofType(Cat)\n     *   .subscribe(cat => cat.meow());\n     * ```\n     */\n    public ofType<R extends T>(constructor: new (...args: unknown[]) => R): Flux<R> {\n        return this.filter((v): v is R => v instanceof constructor).cast<R>();\n    }\n\n    /**\n     * Applies a reusable operator function `fn` to this `Flux`, deferred per subscription.\n     *\n     * `fn` receives this `Flux<T>` (as a `Publisher<T>`) and returns a new `Publisher<R>`.\n     * The transformation is re-evaluated on each `subscribe()` call (deferred assembly).\n     *\n     * @param fn - Operator function to apply.\n     * @returns A `Flux<R>` produced by `fn`.\n     *\n     * @example\n     * ```typescript\n     * const retryThrice = <T>(source: Publisher<T>) => Flux.from(source).retry(3);\n     * Flux.just(1, 2).transformDeferred(retryThrice).subscribe(v => console.log(v));\n     * ```\n     */\n    public transformDeferred<R>(fn: (flux: Publisher<T>) => Publisher<R>): Flux<R> {\n        return Flux.defer(() => Flux.from(fn(this)));\n    }\n}\n\n// ────────────────────────── GroupedFlux ──────────────────────────────────────\n\n/**\n * A `Flux<T>` tagged with a group `key`.\n *\n * Produced by {@link Flux#groupBy} — subscribe to it exactly like any `Flux<T>`;\n * the extra `key` property identifies which group this stream belongs to.\n *\n * Implemented as a plain type intersection rather than a subclass: the runtime\n * object is an ordinary `Flux<T>` with a `key` property attached via\n * `Object.assign`, so no extra prototype chain is required.\n *\n * @typeParam K - The type of the group key.\n * @typeParam T - The type of items in the group.\n */\nexport type GroupedFlux<K, T> = Flux<T> & { readonly key: K };\n","import {Publisher} from \"@/publishers/Publisher\";\nimport {Sink} from \"@/sinks/Sink\";\nimport {Flux} from \"@/publishers/Flux\";\nimport {PipePublisher} from \"@/publishers/PipePublisher\";\nimport {Subscriber} from \"@/subscriptions/Subscriber\";\nimport {Subscription} from \"@/subscriptions/Subscription\";\nimport {AbstractPipePublisher} from \"@/publishers/internal/AbstractPipePublisher\";\n\n/**\n * A cold publisher of 0 or 1 items with full backpressure support.\n *\n * A `Mono` emits at most one value followed by `onComplete`, or signals `onError`.\n * Items flow only when the downstream {@link Subscription} issues `request(n)`.\n * The convenience `subscribe(onNext, onError, onComplete)` overloads automatically\n * request `1` so the value starts flowing without extra ceremony.\n *\n * Each `subscribe()` call creates an **independent** run of the pipeline (\"cold\" semantics).\n *\n * @typeParam T - The type of the single item emitted by this Mono.\n *\n * @example\n * ```typescript\n * Mono.just(42)\n *   .map(n => n * 2)\n *   .subscribe(v => console.log(v));\n * // 84\n * ```\n */\nexport class Mono<T> extends AbstractPipePublisher<T, Mono<T>> implements PipePublisher<T> {\n\n    protected constructor(source: Publisher<T>) { super(source); }\n\n    protected defaultDemand(): number { return 1; }\n\n    protected wrapSource(source: Publisher<T>): Mono<T> {\n        return new Mono<T>(source);\n    }\n\n    // ─────────────────────────── Static factories ────────────────────────────\n\n    /**\n     * Creates a `Mono` from a generator function that pushes a value imperatively.\n     *\n     * The generator receives a {@link Sink} and should call exactly one of:\n     * - `sink.next(value)` — emits the value and completes.\n     * - `sink.error(err)` — terminates with an error.\n     * - `sink.complete()` — completes without emitting a value (empty `Mono`).\n     *\n     * Delivery is deferred until the downstream subscriber issues `request(n)`.\n     * Rule 1.3 is respected — `onSubscribe` is delivered before the generator runs.\n     *\n     * @param generator - Function that drives the `Mono` via the provided `Sink<T>`.\n     * @returns A cold `Mono<T>`.\n     *\n     * @example\n     * ```typescript\n     * Mono.generate<number>(sink => sink.next(42)).subscribe(v => console.log(v)); // 42\n     * ```\n     */\n    public static generate<T>(generator: (sink: Sink<T>) => void): Mono<T> {\n        return new Mono<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                let cancelled = false;\n                let demanded = false;\n                let terminated = false;\n                let pending: { value: T } | null = null;\n                let pendingError: Error | null = null;\n\n                const tryDeliver = () => {\n                    if (cancelled || !demanded) return;\n                    if (pending !== null) {\n                        const v = pending.value;\n                        pending = null;\n                        subscriber.onNext(v);\n                        if (!cancelled) subscriber.onComplete();\n                    } else if (pendingError !== null) {\n                        const e = pendingError;\n                        pendingError = null;\n                        subscriber.onError(e);\n                    } else if (terminated) {\n                        subscriber.onComplete();\n                    }\n                };\n\n                const sink: Sink<T> = {\n                    next(v: T) {\n                        if (terminated || cancelled) return;\n                        terminated = true;\n                        if (demanded) {\n                            subscriber.onNext(v);\n                            if (!cancelled) subscriber.onComplete();\n                        } else {\n                            pending = { value: v };\n                        }\n                    },\n                    error(err: Error) {\n                        if (terminated || cancelled) return;\n                        terminated = true;\n                        if (demanded) {\n                            subscriber.onError(err);\n                        } else {\n                            pendingError = err;\n                        }\n                    },\n                    complete() {\n                        if (terminated || cancelled) return;\n                        terminated = true;\n                        if (demanded) subscriber.onComplete();\n                        // else: deliver onComplete on next request()\n                    }\n                };\n\n                try {\n                    generator(sink);\n                } catch (e) {\n                    if (!terminated) {\n                        terminated = true;\n                        pendingError = e instanceof Error ? e : new Error(String(e));\n                    }\n                }\n\n                const subscription: Subscription = {\n                    request(n: number) {\n                        if (cancelled || demanded) return;\n                        if (n <= 0) {\n                            subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                            return;\n                        }\n                        demanded = true;\n                        tryDeliver();\n                    },\n                    unsubscribe() { cancelled = true; }\n                };\n                subscriber.onSubscribe(subscription);\n                return subscription;\n            }\n        });\n    }\n\n    /**\n     * Wraps an existing {@link Publisher} as a `Mono`.\n     *\n     * @param publisher - Any `Publisher<T>` to adapt.\n     * @returns A `Mono<T>` backed by the given publisher.\n     */\n    public static from<T>(publisher: Publisher<T>): Mono<T> {\n        return new Mono<T>(publisher);\n    }\n\n    /**\n     * Creates a `Mono` that emits `value` then completes.\n     *\n     * @param value - The single item to emit.\n     * @returns A cold `Mono<T>`.\n     *\n     * @example\n     * ```typescript\n     * Mono.just(42).subscribe(v => console.log(v)); // 42\n     * ```\n     */\n    public static just<T>(value: T): Mono<T> {\n        return Mono.generate(sink => sink.next(value));\n    }\n\n    /**\n     * Creates a `Mono` that emits `value` if it is non-null and non-undefined,\n     * or completes empty if `value` is `null` or `undefined`.\n     *\n     * @param value - The value to emit, or `null`/`undefined` for an empty Mono.\n     * @returns A `Mono<T>` that emits the value or completes immediately.\n     */\n    public static justOrEmpty<T>(value: T | null | undefined): Mono<T> {\n        return value != null ? Mono.just(value) : Mono.empty<T>();\n    }\n\n    /**\n     * Creates a `Mono` that completes immediately without emitting any value.\n     *\n     * @returns An empty, completed `Mono<T>`.\n     */\n    public static empty<T = never>(): Mono<T> {\n        return new Mono<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                const sub = { request() {}, unsubscribe() {} };\n                subscriber.onSubscribe(sub);\n                subscriber.onComplete();\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Creates a `Mono` that signals `onError` immediately upon subscription.\n     *\n     * @param error - The error to signal (wrapped in an `Error` if not already one).\n     * @returns An errored `Mono<T>`.\n     */\n    public static error<T = never>(error: unknown): Mono<T> {\n        const err = error instanceof Error ? error : new Error(String(error));\n        return new Mono<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                const sub = { request() {}, unsubscribe() {} };\n                subscriber.onSubscribe(sub);\n                subscriber.onError(err);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Creates a `Mono` that adapts a `Promise<T>`.\n     *\n     * The resolved value is emitted as the single item; a rejected promise signals `onError`.\n     *\n     * @param promise - The promise to adapt.\n     * @returns A `Mono<T>` backed by the promise.\n     *\n     * @example\n     * ```typescript\n     * Mono.fromPromise(fetch('/api/data').then(r => r.json()))\n     *   .subscribe(data => console.log(data));\n     * ```\n     */\n    public static fromPromise<T>(promise: Promise<T>): Mono<T> {\n        return Mono.generate(sink =>\n            promise\n                .then(value => sink.next(value))\n                .catch(err => sink.error(err instanceof Error ? err : new Error(String(err))))\n        );\n    }\n\n    /**\n     * Lazily creates a new `Mono` per subscription by calling `factory`.\n     *\n     * Useful when the source depends on mutable state that should be captured\n     * at subscribe time rather than at assembly time.\n     *\n     * @param factory - Called once per subscription to produce the actual `Mono<T>`.\n     * @returns A lazy `Mono<T>`.\n     */\n    public static defer<T>(factory: () => Mono<T>): Mono<T> {\n        return new Mono<T>({\n            subscribe(subscriber: Subscriber<T>): Subscription {\n                return factory().subscribe(subscriber);\n            }\n        });\n    }\n\n    /**\n     * Alias for {@link Mono.generate} — imperative push interface.\n     *\n     * The generator receives a {@link Sink} and should call exactly one of:\n     * `sink.next(value)`, `sink.error(err)`, or `sink.complete()`.\n     *\n     * @param generator - Function that drives the `Mono` via the provided `Sink<T>`.\n     * @returns A cold `Mono<T>`.\n     */\n    public static create<T>(generator: (sink: Sink<T>) => void): Mono<T> {\n        return Mono.generate(generator);\n    }\n\n    /**\n     * Creates a `Mono<number>` that emits `0` after `ms` milliseconds then completes.\n     *\n     * Useful for introducing timed delays in reactive pipelines.\n     *\n     * @param ms - The delay in milliseconds.\n     * @returns A `Mono<number>` that emits `0` after the delay.\n     *\n     * @example\n     * ```typescript\n     * Mono.delay(500).flatMap(() => Mono.just('hello')).subscribe(v => console.log(v));\n     * ```\n     */\n    public static delay(ms: number): Mono<number> {\n        return Mono.generate<number>(sink => {\n            const id = setTimeout(() => sink.next(0), ms);\n            // cancellation note: timeout fires and is a no-op if sink already terminated\n            void id;\n        });\n    }\n\n    /**\n     * Creates a `Mono<T>` from a synchronous, potentially-throwing factory function.\n     *\n     * The factory is called **lazily** at subscription time (not at assembly time).\n     * If the factory throws, the exception is forwarded as `onError`.\n     *\n     * @param fn - Synchronous factory invoked once per subscription.\n     * @returns A cold `Mono<T>`.\n     *\n     * @example\n     * ```typescript\n     * Mono.fromCallable(() => JSON.parse(rawJson)).subscribe(v => console.log(v));\n     * ```\n     */\n    public static fromCallable<T>(fn: () => T): Mono<T> {\n        return Mono.generate<T>(sink => {\n            try { sink.next(fn()); }\n            catch (e) { sink.error(e instanceof Error ? e : new Error(String(e))); }\n        });\n    }\n\n    /**\n     * Races multiple `Mono`s — emits the first value to arrive, cancelling the rest.\n     *\n     * If a source completes without emitting, it is excluded from the race.\n     * If **all** sources complete empty, the resulting `Mono` also completes empty.\n     * If any source errors before another source emits, the error is propagated.\n     *\n     * @param sources - One or more `Mono<T>` sources to race.\n     * @returns A `Mono<T>` that emits the first available value.\n     *\n     * @example\n     * ```typescript\n     * Mono.firstWithValue(slow, fast).subscribe(v => console.log(v)); // fast's value\n     * ```\n     */\n    public static firstWithValue<T>(...sources: Mono<T>[]): Mono<T> {\n        if (sources.length === 0) return Mono.empty<T>();\n        return Mono.generate<T>(sink => {\n            let done = false;\n            let completedCount = 0;\n            const subs: Subscription[] = [];\n\n            for (const source of sources) {\n                const sub = source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v: T) {\n                        if (done) return;\n                        done = true;\n                        for (const s of subs) s.unsubscribe();\n                        sink.next(v);\n                    },\n                    onError(e: Error) {\n                        if (done) return;\n                        done = true;\n                        for (const s of subs) s.unsubscribe();\n                        sink.error(e);\n                    },\n                    onComplete() {\n                        if (done) return;\n                        completedCount++;\n                        if (completedCount === sources.length) {\n                            done = true;\n                            sink.complete();\n                        }\n                    }\n                });\n                subs.push(sub);\n            }\n            for (const sub of subs) sub.request(1);\n        });\n    }\n\n    /**\n     * Returns a `Mono<void>` that completes when **all** given publishers complete.\n     *\n     * Emitted values from the sources are ignored. If any source signals `onError`,\n     * the error is propagated immediately and all other sources are cancelled.\n     * If no sources are provided, completes immediately.\n     *\n     * @param sources - Zero or more publishers to wait on.\n     * @returns A `Mono<void>` that completes once every source has completed.\n     *\n     * @example\n     * ```typescript\n     * Mono.when(Mono.delay(100), Mono.delay(200))\n     *   .subscribe(undefined, undefined, () => console.log('all done'));\n     * ```\n     */\n    public static when(...sources: Publisher<unknown>[]): Mono<void> {\n        if (sources.length === 0) return Mono.empty<void>();\n        return Mono.generate<void>(sink => {\n            let done = false;\n            let completedCount = 0;\n            const subs: Subscription[] = [];\n\n            for (const source of sources) {\n                const sub = source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(_v) {},\n                    onError(e: Error) {\n                        if (done) return;\n                        done = true;\n                        for (const s of subs) s.unsubscribe();\n                        sink.error(e);\n                    },\n                    onComplete() {\n                        if (done) return;\n                        completedCount++;\n                        if (completedCount === sources.length) {\n                            done = true;\n                            sink.complete();\n                        }\n                    }\n                });\n                subs.push(sub);\n            }\n            for (const sub of subs) sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n\n    // ─────────────────────── PipePublisher operators ─────────────────────────\n\n    /**\n     * Transforms the emitted value using `fn`, producing a `Mono<R>`.\n     *\n     * If `fn` throws, the exception is forwarded to `onError` and the stream terminates.\n     *\n     * @param fn - Mapping function applied to the emitted value.\n     * @returns A new `Mono<R>`.\n     *\n     * @example\n     * ```typescript\n     * Mono.just(42).map(n => n.toString()).subscribe(v => console.log(v)); // '42'\n     * ```\n     */\n    public map<R>(fn: (value: T) => R): Mono<R> {\n        return new Mono<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        try { subscriber.onNext(fn(v)); }\n                        catch (e) { subscriber.onError(e instanceof Error ? e : new Error(String(e))); }\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Transforms the emitted value with `fn`, completing empty if the result is `null` or `undefined`.\n     *\n     * @param fn - Mapping function; returning `null` or `undefined` produces an empty `Mono`.\n     * @returns A `Mono<NonNullable<R>>` that completes empty when the mapping returns null.\n     */\n    public mapNotNull<R>(fn: (value: T) => R | null | undefined): Mono<NonNullable<R>> {\n        return new Mono<NonNullable<R>>({\n            subscribe: (subscriber: Subscriber<NonNullable<R>>): Subscription => {\n                let done = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        if (done) return;\n                        try {\n                            const result = fn(v);\n                            if (result != null) subscriber.onNext(result as NonNullable<R>);\n                            else { done = true; subscriber.onComplete(); }\n                        } catch (e) {\n                            done = true;\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                        }\n                    },\n                    onError(e) { if (!done) { done = true; subscriber.onError(e); } },\n                    onComplete() { if (!done) { done = true; subscriber.onComplete(); } }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Maps the emitted value to an inner `Mono<R>` and flattens the result.\n     *\n     * When the source emits a value, `fn` is called and the resulting inner `Mono` is\n     * subscribed to. The inner `Mono`'s value (or completion/error) is forwarded downstream.\n     *\n     * @param fn - Maps the emitted value to a `Mono<R>` or any `Publisher<R>`.\n     * @returns A `Mono<R>` containing the result of the inner publisher.\n     */\n    public flatMap<R>(fn: (value: T) => Mono<R>): Mono<R>;\n    public flatMap<R>(fn: (value: T) => Publisher<R>): Mono<R>;\n    public flatMap<R>(fn: (value: T) => Publisher<R>): Mono<R> {\n        return new Mono<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                let outerSub: Subscription = { request() {}, unsubscribe() {} };\n                let innerSub: Subscription | null = null;\n                let cancelled = false;\n                let demand = 0;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) {\n                            subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                            return;\n                        }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (innerSub) innerSub.request(n);\n                    },\n                    unsubscribe() {\n                        cancelled = true;\n                        outerSub.unsubscribe();\n                        innerSub?.unsubscribe();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(sourceSub: Subscription) {\n                        outerSub = sourceSub;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        let inner: Publisher<R>;\n                        try { inner = fn(v); }\n                        catch (e) {\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                            return;\n                        }\n                        innerSub = inner.subscribe({\n                            onSubscribe(_s) {},\n                            onNext(r) { subscriber.onNext(r); },\n                            onError(e) { subscriber.onError(e); },\n                            onComplete() { subscriber.onComplete(); }\n                        });\n                        if (demand > 0) innerSub.request(demand);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() {\n                        if (!innerSub) subscriber.onComplete();\n                    }\n                });\n                outerSub.request(1);\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Passes the emitted value downstream only if `predicate` returns `true`;\n     * otherwise completes the `Mono` without emitting.\n     *\n     * @param predicate - Synchronous test applied to the emitted value.\n     * @returns A `Mono<T>` that completes empty when the predicate fails.\n     */\n    public filter(predicate: (value: T) => boolean): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let done = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        if (done) return;\n                        try {\n                            if (predicate(v)) subscriber.onNext(v);\n                            else { done = true; subscriber.onComplete(); }\n                        } catch (e) {\n                            done = true;\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                        }\n                    },\n                    onError(e) { if (!done) { done = true; subscriber.onError(e); } },\n                    onComplete() { if (!done) { done = true; subscriber.onComplete(); } }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Asynchronous filter: subscribes to `predicate(value)` and forwards the value\n     * downstream only if the predicate publisher emits `true`; otherwise completes empty.\n     *\n     * @param predicate - Returns a `Publisher<boolean>` for the emitted value.\n     * @returns A `Mono<T>` that completes empty when the predicate is not satisfied.\n     */\n    public filterWhen(predicate: (value: T) => Publisher<boolean>): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let outerSub: Subscription = { request() {}, unsubscribe() {} };\n                let innerSub: Subscription | null = null;\n                let cancelled = false;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) {\n                            subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                            return;\n                        }\n                    },\n                    unsubscribe() {\n                        cancelled = true;\n                        outerSub.unsubscribe();\n                        innerSub?.unsubscribe();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(sourceSub: Subscription) {\n                        outerSub = sourceSub;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        let pred: Publisher<boolean>;\n                        try { pred = predicate(v); }\n                        catch (e) {\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                            return;\n                        }\n                        let innerDone = false;\n                        innerSub = pred.subscribe({\n                            onSubscribe(_s) {},\n                            onNext(passes) {\n                                if (innerDone) return;\n                                innerDone = true;\n                                if (passes) subscriber.onNext(v);\n                                else subscriber.onComplete();\n                            },\n                            onError(e) { if (!innerDone) { innerDone = true; subscriber.onError(e); } },\n                            onComplete() { if (!innerDone) { innerDone = true; subscriber.onComplete(); } }\n                        });\n                        innerSub.request(1);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { if (!innerSub) subscriber.onComplete(); }\n                });\n                outerSub.request(1);\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Unsafe type cast — changes the declared element type to `R` without any\n     * runtime conversion. Use only when you are certain the actual runtime type is compatible.\n     *\n     * @typeParam R - The target element type.\n     * @returns This `Mono` re-typed as `Mono<R>`.\n     */\n    public cast<R>(): Mono<R> {\n        return new Mono<R>(this.source as unknown as Publisher<R>);\n    }\n\n    /**\n     * Executes a side-effect function after the stream ends for **any** reason —\n     * normal completion or error. Unlike {@link Flux#doFinally}, this does not fire on\n     * cancellation (a `Mono` cancel is semantically identical to an unneeded result).\n     *\n     * Any exception thrown by `fn` is silently swallowed.\n     *\n     * @param fn - Side-effect to run after any terminal event.\n     * @returns A `Mono<T>` with the side effect attached.\n     */\n    public doFinally(fn: () => void): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) {\n                        try { fn(); } catch (_) {}\n                        subscriber.onError(e);\n                    },\n                    onComplete() {\n                        try { fn(); } catch (_) {}\n                        subscriber.onComplete();\n                    }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Low-level escape hatch for bridging imperative push-based sources into a `Mono<R>`.\n     *\n     * The `producer` receives three callbacks and must call them to drive the stream.\n     * `onRequest` and `onUnsubscribe` let the caller respond to downstream demand and\n     * cancellation respectively.\n     *\n     * @param producer - Callback that receives `(onNext, onError, onComplete)` and drives the stream.\n     * @param onRequest - Called when the downstream subscriber requests `n` more items.\n     * @param onUnsubscribe - Called when the downstream subscriber cancels.\n     * @returns A `Mono<R>` backed by the imperative producer.\n     */\n    public pipe<R>(\n        producer: (onNext: (value: R) => void, onError: (error: Error) => void, onComplete: () => void) => void,\n        onRequest: (request: number) => void,\n        onUnsubscribe: () => void\n    ): Mono<R> {\n        return new Mono<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                producer(\n                    v => subscriber.onNext(v),\n                    e => subscriber.onError(e),\n                    () => subscriber.onComplete()\n                );\n                const sub = { request: onRequest, unsubscribe: onUnsubscribe };\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    // ─────────────────────── Mono-specific operators ─────────────────────────\n\n    /**\n     * Maps the emitted value to a multi-item publisher and returns the items as a `Flux<R>`.\n     *\n     * The inner publisher is subscribed to once the source emits its single value.\n     * All items from the inner publisher are forwarded downstream. If the source is empty,\n     * the resulting `Flux` also completes empty.\n     *\n     * @param mapper - Maps the emitted value to a `Flux<R>`, `Mono<R>`, or any `Publisher<R>`.\n     * @returns A `Flux<R>` containing all items from the inner publisher.\n     *\n     * @example\n     * ```typescript\n     * Mono.just(3)\n     *   .flatMapMany(n => Flux.range(1, n))\n     *   .subscribe(v => console.log(v)); // 1  2  3\n     * ```\n     */\n    public flatMapMany<R>(mapper: (value: T) => Flux<R>): Flux<R>;\n    public flatMapMany<R>(mapper: (value: T) => Mono<R>): Flux<R>;\n    public flatMapMany<R>(mapper: (value: T) => Publisher<R>): Flux<R>;\n    public flatMapMany<R>(mapper: (value: T) => Publisher<R>): Flux<R> {\n        return Flux.from<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                let outerSub: Subscription = { request() {}, unsubscribe() {} };\n                let innerSub: Subscription | null = null;\n                let cancelled = false;\n                let demand = 0;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) {\n                            subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                            return;\n                        }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (innerSub) innerSub.request(n);\n                    },\n                    unsubscribe() {\n                        cancelled = true;\n                        outerSub.unsubscribe();\n                        innerSub?.unsubscribe();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(sourceSub: Subscription) {\n                        outerSub = sourceSub;\n                        subscriber.onSubscribe(operatorSub);\n                    },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        let inner: Publisher<R>;\n                        try { inner = mapper(v); }\n                        catch (e) {\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                            return;\n                        }\n                        innerSub = inner.subscribe({\n                            onSubscribe(_s) {},\n                            onNext(r) { subscriber.onNext(r); },\n                            onError(e) { subscriber.onError(e); },\n                            onComplete() { subscriber.onComplete(); }\n                        });\n                        if (demand > 0) innerSub.request(demand);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { if (!innerSub) subscriber.onComplete(); }\n                });\n                outerSub.request(1);\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Subscribes to this `Mono` and `other` concurrently and combines their values\n     * into a `[T, R]` tuple once both emit.\n     *\n     * If either `Mono` completes empty, the resulting `Mono` also completes empty.\n     * If either errors, the error is forwarded and the other is cancelled.\n     *\n     * @param other - The second `Mono` to zip with.\n     * @returns A `Mono<[T, R]>` emitting the combined tuple.\n     *\n     * @example\n     * ```typescript\n     * Mono.just(1).zipWith(Mono.just('a')).subscribe(([n, s]) => console.log(n, s)); // 1 a\n     * ```\n     */\n    public zipWith<R>(other: Mono<R>): Mono<[T, R]> {\n        return Mono.generate<[T, R]>(sink => {\n            let left: T | undefined;\n            let right: R | undefined;\n            let leftDone = false;\n            let rightDone = false;\n            let failed = false;\n\n            const fail = (e: Error) => {\n                if (failed) return;\n                failed = true;\n                leftSub?.unsubscribe();\n                rightSub?.unsubscribe();\n                sink.error(e);\n            };\n\n            const tryEmit = () => {\n                if (leftDone && rightDone) {\n                    sink.next([left as T, right as R]);\n                }\n            };\n\n            let leftSub: Subscription;\n            let rightSub: Subscription;\n\n            leftSub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) { left = v; leftDone = true; tryEmit(); },\n                onError(e) { fail(e); },\n                onComplete() { if (!leftDone) { rightSub?.unsubscribe(); sink.complete(); } }\n            });\n\n            rightSub = other.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) { right = v; rightDone = true; tryEmit(); },\n                onError(e) { fail(e); },\n                onComplete() { if (!rightDone) { leftSub?.unsubscribe(); sink.complete(); } }\n            });\n\n            leftSub.request(1);\n            rightSub.request(1);\n        });\n    }\n\n    /**\n     * Emits the source value and uses `fn` to derive a second `Mono`, combining both into a tuple.\n     *\n     * The source value is passed to `fn` to produce the second `Mono`. Both values are then\n     * combined into a `[T, R]` tuple. If either `Mono` is empty or errors, those signals\n     * propagate to the subscriber.\n     *\n     * @param fn - Called with the emitted value to produce the second `Mono<R>`.\n     * @returns A `Mono<[T, R]>` emitting both values as a tuple.\n     *\n     * @example\n     * ```typescript\n     * Mono.just(42).zipWhen(n => Mono.just(n.toString())).subscribe(([n, s]) => console.log(n, s));\n     * // 42 '42'\n     * ```\n     */\n    public zipWhen<R>(fn: (value: T) => Mono<R>): Mono<[T, R]> {\n        return Mono.generate<[T, R]>(sink => {\n            const outerSub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(v: T) {\n                    let inner: Mono<R>;\n                    try { inner = fn(v); }\n                    catch (e) { sink.error(e instanceof Error ? e : new Error(String(e))); return; }\n\n                    const innerSub = inner.subscribe({\n                        onSubscribe(_s) {},\n                        onNext(r) { sink.next([v, r]); },\n                        onError(e) { sink.error(e); },\n                        onComplete() { sink.complete(); }\n                    });\n                    innerSub.request(1);\n                },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.complete(); }\n            });\n            outerSub.request(1);\n        });\n    }\n\n    /**\n     * Emits `true` if this `Mono` emits a value, `false` if it completes empty.\n     *\n     * @returns A `Mono<boolean>`.\n     */\n    public hasElement(): Mono<boolean> {\n        return Mono.generate<boolean>(sink => {\n            const sub = this.source.subscribe({\n                onSubscribe(_s) {},\n                onNext(_v) { sub.unsubscribe(); sink.next(true); },\n                onError(e) { sink.error(e); },\n                onComplete() { sink.next(false); }\n            });\n            sub.request(1);\n        });\n    }\n\n    /**\n     * Side effect executed when the `Mono` emits its value.\n     *\n     * Does **not** affect the emitted value or stream lifecycle.\n     * Exceptions thrown by `fn` are forwarded as `onError`.\n     *\n     * @param fn - Called with the emitted value.\n     * @returns A `Mono<T>` with the side effect attached.\n     *\n     * @example\n     * ```typescript\n     * Mono.just(42).doOnSuccess(v => console.log('got', v)).subscribe();\n     * ```\n     */\n    public doOnSuccess(fn: (value: T) => void): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        try { fn(v); } catch (e) {\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                            return;\n                        }\n                        subscriber.onNext(v);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Converts a terminal error into a normal `onComplete` signal.\n     *\n     * If a `predicate` is supplied, only errors for which the predicate returns `true`\n     * are swallowed; others are re-propagated as-is.\n     *\n     * @param predicate - Optional filter; when absent all errors are converted.\n     * @returns A `Mono<T>` that completes rather than errors (when predicate matches).\n     *\n     * @example\n     * ```typescript\n     * Mono.error(new Error('oops')).onErrorComplete().subscribe(undefined, undefined, () => console.log('done'));\n     * ```\n     */\n    public onErrorComplete(predicate?: (e: Error) => boolean): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) { subscriber.onNext(v); },\n                    onError(e) {\n                        if (!predicate || predicate(e)) subscriber.onComplete();\n                        else subscriber.onError(e);\n                    },\n                    onComplete() { subscriber.onComplete(); }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Ignores any value emitted by this `Mono` and, upon normal completion,\n     * emits `value` instead.\n     *\n     * Errors from the source are propagated unchanged.\n     *\n     * @param value - The value to emit after this `Mono` completes.\n     * @returns A `Mono<R>` that emits `value` on source completion.\n     *\n     * @example\n     * ```typescript\n     * Mono.just('ignored').thenReturn(42).subscribe(v => console.log(v)); // 42\n     * ```\n     */\n    public thenReturn<R>(value: R): Mono<R> {\n        return new Mono<R>({\n            subscribe: (subscriber: Subscriber<R>): Subscription => {\n                let done = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(_v) { /* swallow the emitted value */ },\n                    onError(e) { if (!done) { done = true; subscriber.onError(e); } },\n                    onComplete() {\n                        if (!done) {\n                            done = true;\n                            subscriber.onNext(value);\n                            subscriber.onComplete();\n                        }\n                    }\n                });\n                subscriber.onSubscribe(sub);\n                return sub;\n            }\n        });\n    }\n\n    /**\n     * Ignores the value emitted by this `Mono` and, upon completion, subscribes to `other`\n     * and forwards its result downstream.\n     *\n     * If `other` is omitted, returns a `Mono<void>` that completes when this `Mono` completes.\n     * Errors from this `Mono` are propagated without subscribing to `other`.\n     *\n     * @param other - Optional `Mono<V>` to subscribe to after this `Mono` completes.\n     * @returns `Mono<void>` when called with no argument; `Mono<V>` when `other` is provided.\n     *\n     * @example\n     * ```typescript\n     * // Sequencing: run A, then run B and return B's value\n     * Mono.just('ignored').then(Mono.just(42)).subscribe(v => console.log(v)); // 42\n     *\n     * // Completion signal only\n     * Mono.just('ignored').then().subscribe(undefined, undefined, () => console.log('done'));\n     * ```\n     */\n    public then(): Mono<void>;\n    public then<V>(other: Mono<V>): Mono<V>;\n    public then<V>(other?: Mono<V>): Mono<void> | Mono<V> {\n        if (!other) {\n            return new Mono<void>({\n                subscribe: (subscriber: Subscriber<void>): Subscription => {\n                    let done = false;\n                    const sub = this.source.subscribe({\n                        onSubscribe(_s) {},\n                        onNext(_v) {},\n                        onError(e) { if (!done) { done = true; subscriber.onError(e); } },\n                        onComplete() { if (!done) { done = true; subscriber.onComplete(); } }\n                    });\n                    subscriber.onSubscribe(sub);\n                    return sub;\n                }\n            });\n        }\n\n        return new Mono<V>({\n            subscribe: (subscriber: Subscriber<V>): Subscription => {\n                let outerSub: Subscription = { request() {}, unsubscribe() {} };\n                let innerSub: Subscription | null = null;\n                let cancelled = false;\n                let demand = 0;\n\n                const operatorSub: Subscription = {\n                    request(n: number) {\n                        if (cancelled) return;\n                        if (n <= 0) {\n                            subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                            return;\n                        }\n                        demand = Math.min(demand + n, Number.MAX_SAFE_INTEGER);\n                        if (innerSub) innerSub.request(n);\n                    },\n                    unsubscribe() {\n                        cancelled = true;\n                        outerSub.unsubscribe();\n                        innerSub?.unsubscribe();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s) { outerSub = s; subscriber.onSubscribe(operatorSub); },\n                    onNext(_v) {},\n                    onError(e) { if (!cancelled) subscriber.onError(e); },\n                    onComplete() {\n                        if (cancelled) return;\n                        innerSub = other.subscribe({\n                            onSubscribe(_s) {},\n                            onNext(v) { subscriber.onNext(v); },\n                            onError(e) { subscriber.onError(e); },\n                            onComplete() { subscriber.onComplete(); }\n                        });\n                        if (demand > 0) innerSub.request(demand);\n                    }\n                });\n                outerSub.request(1);\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Delays delivery of the emitted value by `ms` milliseconds.\n     *\n     * The delay is introduced **after** the source emits; completion and errors\n     * are forwarded without delay.\n     *\n     * @param ms - Delay in milliseconds.\n     * @returns A `Mono<T>` whose value arrives `ms` milliseconds later.\n     *\n     * @example\n     * ```typescript\n     * Mono.just('hello').delayElement(200).subscribe(v => console.log(v));\n     * ```\n     */\n    public delayElement(ms: number): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let timerId: ReturnType<typeof setTimeout> | null = null;\n                let cancelled = false;\n                const sub = this.source.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(v) {\n                        if (cancelled) return;\n                        timerId = setTimeout(() => {\n                            if (!cancelled) {\n                                subscriber.onNext(v);\n                                subscriber.onComplete();\n                            }\n                        }, ms);\n                    },\n                    onError(e) { subscriber.onError(e); },\n                    onComplete() { /* wait for timer, or complete immediately if no value */ }\n                });\n                const proxy: Subscription = {\n                    request(n) { sub.request(n); },\n                    unsubscribe() {\n                        cancelled = true;\n                        if (timerId !== null) clearTimeout(timerId);\n                        sub.unsubscribe();\n                    }\n                };\n                subscriber.onSubscribe(proxy);\n                return proxy;\n            }\n        });\n    }\n\n    /**\n     * Holds the emitted value until a trigger publisher (returned by `triggerFn`) emits\n     * or completes, then forwards the value downstream.\n     *\n     * If the trigger errors, the error is propagated and the value is discarded.\n     * If the source is empty, completes immediately without invoking `triggerFn`.\n     *\n     * @param triggerFn - Receives the emitted value and returns a trigger `Publisher`.\n     * @returns A `Mono<T>` that emits after the trigger fires.\n     *\n     * @example\n     * ```typescript\n     * Mono.just(42).delayUntil(() => Mono.delay(300)).subscribe(v => console.log(v));\n     * ```\n     */\n    public delayUntil(triggerFn: (value: T) => Publisher<unknown>): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let outerSub: Subscription = { request() {}, unsubscribe() {} };\n                let innerSub: Subscription | null = null;\n                let cancelled = false;\n\n                const operatorSub: Subscription = {\n                    request(n) { if (!cancelled) outerSub.request(n); },\n                    unsubscribe() {\n                        cancelled = true;\n                        outerSub.unsubscribe();\n                        innerSub?.unsubscribe();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s) { outerSub = s; subscriber.onSubscribe(operatorSub); },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        let trigger: Publisher<unknown>;\n                        try { trigger = triggerFn(v); }\n                        catch (e) {\n                            subscriber.onError(e instanceof Error ? e : new Error(String(e)));\n                            return;\n                        }\n                        let triggered = false;\n                        innerSub = trigger.subscribe({\n                            onSubscribe(_s) {},\n                            onNext(_u) {\n                                if (triggered || cancelled) return;\n                                triggered = true;\n                                innerSub?.unsubscribe();\n                                subscriber.onNext(v);\n                                subscriber.onComplete();\n                            },\n                            onError(e) { if (!cancelled) subscriber.onError(e); },\n                            onComplete() {\n                                if (!triggered && !cancelled) {\n                                    triggered = true;\n                                    subscriber.onNext(v);\n                                    subscriber.onComplete();\n                                }\n                            }\n                        });\n                        innerSub.request(Number.MAX_SAFE_INTEGER);\n                    },\n                    onError(e) { if (!cancelled) subscriber.onError(e); },\n                    onComplete() { if (!cancelled && !innerSub) subscriber.onComplete(); }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Falls back to `other` if this `Mono` completes without emitting a value (empty).\n     *\n     * If this `Mono` emits a value or errors, `other` is never subscribed to.\n     *\n     * @param other - The fallback `Mono<T>` to subscribe to when the source is empty.\n     * @returns A `Mono<T>` that emits from `other` when the source is empty.\n     *\n     * @example\n     * ```typescript\n     * Mono.empty<number>().or(Mono.just(99)).subscribe(v => console.log(v)); // 99\n     * ```\n     */\n    public or(other: Mono<T>): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let outerSub: Subscription = { request() {}, unsubscribe() {} };\n                let innerSub: Subscription | null = null;\n                let cancelled = false;\n                let emitted = false;\n\n                const operatorSub: Subscription = {\n                    request(n) {\n                        if (cancelled) return;\n                        if (innerSub) innerSub.request(n);\n                        else outerSub.request(n);\n                    },\n                    unsubscribe() {\n                        cancelled = true;\n                        outerSub.unsubscribe();\n                        innerSub?.unsubscribe();\n                    }\n                };\n\n                this.source.subscribe({\n                    onSubscribe(s) { outerSub = s; subscriber.onSubscribe(operatorSub); },\n                    onNext(v: T) {\n                        if (cancelled) return;\n                        emitted = true;\n                        subscriber.onNext(v);\n                    },\n                    onError(e) { if (!cancelled) subscriber.onError(e); },\n                    onComplete() {\n                        if (cancelled || emitted) return;\n                        innerSub = other.subscribe({\n                            onSubscribe(_s) {},\n                            onNext(v) { if (!cancelled) subscriber.onNext(v); },\n                            onError(e) { if (!cancelled) subscriber.onError(e); },\n                            onComplete() { if (!cancelled) subscriber.onComplete(); }\n                        });\n                        innerSub.request(1);\n                    }\n                });\n\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Re-subscribes to this `Mono` on error, using a control publisher to decide\n     * whether and when to retry.\n     *\n     * Each time the source errors, the error is pushed to the control stream returned\n     * by `fn`. If that stream emits any item, the source is re-subscribed. If it\n     * completes or errors, that terminal signal is forwarded downstream.\n     *\n     * @param fn - Receives a `Flux<Error>` of upstream errors; returns a control publisher.\n     * @returns A `Mono<T>` that retries according to the control signal.\n     *\n     * @example\n     * ```typescript\n     * Mono.error(new Error('boom'))\n     *   .retryWhen(errors => errors.take(3))\n     *   .subscribe(undefined, e => console.error(e));\n     * ```\n     */\n    public retryWhen(fn: (errors: Flux<Error>) => Publisher<unknown>): Mono<T> {\n        return new Mono<T>({\n            subscribe: (subscriber: Subscriber<T>): Subscription => {\n                let cancelled = false;\n                let currentSub: Subscription | null = null;\n                let emitted = false;\n\n                // Relay subscriber that the control stream holds\n                let controlSub: { onNext: (e: Error) => void } | null = null;\n\n                const errorRelay = Flux.from<Error>({\n                    subscribe(relaySubscriber) {\n                        controlSub = { onNext: (e) => relaySubscriber.onNext(e) };\n                        const sub: Subscription = {\n                            request(_n) {},\n                            unsubscribe() { cancelled = true; }\n                        };\n                        relaySubscriber.onSubscribe(sub);\n                        return sub;\n                    }\n                });\n\n                const control = fn(errorRelay);\n\n                let controlSubscriber: {\n                    onNext: (v: unknown) => void;\n                    onError: (e: Error) => void;\n                    onComplete: () => void;\n                };\n\n                const attempt = () => {\n                    if (cancelled || emitted) return;\n                    currentSub = this.source.subscribe({\n                        onSubscribe(_s) {},\n                        onNext(v: T) {\n                            if (cancelled || emitted) return;\n                            emitted = true;\n                            subscriber.onNext(v);\n                            subscriber.onComplete();\n                        },\n                        onError(e: Error) {\n                            if (cancelled) return;\n                            controlSub?.onNext(e);\n                        },\n                        onComplete() {\n                            if (!cancelled && !emitted) subscriber.onComplete();\n                        }\n                    });\n                    currentSub.request(1);\n                };\n\n                const controlSub2 = control.subscribe({\n                    onSubscribe(_s) {},\n                    onNext(_v: unknown) { if (!cancelled && !emitted) attempt(); },\n                    onError(e: Error) { if (!cancelled) subscriber.onError(e); },\n                    onComplete() { if (!cancelled && !emitted) subscriber.onComplete(); }\n                });\n                controlSub2.request(Number.MAX_SAFE_INTEGER);\n\n                controlSubscriber = {\n                    onNext: (_v) => { if (!cancelled && !emitted) attempt(); },\n                    onError: (e) => { if (!cancelled) subscriber.onError(e); },\n                    onComplete: () => { if (!cancelled && !emitted) subscriber.onComplete(); }\n                };\n                void controlSubscriber;\n\n                attempt();\n\n                const operatorSub: Subscription = {\n                    request(_n) {},\n                    unsubscribe() {\n                        cancelled = true;\n                        currentSub?.unsubscribe();\n                        controlSub2.unsubscribe();\n                    }\n                };\n                subscriber.onSubscribe(operatorSub);\n                return operatorSub;\n            }\n        });\n    }\n\n    /**\n     * Alias for {@link Mono#toPromise} — returns a `Promise<T | null>` that resolves\n     * with the emitted value (or `null` if the `Mono` is empty).\n     *\n     * @returns A `Promise<T | null>`.\n     */\n    public toFuture(): Promise<T | null> {\n        return this.toPromise();\n    }\n\n    /**\n     * Subscribes to this `Mono` and returns a `Promise<T | null>`.\n     *\n     * The promise resolves with the emitted value, or with `null` if the `Mono` completes empty.\n     * The promise rejects if the `Mono` signals an error.\n     *\n     * @returns A `Promise<T | null>` that resolves when the `Mono` terminates.\n     */\n    public toPromise(): Promise<T | null> {\n        return new Promise<T | null>((resolve, reject) => {\n            let value: T | null = null;\n            const sub = this.subscribe({\n                onSubscribe(_s) {},\n                onNext(v) { value = v; },\n                onError(e) { reject(e); },\n                onComplete() { resolve(value); }\n            });\n            sub.request(Number.MAX_SAFE_INTEGER);\n        });\n    }\n}\n","import {Sink} from \"@/sinks/Sink\";\nimport {Flux, Publisher} from \"@/publishers\";\nimport {Subscriber, Subscription} from \"@/subscriptions\";\n\n// Rule 1.1: demand tracked per subscriber — onNext only sent when demand >= 1\ntype Entry = { demand: number; cancelled: boolean; completionQueued: boolean };\n\nexport default class OneSink<T> implements Sink<T>, Publisher<T> {\n    private pendingValue: { value: T } | null = null;\n    private completed: boolean = false;\n    private terminalError: Error | null = null;\n    private readonly entries = new Map<Subscriber<T>, Entry>();\n\n    private get terminated(): boolean {\n        return this.completed || this.terminalError !== null;\n    }\n\n    next(value: T): void {\n        if (this.terminated || this.pendingValue !== null) return;\n        this.pendingValue = { value };\n    }\n\n    error(error: Error): void {\n        if (this.terminated) return;\n        this.terminalError = error;\n        for (const [s, e] of this.entries) {\n            if (!e.cancelled) s.onError(error);\n        }\n        this.entries.clear();\n    }\n\n    complete(): void {\n        if (this.terminated) return;\n        this.completed = true;\n        for (const [s, entry] of this.entries) {\n            if (entry.cancelled) continue;\n            if (this.pendingValue === null) {\n                s.onComplete();\n                this.entries.delete(s);\n            } else if (entry.demand >= 1) {\n                entry.demand--;\n                s.onNext(this.pendingValue.value);\n                if (!entry.cancelled) s.onComplete();\n                this.entries.delete(s);\n            } else {\n                // No demand yet — defer delivery until request(n)\n                entry.completionQueued = true;\n            }\n        }\n    }\n\n    asFlux(): Flux<T> {\n        return Flux.from(this);\n    }\n\n    subscribe(subscriber: Subscriber<T>): Subscription {\n        if (this.terminalError) {\n            const sub = { request() {}, unsubscribe() {} };\n            subscriber.onSubscribe(sub);\n            subscriber.onError(this.terminalError);\n            return sub;\n        }\n\n        const entry: Entry = { demand: 0, cancelled: false, completionQueued: this.completed };\n        this.entries.set(subscriber, entry);\n\n        // Already completed with no value — signal immediately\n        if (this.completed && this.pendingValue === null) {\n            this.entries.delete(subscriber);\n            const sub = { request() {}, unsubscribe() {} };\n            subscriber.onSubscribe(sub);\n            subscriber.onComplete();\n            return sub;\n        }\n\n        const sub = {\n            request: (n: number) => {\n                if (entry.cancelled) return;\n                // Rule 3.9: request(n ≤ 0) MUST signal onError\n                if (n <= 0) {\n                    entry.cancelled = true;\n                    this.entries.delete(subscriber);\n                    subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                    return;\n                }\n                entry.demand = Math.min(entry.demand + n, Number.MAX_SAFE_INTEGER);\n                // Deliver queued value now that demand is available\n                if (entry.completionQueued && this.pendingValue !== null && entry.demand >= 1) {\n                    entry.demand--;\n                    entry.cancelled = true;\n                    this.entries.delete(subscriber);\n                    subscriber.onNext(this.pendingValue.value);\n                    subscriber.onComplete();\n                }\n            },\n            unsubscribe: () => {\n                entry.cancelled = true;\n                this.entries.delete(subscriber);\n            }\n        };\n        subscriber.onSubscribe(sub);\n        return sub;\n    }\n}\n","import {Sink} from \"@/sinks/Sink\";\nimport {Flux, Publisher} from \"@/publishers\";\nimport {Subscriber, Subscription} from \"@/subscriptions\";\n\ntype Terminal = { kind: 'completed' } | { kind: 'error'; error: Error };\n\nexport default class EmptySink<T> implements Sink<T>, Publisher<T> {\n    private terminal: Terminal | null = null;\n    private readonly subscribers = new Set<Subscriber<T>>();\n\n    next(_value: T): void {}\n\n    error(error: Error): void {\n        if (this.terminal) return;\n        this.terminal = { kind: 'error', error };\n        for (const s of this.subscribers) s.onError(error);\n        this.subscribers.clear();\n    }\n\n    complete(): void {\n        if (this.terminal) return;\n        this.terminal = { kind: 'completed' };\n        for (const s of this.subscribers) s.onComplete();\n        this.subscribers.clear();\n    }\n\n    asFlux(): Flux<T> {\n        return Flux.from(this);\n    }\n\n    subscribe(subscriber: Subscriber<T>): Subscription {\n        if (this.terminal) {\n            const sub = { request() {}, unsubscribe() {} };\n            subscriber.onSubscribe(sub);\n            this.terminal.kind === 'completed'\n                ? subscriber.onComplete()\n                : subscriber.onError(this.terminal.error);\n            return sub;\n        }\n        this.subscribers.add(subscriber);\n        const sub = {\n            // Rule 3.9: request(n ≤ 0) MUST signal onError\n            request: (n: number) => {\n                if (!this.subscribers.has(subscriber)) return;\n                if (n <= 0) {\n                    this.subscribers.delete(subscriber);\n                    subscriber.onError(new Error(`request must be > 0, but was ${n}`));\n                }\n            },\n            unsubscribe: () => { this.subscribers.delete(subscriber); }\n        };\n        subscriber.onSubscribe(sub);\n        return sub;\n    }\n}\n","import {Sink} from \"@/sinks/Sink\";\nimport {Flux, Publisher} from \"@/publishers\";\nimport {Subscriber, Subscription} from \"@/subscriptions\";\n\n/**\n * Base class for unicast sinks (one producer → at most one subscriber).\n *\n * Handles the common subscribe() boilerplate:\n *  - Reject a second subscriber with a descriptive error\n *  - Replay terminal signal immediately if already terminated\n *  - Build the Subscription with Rule 3.9 enforcement and demand accumulation\n *\n * Hooks (all no-ops by default, override as needed):\n *  - `shouldReplayTerminalOnSubscribe()` — override to false for buffer-based sinks\n *    that can accept a subscriber after termination and deliver buffered items first\n *  - `onDemandGranted()`  — called after demand is accumulated (e.g. drain)\n *  - `onUnsubscribed()`   — extra cleanup on cancel (e.g. clear buffer)\n *  - `afterSubscribed()`  — called after subscriber.onSubscribe() (e.g. initial drain)\n *  - `onTerminal()`       — how to deliver terminal signal (default: direct; override for drain)\n */\nexport abstract class AbstractUnicastSink<T> implements Sink<T>, Publisher<T> {\n\n    protected subscriber: Subscriber<T> | null = null;\n    protected demand = 0;\n    protected cancelled = false;\n    protected terminated = false;\n    protected terminalError: Error | null = null;\n\n    abstract next(value: T): void;\n\n    asFlux(): Flux<T> {\n        return Flux.from(this);\n    }\n\n    // ──── Hooks ──────────────────────────────────────────────────────────────\n\n    /** True → replay terminal immediately for late subscribers. */\n    protected shouldReplayTerminalOnSubscribe(): boolean {\n        return this.terminated;\n    }\n\n    /** Called after demand is accumulated in this.demand. Default: noop. */\n    protected onDemandGranted(): void {}\n\n    /** Called after subscriber is cleared on unsubscribe. Default: noop. */\n    protected onUnsubscribed(): void {}\n\n    /** Called after subscriber.onSubscribe(sub). Default: noop. */\n    protected afterSubscribed(): void {}\n\n    /**\n     * How to deliver the terminal signal. Called by both error() and complete().\n     * Default: direct onError / onComplete. Override to use drain() instead.\n     */\n    protected onTerminal(): void {\n        if (this.subscriber && !this.cancelled) {\n            this.terminalError\n                ? this.subscriber.onError(this.terminalError)\n                : this.subscriber.onComplete();\n        }\n    }\n\n    // ──── Terminal signal ─────────────────────────────────────────────────────\n\n    error(error: Error): void {\n        if (this.terminated) return;\n        this.terminated = true;\n        this.terminalError = error;\n        this.onTerminal();\n    }\n\n    complete(): void {\n        if (this.terminated) return;\n        this.terminated = true;\n        this.onTerminal();\n    }\n\n    // ──── Subscribe ───────────────────────────────────────────────────────────\n\n    subscribe(subscriber: Subscriber<T>): Subscription {\n        if (this.subscriber !== null) {\n            const noop = { request() {}, unsubscribe() {} };\n            subscriber.onSubscribe(noop);\n            subscriber.onError(new Error(`${this.constructor.name} allows only one subscriber`));\n            return noop;\n        }\n        if (this.shouldReplayTerminalOnSubscribe()) {\n            const sub = { request() {}, unsubscribe() {} };\n            subscriber.onSubscribe(sub);\n            this.terminalError\n                ? subscriber.onError(this.terminalError)\n                : subscriber.onComplete();\n            return sub;\n        }\n\n        this.subscriber = subscriber;\n        const sub = {\n            request: (n: number) => {\n                if (this.cancelled) return;\n                // Rule 3.9: request(n ≤ 0) MUST signal onError\n                if (n <= 0) {\n                    this.cancelled = true;\n                    const s = this.subscriber;\n                    this.subscriber = null;\n                    s?.onError(new Error(`request must be > 0, but was ${n}`));\n                    return;\n                }\n                this.demand = Math.min(this.demand + n, Number.MAX_SAFE_INTEGER);\n                this.onDemandGranted();\n            },\n            unsubscribe: () => {\n                this.cancelled = true;\n                this.subscriber = null;\n                this.onUnsubscribed();\n            }\n        };\n\n        subscriber.onSubscribe(sub);\n        this.afterSubscribed();\n        return sub;\n    }\n}\n","import {AbstractUnicastSink} from \"@/sinks/internal/AbstractUnicastSink\";\n\nexport default class UnicastOnBackpressureBufferSink<T> extends AbstractUnicastSink<T> {\n\n    private readonly buffer: T[] = [];\n    // Rule 3.16: guard against re-entrant drain (onNext → request → drain)\n    private draining = false;\n\n    // ──── AbstractUnicastSink hooks ───────────────────────────────────────────\n\n    /** Allow late subscribers — they receive buffered items then the terminal signal. */\n    protected shouldReplayTerminalOnSubscribe(): boolean {\n        return false;\n    }\n\n    /** Use drain() for both error and complete so buffered items are delivered first. */\n    protected onTerminal(): void {\n        this.drain();\n    }\n\n    protected onDemandGranted(): void {\n        this.drain();\n    }\n\n    protected onUnsubscribed(): void {\n        this.buffer.length = 0;\n    }\n\n    protected afterSubscribed(): void {\n        this.drain();\n    }\n\n    // ──── Sink.next ───────────────────────────────────────────────────────────\n\n    next(value: T): void {\n        if (this.terminated || this.cancelled) return;\n        this.buffer.push(value);\n        this.drain();\n    }\n\n    // ──── Internal drain ──────────────────────────────────────────────────────\n\n    private drain(): void {\n        if (!this.subscriber || this.cancelled || this.draining) return;\n        this.draining = true;\n        try {\n            while (this.demand > 0 && this.buffer.length > 0) {\n                this.demand--;\n                this.subscriber.onNext(this.buffer.shift()!);\n                if (this.cancelled) return;\n            }\n            if (this.buffer.length === 0 && this.terminated) {\n                const s = this.subscriber;\n                this.subscriber = null;\n                this.terminalError ? s.onError(this.terminalError) : s.onComplete();\n            }\n        } finally {\n            this.draining = false;\n        }\n    }\n}\n","import {AbstractUnicastSink} from \"@/sinks/internal/AbstractUnicastSink\";\n\nexport default class UnicastOnBackpressureErrorSink<T> extends AbstractUnicastSink<T> {\n\n    next(value: T): void {\n        if (this.terminated || this.cancelled || !this.subscriber) return;\n        if (this.demand <= 0) {\n            this.error(new Error('UnicastOnBackpressureErrorSink: subscriber cannot keep up with demand'));\n            return;\n        }\n        this.demand--;\n        this.subscriber.onNext(value);\n    }\n}\n","import {AbstractMulticastSink} from \"@/sinks/internal/AbstractMulticastSink\";\n\ntype Entry = { demand: number; cancelled: boolean };\n\nexport default class MulticastDirectAllOrNothingSink<T> extends AbstractMulticastSink<T, Entry> {\n\n    protected createEntry(): Entry {\n        return { demand: 0, cancelled: false };\n    }\n\n    next(value: T): void {\n        if (this.terminated) return;\n        const active = [...this.entries.values()].filter(e => !e.cancelled);\n        if (active.length === 0 || !active.every(e => e.demand > 0)) return;\n        for (const [sub, entry] of this.entries) {\n            if (!entry.cancelled) {\n                entry.demand--;\n                sub.onNext(value);\n            }\n        }\n    }\n}\n","import {AbstractMulticastSink} from \"@/sinks/internal/AbstractMulticastSink\";\nimport {Subscriber} from \"@/subscriptions\";\n\ntype Entry = { demand: number; cancelled: boolean };\n\nexport default class MulticastDirectBestEffortSink<T> extends AbstractMulticastSink<T, Entry> {\n\n    protected createEntry(): Entry {\n        return { demand: 0, cancelled: false };\n    }\n\n    next(value: T): void {\n        if (this.terminated) return;\n        for (const [sub, entry] of this.entries) {\n            if (!entry.cancelled && entry.demand > 0) {\n                entry.demand--;\n                sub.onNext(value);\n            }\n        }\n    }\n}\n","import {AbstractMulticastSink} from \"@/sinks/internal/AbstractMulticastSink\";\nimport {Subscriber} from \"@/subscriptions\";\n\n// Rule 3.16: draining flag per subscriber prevents re-entrant drain (onNext → request → drain)\ntype Entry<T> = { buffer: T[]; demand: number; cancelled: boolean; draining: boolean };\n\nexport default class MulticastOnBackpressureBufferSink<T>\n    extends AbstractMulticastSink<T, Entry<T>> {\n\n    private readonly bufferSize: number;\n    private readonly autoCancel: boolean;\n\n    constructor(bufferSize: number = 256, autoCancel: boolean = true) {\n        super();\n        this.bufferSize = bufferSize;\n        this.autoCancel = autoCancel;\n    }\n\n    // ──── AbstractMulticastSink hooks ─────────────────────────────────────────\n\n    protected createEntry(): Entry<T> {\n        return { buffer: [], demand: 0, cancelled: false, draining: false };\n    }\n\n    /** Drain buffered items for each subscriber instead of completing immediately. */\n    protected deliverComplete(sub: Subscriber<T>, entry: Entry<T>): void {\n        this.drainEntry(sub, entry);\n    }\n\n    /** drainEntry handles its own cleanup — don't clear the map eagerly. */\n    protected clearEntriesAfterComplete(): boolean {\n        return false;\n    }\n\n    protected onDemandGranted(sub: Subscriber<T>, entry: Entry<T>): void {\n        this.drainEntry(sub, entry);\n    }\n\n    protected onUnsubscribed(_sub: Subscriber<T>, _entry: Entry<T>): void {\n        if (this.autoCancel && this.entries.size === 0) this.terminated = true;\n    }\n\n    // ──── Sink.next ───────────────────────────────────────────────────────────\n\n    next(value: T): void {\n        if (this.terminated) return;\n        for (const [sub, entry] of this.entries) {\n            if (entry.cancelled) continue;\n            if (entry.demand > 0) {\n                entry.demand--;\n                sub.onNext(value);\n            } else if (entry.buffer.length < this.bufferSize) {\n                entry.buffer.push(value);\n            } else {\n                entry.cancelled = true;\n                this.entries.delete(sub);\n                sub.onError(new Error('MulticastOnBackpressureBufferSink: buffer overflow'));\n                if (this.autoCancel && this.entries.size === 0) this.terminated = true;\n            }\n        }\n    }\n\n    // ──── Internal drain ──────────────────────────────────────────────────────\n\n    private drainEntry(sub: Subscriber<T>, entry: Entry<T>): void {\n        if (entry.cancelled || entry.draining) return;\n        entry.draining = true;\n        try {\n            while (entry.demand > 0 && entry.buffer.length > 0) {\n                entry.demand--;\n                sub.onNext(entry.buffer.shift()!);\n                if (entry.cancelled) return;\n            }\n            if (entry.buffer.length === 0 && this.terminated) {\n                this.entries.delete(sub);\n                this.terminalError ? sub.onError(this.terminalError) : sub.onComplete();\n            }\n        } finally {\n            entry.draining = false;\n        }\n    }\n}\n","import {AbstractMulticastSink} from \"@/sinks/internal/AbstractMulticastSink\";\nimport {Subscriber} from \"@/subscriptions\";\n\n// Rule 3.16: draining flag prevents re-entrant drain (onNext → request → drain)\ntype Entry<T> = { replay: T[]; demand: number; cancelled: boolean; draining: boolean };\n\n/**\n * Replays the latest `limit` emitted items to each new subscriber.\n * Used for both `Sinks.many().replay().latest(limit)` and `Sinks.many().replay().limit(limit)`.\n */\nexport default class ReplayLatestSink<T> extends AbstractMulticastSink<T, Entry<T>> {\n\n    private readonly limit: number;\n    private readonly history: T[] = [];\n\n    constructor(limit: number) {\n        super();\n        this.limit = limit;\n    }\n\n    // ──── AbstractMulticastSink hooks ─────────────────────────────────────────\n\n    protected createEntry(): Entry<T> {\n        return { replay: [...this.history], demand: 0, cancelled: false, draining: false };\n    }\n\n    protected shouldReplayTerminalOnSubscribe(): boolean {\n        return this.terminated && this.history.length === 0;\n    }\n\n    /** Drain buffered replay queue first, then signal error. */\n    protected deliverError(sub: Subscriber<T>, entry: Entry<T>): void {\n        this.drainEntry(sub, entry);\n        if (!entry.cancelled) sub.onError(this.terminalError!);\n    }\n\n    /** Drain buffered replay queue — drainEntry signals complete when done. */\n    protected deliverComplete(sub: Subscriber<T>, entry: Entry<T>): void {\n        if (!entry.cancelled) this.drainEntry(sub, entry);\n    }\n\n    protected clearEntriesAfterComplete(): boolean {\n        return false;\n    }\n\n    protected onDemandGranted(sub: Subscriber<T>, entry: Entry<T>): void {\n        this.drainEntry(sub, entry);\n    }\n\n    // ──── Sink.next ───────────────────────────────────────────────────────────\n\n    next(value: T): void {\n        if (this.terminated) return;\n        this.history.push(value);\n        if (this.history.length > this.limit) this.history.shift();\n        for (const [sub, entry] of this.entries) {\n            if (!entry.cancelled) {\n                entry.replay.push(value);\n                this.drainEntry(sub, entry);\n            }\n        }\n    }\n\n    // ──── Internal drain ──────────────────────────────────────────────────────\n\n    private drainEntry(sub: Subscriber<T>, entry: Entry<T>): void {\n        if (entry.cancelled || entry.draining) return;\n        entry.draining = true;\n        try {\n            while (entry.demand > 0 && entry.replay.length > 0) {\n                entry.demand--;\n                sub.onNext(entry.replay.shift()!);\n                if (entry.cancelled) return;\n            }\n            if (entry.replay.length === 0 && this.terminated) {\n                this.entries.delete(sub);\n                this.terminalError ? sub.onError(this.terminalError) : sub.onComplete();\n            }\n        } finally {\n            entry.draining = false;\n        }\n    }\n}\n","import {AbstractMulticastSink} from \"@/sinks/internal/AbstractMulticastSink\";\nimport {Subscriber} from \"@/subscriptions\";\n\n// Rule 3.16: draining flag prevents re-entrant drain (onNext → request → drain)\ntype Entry<T> = { pending: T; hasPending: boolean; demand: number; cancelled: boolean; draining: boolean };\n\n/**\n * Replays the latest emitted item to new subscribers, or the default value if no item was emitted yet.\n */\nexport default class ReplayLatestOrDefaultSink<T> extends AbstractMulticastSink<T, Entry<T>> {\n\n    private latestValue: T;\n\n    constructor(defaultValue: T) {\n        super();\n        this.latestValue = defaultValue;\n    }\n\n    // ──── AbstractMulticastSink hooks ─────────────────────────────────────────\n\n    protected createEntry(): Entry<T> {\n        return { pending: this.latestValue, hasPending: true, demand: 0, cancelled: false, draining: false };\n    }\n\n    /**\n     * Only replay an error terminal immediately. If completed, allow subscription\n     * so the subscriber can still receive the latest value.\n     */\n    protected shouldReplayTerminalOnSubscribe(): boolean {\n        return this.terminated && this.terminalError !== null;\n    }\n\n    /** Drain pending value first, then signal error. */\n    protected deliverError(sub: Subscriber<T>, entry: Entry<T>): void {\n        this.drainEntry(sub, entry);\n        if (!entry.cancelled) sub.onError(this.terminalError!);\n    }\n\n    /** Drain pending value — drainEntry signals complete when done. */\n    protected deliverComplete(sub: Subscriber<T>, entry: Entry<T>): void {\n        if (!entry.cancelled) this.drainEntry(sub, entry);\n    }\n\n    protected clearEntriesAfterComplete(): boolean {\n        return false;\n    }\n\n    protected onDemandGranted(sub: Subscriber<T>, entry: Entry<T>): void {\n        this.drainEntry(sub, entry);\n    }\n\n    // ──── Sink.next ───────────────────────────────────────────────────────────\n\n    next(value: T): void {\n        if (this.terminated) return;\n        this.latestValue = value;\n        for (const [sub, entry] of this.entries) {\n            if (!entry.cancelled) {\n                entry.pending = value;\n                entry.hasPending = true;\n                this.drainEntry(sub, entry);\n            }\n        }\n    }\n\n    // ──── Internal drain ──────────────────────────────────────────────────────\n\n    private drainEntry(sub: Subscriber<T>, entry: Entry<T>): void {\n        if (entry.cancelled || entry.draining) return;\n        entry.draining = true;\n        try {\n            if (entry.hasPending && entry.demand > 0) {\n                entry.demand--;\n                entry.hasPending = false;\n                sub.onNext(entry.pending);\n                if (entry.cancelled) return;\n            }\n            if (!entry.hasPending && this.terminated) {\n                this.entries.delete(sub);\n                this.terminalError ? sub.onError(this.terminalError) : sub.onComplete();\n            }\n        } finally {\n            entry.draining = false;\n        }\n    }\n}\n","import {Flux, Publisher} from \"@/publishers\";\nimport {Sink} from \"@/sinks/Sink\";\nimport OneSink from \"@/sinks/OneSink\";\nimport EmptySink from \"@/sinks/EmptySink\";\nimport UnicastOnBackpressureBufferSink from \"@/sinks/UnicastOnBackpressureBufferSink\";\nimport UnicastOnBackpressureErrorSink from \"@/sinks/UnicastOnBackpressureErrorSink\";\nimport MulticastDirectAllOrNothingSink from \"@/sinks/MulticastDirectAllOrNothingSink\";\nimport MulticastDirectBestEffortSink from \"@/sinks/MulticastDirectBestEffortSink\";\nimport MulticastOnBackpressureBufferSink from \"@/sinks/MulticastOnBackpressureBufferSink\";\nimport ReplayAllSink from \"@/sinks/ReplayAllSink\";\nimport ReplayLatestSink from \"@/sinks/ReplayLatestSink\";\nimport ReplayLatestOrDefaultSink from \"@/sinks/ReplayLatestOrDefaultSink\";\n\n/**\n * A {@link Sink} that is also a {@link Publisher}, with a convenience `asFlux()` accessor.\n * Callers can push values via the `Sink` interface, subscribe via the `Publisher` interface,\n * or obtain a full-featured {@link Flux} view via `asFlux()`.\n */\nexport type SinkPublisher<T> = Sink<T> & Publisher<T> & { asFlux(): Flux<T> };\n\nexport {type Sink};\n\n/**\n * Factory namespace for creating hot or replayable sink/publisher pairs.\n *\n * Each factory returns a {@link SinkPublisher} that implements both {@link Sink} (for pushing values)\n * and {@link Publisher} (for subscribing).\n *\n * @example\n * ```typescript\n * const sink = Sinks.many().multicast().directBestEffort<number>();\n * const flux = Flux.from(sink);\n * flux.subscribe(v => console.log(v));\n * sink.next(1);\n * sink.next(2);\n * sink.complete();\n * ```\n */\nexport const Sinks = {\n    /**\n     * A sink that immediately completes any subscriber without emitting values.\n     * Equivalent to `Flux.empty()` but hot/shared.\n     */\n    empty: <T>(): SinkPublisher<T> => new EmptySink(),\n\n    /**\n     * A sink for exactly one value. Replays that value (and subsequent completion) to all subscribers.\n     * Use for single-result async operations.\n     */\n    one: <T>(): SinkPublisher<T> => new OneSink(),\n\n    /** Creates a multi-subscriber sink factory. */\n    many: () => ({\n        /** Creates multicast (fan-out) sinks that deliver to all current subscribers. */\n        multicast: () => ({\n            /**\n             * Delivers each item to all current subscribers simultaneously.\n             * If any subscriber cannot accept the item (due to backpressure), **none** of them receive it.\n             */\n            directAllOrNothing: <T>(): SinkPublisher<T> =>\n                new MulticastDirectAllOrNothingSink(),\n\n            /**\n             * Delivers each item to all current subscribers on a best-effort basis.\n             * Subscribers that are not ready (backpressure) are skipped for that item.\n             */\n            directBestEffort: <T>(): SinkPublisher<T> =>\n                new MulticastDirectBestEffortSink(),\n\n            /**\n             * Buffers items and delivers them to all subscribers respecting backpressure.\n             *\n             * @param bufferSize - Maximum number of items to buffer (default: `256`).\n             * @param autoCancel - If `true`, cancels the sink when all subscribers unsubscribe (default: `true`).\n             */\n            onBackpressureBuffer: <T>(bufferSize: number = 256, autoCancel: boolean = true): SinkPublisher<T> =>\n                new MulticastOnBackpressureBufferSink(bufferSize, autoCancel),\n        }),\n\n        /** Creates unicast (single-subscriber) sinks. */\n        unicast: () => ({\n            /**\n             * Unicast sink that buffers items until the single subscriber requests them.\n             * A second `subscribe()` call throws.\n             */\n            onBackpressureBuffer: <T>(): SinkPublisher<T> =>\n                new UnicastOnBackpressureBufferSink(),\n\n            /**\n             * Unicast sink that errors if an item is pushed when the subscriber has no outstanding demand.\n             * A second `subscribe()` call throws.\n             */\n            onBackpressureError: <T>(): SinkPublisher<T> =>\n                new UnicastOnBackpressureErrorSink(),\n        }),\n\n        /** Creates replay sinks that buffer past items for late subscribers. */\n        replay: () => ({\n            /**\n             * Replays **all** previously emitted items to each new subscriber.\n             * Items are accumulated indefinitely.\n             */\n            all: <T>(): SinkPublisher<T> =>\n                new ReplayAllSink(),\n\n            /**\n             * Replays the most recent `limit` items to each new subscriber.\n             *\n             * @param limit - Maximum number of items to replay.\n             */\n            latest: <T>(limit: number): SinkPublisher<T> =>\n                new ReplayLatestSink(limit),\n\n            /**\n             * Replays the most recent item (or `value` if nothing has been emitted yet) to each new subscriber.\n             *\n             * @param value - Default value replayed until the first `next()` call.\n             */\n            latestOrDefault: <T>(value: T): SinkPublisher<T> =>\n                new ReplayLatestOrDefaultSink(value),\n\n            /**\n             * Alias for {@link latest}. Replays the most recent `limit` items.\n             *\n             * @param limit - Maximum number of items to replay.\n             */\n            limit: <T>(limit: number): SinkPublisher<T> =>\n                new ReplayLatestSink(limit),\n        }),\n    }),\n}\n"],"mappings":"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","names":["index_exports","__export","Flux","Mono","Schedulers","Signal","Sinks","__toCommonJS","AbstractMulticastSink","Flux","_sub","_entry","sub","entry","error","subscriber","n","ReplayAllSink","AbstractMulticastSink","sub","entry","value","Signal","value","error","AbstractPipePublisher","source","subscriberOrOnNext","onError","onComplete","onNext","demand","s","e","alternative","subscriber","primarySub","altSub","hasValue","cancelled","operatorSub","n","sourceSub","v","altSourceSub","replacement","_e","predicate","sub","_s","fn","first","scheduler","alt","fnErr","e2","ms","fallback","sourceDone","terminated","timer","clearTimer","startTimer","proxy","timerId","originalUnsub","label","tag","wrappedSub","Signal","pending","ImmediateScheduler","task","MicroScheduler","task","MacroScheduler","task","DelayScheduler","delay","task","id","IntervalScheduler","delay","task","id","Schedulers","ImmediateScheduler","MicroScheduler","MacroScheduler","ms","DelayScheduler","IntervalScheduler","Flux","_Flux","AbstractPipePublisher","source","publisher","generator","subscriber","buffer","demand","terminated","terminalDelivered","terminalError","cancelled","draining","drain","sink","v","err","subscription","n","e","iterable","item","start","count","i","sub","factory","items","error","emitter","requestCbs","cancelCbs","disposeCbs","fireDispose","fn","value","resourceSupplier","sourceFactory","cleanup","resource","sources","doneCount","subs","terminate","s","operatorSub","inner","won","finished","lastError","idx","j","ms","counter","id","combiner","queues","completed","tryEmit","q","args","result","done","pending","latest","hasValue","flush","_s","sourceSub","r","handler","emitted","sinkWrapper","outerSub","innerSubs","outerDone","innerSub","generation","myGen","predicate","pass","trigger","triggerSub","_v","maxRetries","currentSub","retries","attempt","reducer","acc","hasAcc","seedFactory","other","leftQueue","rightQueue","leftDone","rightDone","leftSub","rightSub","l","producer","onRequest","onUnsubscribe","Mono","last","index","defaultValue","_force","comparator","arr","maxSize","batch","ReplayAllSink","connected","entries","upstreamSub","connect","entry","skipped","skipping","gating","primarySub","seen","a","b","prev","first","sourceCompleted","wasZero","Schedulers","otherSub","otherSourceSub","otherSubRef","errBuf","errSub","errDemand","pushErr","drainErrs","errorFlux","relay","compBuf","compSub","compDemand","drainingComps","drainComps","pushComp","completeFlux","keyFn","groups","_n","key","g","timer","toEmit","resetTimer","val","triggerFn","_r","active","sourceDone","children","lastTime","now","Signal","signal","onDrop","hasLatest","prefetch","replenish","consumed","requestMore","toRequest","constructor","Mono","_Mono","AbstractPipePublisher","source","generator","subscriber","cancelled","demanded","terminated","pending","pendingError","tryDeliver","v","e","sink","err","subscription","n","publisher","value","sub","error","promise","factory","ms","id","fn","sources","done","completedCount","subs","_s","s","_v","result","outerSub","innerSub","demand","operatorSub","sourceSub","inner","r","predicate","pred","innerDone","passes","producer","onRequest","onUnsubscribe","mapper","Flux","other","left","right","leftDone","rightDone","failed","fail","leftSub","rightSub","tryEmit","timerId","proxy","triggerFn","trigger","triggered","_u","emitted","currentSub","controlSub","errorRelay","relaySubscriber","_n","control","controlSubscriber","attempt","controlSub2","resolve","reject","OneSink","value","error","s","e","entry","Flux","subscriber","sub","n","EmptySink","_value","error","s","Flux","subscriber","sub","n","AbstractUnicastSink","Flux","error","subscriber","noop","sub","n","s","UnicastOnBackpressureBufferSink","AbstractUnicastSink","value","s","UnicastOnBackpressureErrorSink","AbstractUnicastSink","value","MulticastDirectAllOrNothingSink","AbstractMulticastSink","value","active","e","sub","entry","MulticastDirectBestEffortSink","AbstractMulticastSink","value","sub","entry","MulticastOnBackpressureBufferSink","AbstractMulticastSink","bufferSize","autoCancel","sub","entry","_sub","_entry","value","ReplayLatestSink","AbstractMulticastSink","limit","sub","entry","value","ReplayLatestOrDefaultSink","AbstractMulticastSink","defaultValue","sub","entry","value","Sinks","EmptySink","OneSink","MulticastDirectAllOrNothingSink","MulticastDirectBestEffortSink","bufferSize","autoCancel","MulticastOnBackpressureBufferSink","UnicastOnBackpressureBufferSink","UnicastOnBackpressureErrorSink","ReplayAllSink","limit","ReplayLatestSink","value","ReplayLatestOrDefaultSink"]}