brass-runtime 1.13.8 → 1.15.0

package/dist/index.d.ts

@@ -1,11 +1,13 @@
-import { F as FiberEngine, W as WasmEngineRuntime, A as Async, R as RuntimeFiber, b as FiberEngineStats, c as Fiber, d as FiberId, e as FiberStatus, E as Exit, f as RuntimeEvent, g as WasmBridge, h as OpcodeProgram, i as FiberId$1, j as EngineEvent, k as RefId, N as NodeId, l as OpcodeNode, S as Scope, m as RingBufferOptions, n as EngineStats, O as Option } from './effect-ISvXPLgc.js';
-export { o as AsyncRegisterRef, a as AsyncWithPromise, p as BoundedRingBuffer, C as CancelToken, q as Canceler, r as Cause, s as CustomHostAction, D as DbHostAction, t as DecodeRef, u as DefaultHostExecutor, v as EngineKind, w as EngineSelection, x as EngineSelectionMode, y as FiberEngineKind, z as FlatMapRef, B as FoldFailureRef, G as FoldSuccessRef, H as HostAction, I as HostActionKind, J as HostActionResult, K as HostExecutionContext, L as HostExecutor, M as HostRegistry, P as HttpHostAction, Q as Interrupted, T as Joiner, U as None, V as NoopHooks, X as ProgramBuilder, Y as ProgramPatch, _ as PushStatus, $ as QueueHostAction, a0 as RingBuffer, a1 as RingBufferEngine, a2 as RingBufferStatsData, a3 as Runtime, a4 as RuntimeCapabilities, a5 as RuntimeEngineMode, a6 as RuntimeOptions, a7 as Scheduler, a8 as SchedulerEngine, a9 as SchedulerOptions, aa as SchedulerStats, ab as SchedulerStatsData, ac as ScopeId, ad as Some, ae as SyncRef, af as Task, ag as WasmFiberEngine, ah as WasmFiberEngineOptions, Z as ZIO, ai as acquireRelease, aj as async, ak as asyncCatchAll, al as asyncFail, am as asyncFlatMap, an as asyncFold, ao as asyncInterruptible, ap as asyncMap, aq as asyncMapError, ar as asyncSucceed, as as asyncSync, at as asyncTotal, au as catchAll, av as end, aw as engineStats, ax as fail, ay as flatMap, az as fork, aA as fromPromiseAbortable, aB as getBenchmarkBudget, aC as getCurrentFiber, aD as globalScheduler, aE as linkAbortController, aF as makeBoundedRingBuffer, aG as makeCancelToken, aH as map, aI as mapAsync, aJ as mapError, aK as mapTryAsync, aL as none, aM as orElseOptional, aN as runtimeCapabilities, aO as selectedEngineStats, aP as setBenchmarkBudget, aQ as some, aR as succeed, aS as sync, aT as toPromise, aU as unit, aV as unsafeGetCurrentRuntime, aW as unsafeRunAsync, aX as unsafeRunFoldWithEnv, aY as withAsyncPromise, aZ as withCurrentFiber, a_ as withScope, a$ as withScopeAsync } from './effect-ISvXPLgc.js';
-import { Z as ZStream } from './stream-BvukHxCv.js';
-export { C as Concat, E as Emit, a as Empty, F as Flatten, b as FromPull, M as Managed, c as Merge, N as Normalize, S as Scoped, d as assertNever, e as collectStream, f as concatStream, g as emitStream, h as emptyStream, i as flattenStream, j as foreachStream, k as fromArray, l as fromPull, m as managedStream, n as mapStream, o as merge, p as mergeStream, r as rangeStream, s as streamFromReadableStream, u as uncons, q as unwrapScoped, w as widenOpt, z as zip } from './stream-BvukHxCv.js';
+import { F as FiberEngine, W as WasmEngineRuntime, A as Async, R as RuntimeFiber, a as FiberEngineStats, b as Fiber, c as FiberId, d as FiberStatus, E as Exit, e as RuntimeEvent, f as WasmBridge, g as OpcodeProgram, h as FiberId$1, i as EngineEvent, j as RefId, N as NodeId, k as OpcodeNode, S as Scope, l as RingBufferOptions, m as EngineStats, O as Option } from './effect-CMOQKX8y.js';
+export { n as AbortablePromiseFinish, o as AbortablePromiseLabelStats, p as AbortablePromiseOptions, q as AbortablePromiseOutcome, r as AbortablePromiseStats, s as AsyncRegisterRef, t as AsyncWithPromise, u as BoundedRingBuffer, C as CancelToken, v as Canceler, w as Cause, x as CustomHostAction, D as DbHostAction, y as DecodeRef, z as DefaultHostExecutor, B as EngineKind, G as EngineSelection, H as EngineSelectionMode, I as FiberEngineKind, J as FlatMapRef, K as FoldFailureRef, L as FoldSuccessRef, M as HostAction, P as HostActionKind, Q as HostActionResult, T as HostExecutionContext, U as HostExecutor, V as HostRegistry, X as HostRegistryStats, Y as HttpHostAction, _ as Interrupted, $ as Joiner, a0 as LaneStatsData, a1 as None, a2 as NoopHooks, a3 as ProgramBuilder, a4 as ProgramPatch, a5 as PushStatus, a6 as QueueHostAction, a7 as RingBuffer, a8 as RingBufferEngine, a9 as RingBufferStatsData, aa as Runtime, ab as RuntimeCapabilities, ac as RuntimeEngineMode, ad as RuntimeOptions, ae as ScheduleResult, af as Scheduler, ag as SchedulerEngine, ah as SchedulerOptions, ai as SchedulerStats, aj as SchedulerStatsData, ak as ScopeId, al as Some, am as SyncRef, an as Task, ao as WasmFiberEngine, ap as WasmFiberEngineOptions, Z as ZIO, aq as abortablePromiseStats, ar as acquireRelease, as as async, at as asyncCatchAll, au as asyncFail, av as asyncFlatMap, aw as asyncFold, ax as asyncInterruptible, ay as asyncMap, az as asyncMapError, aA as asyncSucceed, aB as asyncSync, aC as asyncTotal, aD as catchAll, aE as end, aF as engineStats, aG as fail, aH as flatMap, aI as fork, aJ as fromPromiseAbortable, aK as getBenchmarkBudget, aL as getCurrentFiber, aM as globalScheduler, aN as inferCallerLaneFromStack, aO as laneTag, aP as linkAbortController, aQ as makeBoundedRingBuffer, aR as makeCancelToken, aS as map, aT as mapAsync, aU as mapError, aV as mapTryAsync, aW as none, aX as orElseOptional, aY as resetAbortablePromiseStats, aZ as runtimeCapabilities, a_ as runtimeForCaller, a$ as sanitizeLaneKey, b0 as selectedEngineStats, b1 as setBenchmarkBudget, b2 as some, b3 as succeed, b4 as sync, b5 as toPromise, b6 as toPromiseByCaller, b7 as unit, b8 as unsafeGetCurrentRuntime, b9 as unsafeRunAsync, ba as unsafeRunFoldWithEnv, bb as withAsyncPromise, bc as withCurrentFiber, bd as withScope, be as withScopeAsync } from './effect-CMOQKX8y.js';
+export { Counter, Gauge, Histogram, HistogramBuckets, Layer, ManagedResource, MetricSnapshot, MetricType, MetricValue, MetricsRegistry, Ref, RetryPolicy, RetryState, Schedule, ScheduleDecision, Semaphore, SemaphoreStats, ShutdownConfig, ShutdownStats, TaggedError, TestRuntimeOptions, TimeoutError, WorkerPool, WorkerPoolConfig, WorkerPoolError, WorkerPoolStats, andThenSchedule, assertCompletesWithin, assertFails, assertFailsWith, assertSucceeds, bracket, catchTag, catchTags, composeLayer, delayedEffect, derivedRef, elapsed, ensuring, exponential, fixed, flakyEffect, gracefulShutdown, intersect, jittered, layer, layerFail, layerFrom, layerSucceed, makeMetrics, makeRef, makeSemaphore, makeTestRuntime, makeWorkerPool, managed, managedAll, mapErrorTyped, mapLayer, mergeLayer, neverEffect, orElse, provideLayer, recurs, registerShutdownHooks, repeatWithSchedule, retry, retryN, retryWithBackoff, retryWithSchedule, sleep, tagError, takeSchedule, timeout, union, useManaged, whileInput } from './core/index.js';
+export { C as CircuitBreaker, a as CircuitBreakerConfig, b as CircuitBreakerError, c as CircuitBreakerState, d as CircuitBreakerStats, S as Span, e as SpanContext, f as SpanEvent, g as SpanStatus, T as Tracer, h as TracerConfig, m as makeCircuitBreaker, i as makeTracer } from './tracing-DNT9jEbr.js';
+import { Z as ZStream } from './stream-FQm9h4Mg.js';
+export { C as Concat, E as Emit, a as Empty, F as Flatten, b as FromArray, c as FromPull, M as Managed, d as Merge, N as Normalize, R as ReadableStreamOptions, S as Scoped, e as assertNever, f as collectStream, g as concatStream, h as emitStream, i as emptyStream, j as flattenStream, k as foreachStream, l as fromArray, m as fromPull, n as managedStream, o as mapStream, p as merge, q as mergeStream, r as rangeStream, s as streamFromReadableStream, u as uncons, t as unwrapScoped, w as widenOpt, z as zip } from './stream-FQm9h4Mg.js';
 
 declare class JsFiberEngine<R> implements FiberEngine<R> {
     private readonly runtime;
-    readonly kind: "js";
+    readonly kind: "ts";
     private startedFibers;
     constructor(runtime: WasmEngineRuntime<R> & any);
     fork<E, A>(effect: Async<R, E, A>, scopeId?: number): RuntimeFiber<R, E, A>;
@@ -18,26 +20,31 @@ declare class EngineFiberHandle<R, E, A> implements Fiber<E, A> {
     private readonly onInterrupt;
     private readonly onJoiner?;
     private readonly onQueued?;
+    private readonly onScheduleDropped?;
+    private readonly onScheduleRequest?;
     readonly id: FiberId;
     readonly runtime: WasmEngineRuntime<R> & any;
     fiberContext: any;
     name?: string;
     scopeId?: number;
     parentFiberId?: number;
+    lane?: string;
     private result;
     private readonly joiners;
     private readonly finalizers;
     private finalizersDrained;
     private internalStatus;
     private queued;
-    constructor(id: FiberId, runtime: WasmEngineRuntime<R> & any, onScheduledStep: (fiberId: FiberId) => void, onInterrupt: (fiberId: FiberId, reason: unknown) => void, onJoiner?: ((fiberId: FiberId) => void) | undefined, onQueued?: ((fiberId: FiberId) => void) | undefined);
+    constructor(id: FiberId, runtime: WasmEngineRuntime<R> & any, onScheduledStep: (fiberId: FiberId) => void, onInterrupt: (fiberId: FiberId, reason: unknown) => void, onJoiner?: ((fiberId: FiberId) => void) | undefined, onQueued?: ((fiberId: FiberId) => void) | undefined, onScheduleDropped?: ((fiberId: FiberId, label: string) => void) | undefined, onScheduleRequest?: ((fiberId: FiberId, label: string) => "accepted" | "dropped") | undefined);
     status(): FiberStatus;
     engineStatus(): InternalFiberStatus;
     setEngineStatus(status: InternalFiberStatus): void;
+    markDequeued(): void;
     join(cb: (exit: Exit<E, A>) => void): void;
     interrupt(): void;
     addFinalizer(f: (exit: Exit<E, A>) => void): void;
     schedule(tag?: string): void;
+    private scheduleWithRuntime;
     emit(ev: RuntimeEvent): void;
     succeed(value: A): void;
     fail(error: E): void;
@@ -47,43 +54,46 @@ declare class EngineFiberHandle<R, E, A> implements Fiber<E, A> {
     private runFinalizersOnce;
 }
 
-declare class ReferenceWasmBridge implements WasmBridge {
-    readonly kind: "wasm-reference";
-    private nextFiberId;
-    private readonly fibers;
-    private started;
-    private completed;
-    private failed;
-    private interrupted;
-    createFiber(program: OpcodeProgram): FiberId$1;
-    poll(fiberId: FiberId$1): EngineEvent;
-    provideValue(fiberId: FiberId$1, valueRef: RefId): EngineEvent;
-    provideError(fiberId: FiberId$1, errorRef: RefId): EngineEvent;
-    provideEffect(fiberId: FiberId$1, root: NodeId, nodes: OpcodeNode[]): EngineEvent;
-    interrupt(fiberId: FiberId$1, reasonRef: RefId): EngineEvent;
-    dropFiber(fiberId: FiberId$1): void;
-    stats(): unknown;
-    private mustFiber;
-    private step;
-    private success;
-    private failure;
-    private suspend;
-    private markDone;
-    private markFailed;
-}
-
 declare class WasmPackFiberBridge implements WasmBridge {
     readonly kind: "wasm";
+    readonly supportsBinary: boolean;
+    readonly supportsZeroCopy: boolean;
+    readonly supportsNoJsonMetrics: boolean;
     private readonly vm;
+    private jsonEventCalls;
+    private binaryEventCalls;
+    private zeroCopyEventCalls;
+    private eventsReceived;
+    private maxEventsPerCall;
+    private jsonPrograms;
+    private binaryPrograms;
+    private zeroCopyPrograms;
+    private jsonPatches;
+    private binaryPatches;
+    private zeroCopyPatches;
     constructor(modulePath?: string);
     createFiber(program: OpcodeProgram): FiberId$1;
     poll(fiberId: FiberId$1): EngineEvent;
+    driveBatch(fiberId: FiberId$1, budget: number): readonly EngineEvent[];
     provideValue(fiberId: FiberId$1, valueRef: RefId): EngineEvent;
+    provideValueBatch(fiberId: FiberId$1, valueRef: RefId, budget: number): readonly EngineEvent[];
     provideError(fiberId: FiberId$1, errorRef: RefId): EngineEvent;
+    provideErrorBatch(fiberId: FiberId$1, errorRef: RefId, budget: number): readonly EngineEvent[];
     provideEffect(fiberId: FiberId$1, root: NodeId, nodes: OpcodeNode[]): EngineEvent;
+    provideEffectBatch(fiberId: FiberId$1, root: NodeId, nodes: OpcodeNode[], budget: number): readonly EngineEvent[];
     interrupt(fiberId: FiberId$1, reasonRef: RefId): EngineEvent;
+    interruptBatch(fiberId: FiberId$1, reasonRef: RefId, budget: number): readonly EngineEvent[];
     dropFiber(fiberId: FiberId$1): void;
     stats(): unknown;
+    private assertStrictWasmHotPath;
+    private decodeZeroCopy;
+    private decodeBinary;
+    private decodeJson;
+    private memory;
+    private readU32;
+    private readF64;
+    private writeWords;
+    private readMetricsSnapshot;
 }
 
 type WasmFiberRegistryStats = {
@@ -120,6 +130,63 @@ declare class WasmFiberRegistryBridge {
     stats(): WasmFiberRegistryStats;
 }
 
+type ReadyQueueScheduleKind = "micro" | "macro" | "none" | "dropped";
+type FiberReadyQueueStats = {
+    readonly engine: "ts" | "wasm";
+    readonly fallbackUsed: boolean;
+    readonly data: unknown;
+};
+interface FiberReadyQueue {
+    readonly engine: "ts" | "wasm";
+    enqueue(fiberId: FiberId$1, tag: string): ReadyQueueScheduleKind;
+    beginFlush(): number;
+    shift(): FiberId$1 | undefined;
+    endFlush(ran: number): ReadyQueueScheduleKind;
+    len(): number;
+    clear(): void;
+    stats(): FiberReadyQueueStats;
+}
+type FiberReadyQueueOptions = {
+    readonly engine?: "ts" | "wasm";
+    readonly flushBudget?: number;
+    readonly microThreshold?: number;
+    readonly laneCapacity?: number;
+    readonly laneBudget?: number;
+    readonly maxLanes?: number;
+};
+declare function makeFiberReadyQueue(options?: FiberReadyQueueOptions): FiberReadyQueue;
+
+declare const ABI_VERSION = 1;
+declare const EVENT_WORDS = 5;
+declare const NONE_U32 = 4294967295;
+declare const enum OpcodeTagCode {
+    Succeed = 0,
+    Fail = 1,
+    Sync = 2,
+    Async = 3,
+    FlatMap = 4,
+    Fold = 5,
+    Fork = 6,
+    HostAction = 7
+}
+declare const enum EventKindCode {
+    Continue = 0,
+    Done = 1,
+    Failed = 2,
+    Interrupted = 3,
+    InvokeSync = 4,
+    InvokeAsync = 5,
+    InvokeFlatMap = 6,
+    InvokeFoldFailure = 7,
+    InvokeFoldSuccess = 8,
+    InvokeFork = 9,
+    InvokeHostAction = 10
+}
+declare function encodeOpcodeProgram(program: OpcodeProgram): Uint32Array;
+declare function encodeOpcodeNodes(nodes: readonly OpcodeNode[]): Uint32Array;
+declare function decodeEvent(words: ArrayLike<number>, offset?: number): EngineEvent;
+declare function decodeEventBatch(words: ArrayLike<number> | null | undefined): EngineEvent[];
+
 declare function buffer<R, E, A>(stream: ZStream<{} & R, E, A>, capacity: number, strategy?: "backpressure" | "dropping" | "sliding"): ZStream<{} & R, E, A>;
 
 /**
@@ -152,6 +219,10 @@ type QueueClosed = {
 type Queue<A> = {
     offer: (a: A) => Async<unknown, never, boolean>;
     take: () => Async<unknown, QueueClosed, A>;
+    /** Offer multiple values in a single effect. Returns array of success flags. */
+    offerBatch: (values: readonly A[]) => Async<unknown, never, boolean[]>;
+    /** Take up to N values in a single effect. Returns available values (may be fewer than N). */
+    takeBatch: (n: number) => Async<unknown, QueueClosed, A[]>;
     size: () => number;
     shutdown: () => void;
 };
@@ -176,12 +247,13 @@ declare const broadcast: typeof makeHub;
 declare function broadcastToHub<R, E, A>(stream: ZStream<R, E, A>, hub: Hub<A>): Async<R, E, void>;
 declare function fromHub<A>(hub: Hub<A>): ZStream<unknown, HubClosed, A>;
 
-type StreamChunkEngine = "auto" | "js" | "wasm";
+type StreamChunkEngine = "ts" | "wasm";
 type StreamChunkOptions = {
     /**
-     * auto: use WASM when wasm/pkg is available, otherwise JS.
-     * js: always use the JS array chunker.
+     * ts: always use the TypeScript array chunker.
      * wasm: require BrassWasmChunkBuffer from wasm/pkg.
+     *
+     * Strict mode never falls back between engines.
      */
     engine?: StreamChunkEngine;
 };
@@ -219,7 +291,12 @@ declare function mapChunksEffect<Rp, Ep, A, B>(chunkSize: number, f: (chunk: rea
  * When applied to a stream `ZStream<R, E, In>`, the result is `ZStream<R & Rp, E | Ep, Out>`.
  */
 type ZPipeline<Rp, Ep, In, Out> = <R, E>(input: ZStream<R, E, In>) => ZStream<R & Rp, E | Ep, Out>;
-/** Apply a pipeline to a stream (alias of `pipeline(stream)`). */
+/** Apply a pipeline to a stream (alias of `pipeline(stream)`).
+ *
+ * OPTIMIZATION: When the pipeline is a single pure operator (has PURE_PIPELINE_TAG)
+ * and the stream can be drained synchronously, uses the fast fused path.
+ * The FusedPipelineRepr is cached on the pipeline to avoid recalculation.
+ */
 declare function via<R, E, A, Rp, Ep, B>(stream: ZStream<R, E, A>, pipeline: ZPipeline<Rp, Ep, A, B>): ZStream<R & Rp, E | Ep, B>;
 /** Compose pipelines left-to-right (p1 >>> p2). */
 declare function andThen<R1, E1, In, Mid, R2, E2, Out>(p1: ZPipeline<R1, E1, In, Mid>, p2: ZPipeline<R2, E2, Mid, Out>): ZPipeline<R1 & R2, E1 | E2, In, Out>;
@@ -255,4 +332,204 @@ declare function bufferP<A>(capacity: number, strategy?: "backpressure" | "dropp
  */
 declare function groupedP<A>(n: number): ZPipeline<unknown, never, A, A[]>;
 
-export { Async, EngineEvent, EngineFiberHandle, EngineStats, Exit, Fiber, FiberEngine, FiberEngineStats, FiberId, FiberStatus, type Hub, type HubClosed, type HubStrategy, type InternalFiberStatus, JsFiberEngine, NodeId, OpcodeNode, OpcodeProgram, Option, type Queue, type QueueClosed, type QueueOptions, RefId, ReferenceWasmBridge, RingBufferOptions, RuntimeFiber, Scope, type Strategy, type StreamChunkEngine, type StreamChunkOptions, type StreamChunkStats, type Subscription, WasmBridge, WasmEngineRuntime, WasmFiberRegistryBridge, type WasmFiberRegistryStats, WasmPackFiberBridge, type ZPipeline, ZStream, andThen, bounded, broadcast, broadcastToHub, buffer, bufferP, chunks, chunksP, collectAllPar, compose, dropP, filterMapP, filterP, fromHub, groupedP, identity, makeHub, makeStreamChunker, mapChunks, mapChunksEffect, mapChunksEffectP, mapEffectP, mapP, race, raceWith, takeP, tapEffectP, via, zipPar };
+/** Serialized representation of a single step in a fused pipeline */
+type SerializedStep = {
+    kind: "map";
+    fnSource: string;
+} | {
+    kind: "filter";
+    predSource: string;
+} | {
+    kind: "take";
+    n: number;
+} | {
+    kind: "drop";
+    n: number;
+};
+/** JSON-safe serialized representation of a fused pipeline */
+type SerializedFusedPipeline = {
+    readonly version: 1;
+    readonly steps: SerializedStep[];
+};
+/** Enable or disable fusion globally. When disabled, andThen will not attempt fusion. */
+declare function setFusionEnabled(enabled: boolean): void;
+/** Check if fusion is globally enabled. */
+declare function isFusionEnabled(): boolean;
+/** Set verbose mode globally. When enabled, fusion decisions are logged to console. */
+declare function setFusionVerbose(verbose: boolean): void;
+/** Check if verbose mode is globally enabled. */
+declare function isFusionVerbose(): boolean;
+/**
+ * Get stats from a fused pipeline, or null if the pipeline is not fused.
+ * Works with pipelines that have been fused via `andThen` (have `_fusedSteps`)
+ * or with `FusedPipelineRepr` objects directly.
+ */
+declare function getStats<In, Out>(pipeline: ZPipeline<unknown, never, In, Out>): FusedPipelineStats | null;
+declare const PURE_PIPELINE_TAG: unique symbol;
+/** Result of a fused step for an element */
+type FuseResult<A> = {
+    readonly tag: "emit";
+    readonly value: A;
+} | {
+    readonly tag: "skip";
+} | {
+    readonly tag: "halt";
+};
+/** Metadata of a step in the original pipeline */
+type FusedStep = {
+    readonly kind: "map";
+} | {
+    readonly kind: "filter";
+} | {
+    readonly kind: "take";
+    readonly n: number;
+} | {
+    readonly kind: "drop";
+    readonly n: number;
+};
+/** Stats of a fused pipeline */
+type FusedPipelineStats = {
+    readonly fusedSteps: number;
+    readonly steps: readonly FusedStep[];
+    readonly hasTake: boolean;
+    readonly hasDrop: boolean;
+};
+/** Internal representation of a fused pipeline */
+type FusedPipelineRepr<In, Out> = {
+    readonly _tag: "FusedPipeline";
+    readonly step: (a: In, state: FuseState) => FuseResult<Out>;
+    readonly initState: () => FuseState;
+    readonly stats: FusedPipelineStats;
+};
+/** Mutable state during execution (per-step counters for take/drop) */
+type FuseState = {
+    /** Per-step counters: each take/drop step gets its own independent counter */
+    counters: number[];
+};
+/** Fusion options */
+type FusionOptions = {
+    readonly enabled?: boolean;
+    readonly verbose?: boolean;
+};
+type PurePipelineMetadata<In, Out> = {
+    readonly kind: "map" | "filter" | "take" | "drop";
+    readonly fn?: (a: In) => Out;
+    readonly pred?: (a: In) => boolean;
+    readonly n?: number;
+};
+type PurePipelineTag<In, Out> = {
+    readonly [PURE_PIPELINE_TAG]: PurePipelineMetadata<In, Out>;
+};
+/** Creates a FuseState with per-step counters (one for each take/drop step) */
+declare function initState(counterCount: number): () => FuseState;
+/**
+ * Detects if a pipeline is fusable and returns the fused representation.
+ * Returns null if the pipeline is not fusable (not pure or fusion disabled).
+ */
+declare function fuse<In, Out>(pipeline: ZPipeline<unknown, never, In, Out>, options?: FusionOptions): FusedPipelineRepr<In, Out> | null;
+/**
+ * Applies a fused pipeline to an array of inputs synchronously.
+ * This is the fastest execution path — a pure `for` loop with no effects,
+ * no fibers, no scheduling overhead. O(n) with minimal constant factor.
+ */
+declare function runFusedArray<In, Out>(input: readonly In[], fused: FusedPipelineRepr<In, Out>): Out[];
+/**
+ * Applies a fused pipeline to a stream using a single pull loop.
+ * No intermediate fibers are created between fused operators.
+ *
+ * OPTIMIZATION: If the input stream can be drained synchronously (e.g., fromArray),
+ * the entire pipeline is executed as a pure synchronous loop — no effects at all.
+ */
+declare function applyFused<R, E, In, Out>(stream: ZStream<R, E, In>, fused: FusedPipelineRepr<In, Out>): ZStream<R, E, Out>;
+/**
+ * Serialize a fused pipeline to a JSON-safe representation.
+ * Returns null if the pipeline is not fused (no _fusedSteps metadata).
+ *
+ * For map/filter steps, the function/predicate source is captured via `.toString()`.
+ * Note: toString() has limitations with closures and minification, but is sufficient
+ * for debugging/observability use cases.
+ */
+declare function serializeFusedPipeline<In, Out>(pipeline: ZPipeline<unknown, never, In, Out>): SerializedFusedPipeline | null;
+/**
+ * Deserialize a serialized pipeline back to a functional pipeline.
+ * Returns null if deserialization fails (e.g., invalid version, malformed fnSource).
+ *
+ * Reconstructs functions using `new Function(...)` with appropriate wrapping.
+ * The resulting pipeline is functionally equivalent to the original for pure
+ * (non-closure) functions.
+ *
+ * WARNING: Uses `new Function()` which has security implications similar to `eval`.
+ * Only deserialize trusted serialized pipelines.
+ */
+declare function deserializeFusedPipeline<In, Out>(serialized: SerializedFusedPipeline): ZPipeline<unknown, never, In, Out> | null;
+
+/**
+ * Throttles a stream to emit at most one element per `intervalMs`.
+ * Elements arriving during the cooldown period are dropped.
+ *
+ * ```ts
+ * const throttled = throttle(clickStream, 1000); // max 1 click per second
+ * ```
+ */
+declare function throttle<R, E, A>(stream: ZStream<R, E, A>, intervalMs: number): ZStream<R, E, A>;
+/**
+ * Debounces a stream: only emits an element after `delayMs` of silence.
+ * If a new element arrives before the delay expires, the previous is dropped.
+ *
+ * Note: This is a simplified debounce that works by buffering the last element
+ * and emitting it after a delay. For real-time use cases, consider using
+ * the Hub-based approach with timers.
+ *
+ * ```ts
+ * const debounced = debounce(inputStream, 300); // wait 300ms of silence
+ * ```
+ */
+declare function debounce<R, E, A>(stream: ZStream<R, E, A>, delayMs: number): ZStream<R, E, A>;
+/**
+ * Zips two streams together, pairing elements by position.
+ * The resulting stream ends when either input stream ends.
+ *
+ * ```ts
+ * const zipped = zip(numbersStream, lettersStream);
+ * // [1, "a"], [2, "b"], [3, "c"], ...
+ * ```
+ */
+declare function zip<R, E, A, B>(left: ZStream<R, E, A>, right: ZStream<R, E, B>): ZStream<R, E, [A, B]>;
+/**
+ * Zips two streams with a custom combiner function.
+ *
+ * ```ts
+ * const summed = zipWith(xs, ys, (x, y) => x + y);
+ * ```
+ */
+declare function zipWith<R, E, A, B, C>(left: ZStream<R, E, A>, right: ZStream<R, E, B>, f: (a: A, b: B) => C): ZStream<R, E, C>;
+/**
+ * Produces a stream of accumulated values using a reducer function.
+ * Emits the initial value first, then each accumulated result.
+ *
+ * ```ts
+ * const running = scan(numbersStream, 0, (acc, n) => acc + n);
+ * // 0, 1, 3, 6, 10, ... (running sum)
+ * ```
+ */
+declare function scan<R, E, A, B>(stream: ZStream<R, E, A>, initial: B, f: (acc: B, a: A) => B): ZStream<R, E, B>;
+/**
+ * Interleaves two streams, alternating elements from each.
+ * When one stream ends, remaining elements from the other are emitted.
+ *
+ * ```ts
+ * const mixed = interleave(evens, odds);
+ * // 0, 1, 2, 3, 4, 5, ...
+ * ```
+ */
+declare function interleave<R, E, A>(left: ZStream<R, E, A>, right: ZStream<R, E, A>): ZStream<R, E, A>;
+/**
+ * Takes the first N elements from a stream.
+ */
+declare function take<R, E, A>(stream: ZStream<R, E, A>, n: number): ZStream<R, E, A>;
+/**
+ * Drops the first N elements from a stream.
+ */
+declare function drop<R, E, A>(stream: ZStream<R, E, A>, n: number): ZStream<R, E, A>;
+
+export { ABI_VERSION, Async, EVENT_WORDS, EngineEvent, EngineFiberHandle, EngineStats, EventKindCode, Exit, Fiber, FiberEngine, FiberEngineStats, FiberId, type FiberReadyQueue, type FiberReadyQueueOptions, type FiberReadyQueueStats, FiberStatus, type FuseResult, type FuseState, type FusedPipelineRepr, type FusedPipelineStats, type FusedStep, type FusionOptions, type Hub, type HubClosed, type HubStrategy, type InternalFiberStatus, JsFiberEngine, NONE_U32, NodeId, OpcodeNode, OpcodeProgram, OpcodeTagCode, Option, PURE_PIPELINE_TAG, type PurePipelineMetadata, type PurePipelineTag, type Queue, type QueueClosed, type QueueOptions, type ReadyQueueScheduleKind, RefId, RingBufferOptions, RuntimeFiber, Scope, type SerializedFusedPipeline, type SerializedStep, type Strategy, type StreamChunkEngine, type StreamChunkOptions, type StreamChunkStats, type Subscription, WasmBridge, WasmEngineRuntime, WasmFiberRegistryBridge, type WasmFiberRegistryStats, WasmPackFiberBridge, type ZPipeline, ZStream, andThen, applyFused, bounded, broadcast, broadcastToHub, buffer, bufferP, chunks, chunksP, collectAllPar, compose, debounce, decodeEvent, decodeEventBatch, deserializeFusedPipeline, dropP, drop as dropStream, encodeOpcodeNodes, encodeOpcodeProgram, filterMapP, filterP, fromHub, fuse, getStats, groupedP, identity, initState, interleave, isFusionEnabled, isFusionVerbose, makeFiberReadyQueue, makeHub, makeStreamChunker, mapChunks, mapChunksEffect, mapChunksEffectP, mapEffectP, mapP, race, raceWith, runFusedArray, scan, serializeFusedPipeline, setFusionEnabled, setFusionVerbose, takeP, take as takeStream, tapEffectP, throttle, via, zipPar, zip as zipStream, zipWith };