brass-runtime 1.13.7 → 1.14.0

package/dist/index.d.ts

@@ -1,11 +1,679 @@
-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 { A as Async, E as Exit, R as Runtime, F as FiberEngine, W as WasmEngineRuntime, b as RuntimeFiber, c as FiberEngineStats, d as Fiber, e as FiberId, f as FiberStatus, g as RuntimeEvent, h as WasmBridge, i as OpcodeProgram, j as FiberId$1, k as EngineEvent, l as RefId, N as NodeId, m as OpcodeNode, S as Scope, n as RingBufferOptions, o as EngineStats, O as Option } from './effect-DM56H743.js';
+export { p as AbortablePromiseFinish, q as AbortablePromiseLabelStats, r as AbortablePromiseOptions, s as AbortablePromiseOutcome, t as AbortablePromiseStats, u as AsyncRegisterRef, a as AsyncWithPromise, v as BoundedRingBuffer, C as CancelToken, w as Canceler, x as Cause, y as CustomHostAction, D as DbHostAction, z as DecodeRef, B as DefaultHostExecutor, G as EngineKind, H as EngineSelection, I as EngineSelectionMode, J as FiberEngineKind, K as FlatMapRef, L as FoldFailureRef, M as FoldSuccessRef, P as HostAction, Q as HostActionKind, T as HostActionResult, U as HostExecutionContext, V as HostExecutor, X as HostRegistry, Y as HostRegistryStats, _ as HttpHostAction, $ as Interrupted, a0 as Joiner, a1 as LaneStatsData, a2 as None, a3 as NoopHooks, a4 as ProgramBuilder, a5 as ProgramPatch, a6 as PushStatus, a7 as QueueHostAction, a8 as RingBuffer, a9 as RingBufferEngine, aa as RingBufferStatsData, 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-DM56H743.js';
+import { Z as ZStream } from './stream-Oqe6WeLE.js';
+export { a as CircuitBreaker, C as CircuitBreakerConfig, b as CircuitBreakerError, c as CircuitBreakerState, d as CircuitBreakerStats, e as Concat, E as Emit, f as Empty, F as Flatten, g as FromArray, h as FromPull, M as Managed, i as Merge, N as Normalize, S as Scoped, j as Span, k as SpanContext, l as SpanEvent, m as SpanStatus, T as Tracer, n as TracerConfig, o as assertNever, p as collectStream, q as concatStream, r as emitStream, s as emptyStream, t as flattenStream, u as foreachStream, v as fromArray, w as fromPull, x as makeCircuitBreaker, y as makeTracer, z as managedStream, A as mapStream, B as merge, D as mergeStream, G as rangeStream, H as streamFromReadableStream, I as uncons, J as unwrapScoped, K as widenOpt, L as zip } from './stream-Oqe6WeLE.js';
+
+type TimeoutError = {
+    readonly _tag: "TimeoutError";
+    readonly ms: number;
+};
+/**
+ * Suspends the fiber for `ms` milliseconds. Cancellable via fiber interruption.
+ */
+declare function sleep(ms: number): Async<unknown, never, void>;
+/**
+ * Runs `effect` with a timeout of `ms` milliseconds.
+ * - If the effect completes before the timeout, returns its result.
+ * - If the timeout fires first, the effect is cancelled and a TimeoutError is returned.
+ *
+ * Works with ANY effect type (Async, FlatMap, Fold, etc.) by forking
+ * the effect into a child fiber and interrupting it on timeout.
+ */
+declare function timeout<R, E, A>(effect: Async<R, E, A>, ms: number): Async<R, E | TimeoutError, A>;
+type RetryPolicy = {
+    /** Maximum number of retry attempts (0 = no retries, just the initial attempt) */
+    readonly maxRetries: number;
+    /** Base delay in ms for exponential backoff */
+    readonly baseDelayMs: number;
+    /** Maximum delay cap in ms */
+    readonly maxDelayMs: number;
+    /** Total time budget in ms (optional). Retries stop if elapsed time exceeds this. */
+    readonly maxElapsedMs?: number;
+    /** Custom predicate: should this error trigger a retry? Default: always retry. */
+    readonly shouldRetry?: (error: unknown, attempt: number) => boolean;
+    /** Jitter strategy. Default: "full" (random 0..delay). "none" = no jitter. */
+    readonly jitter?: "full" | "none";
+};
+type RetryState = {
+    readonly attempt: number;
+    readonly elapsedMs: number;
+    readonly lastError: unknown;
+};
+/**
+ * Retries an effect according to the given policy.
+ * Uses exponential backoff with full jitter by default.
+ *
+ * ```ts
+ * const result = retry(
+ *   fetchData(),
+ *   { maxRetries: 3, baseDelayMs: 100, maxDelayMs: 5000 }
+ * );
+ * ```
+ */
+declare function retry<R, E, A>(effect: Async<R, E, A>, policy: RetryPolicy): Async<R, E, A>;
+/**
+ * Retry with a simple count (no backoff, immediate retry).
+ * Useful for flaky operations that just need a few attempts.
+ */
+declare function retryN<R, E, A>(effect: Async<R, E, A>, n: number): Async<R, E, A>;
+/**
+ * Retry with exponential backoff and full jitter.
+ * Convenience wrapper with sensible defaults.
+ */
+declare function retryWithBackoff<R, E, A>(effect: Async<R, E, A>, opts?: {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    maxElapsedMs?: number;
+    shouldRetry?: (error: unknown, attempt: number) => boolean;
+}): Async<R, E, A>;
+
+/**
+ * Acquires a resource, uses it, and guarantees release regardless of outcome.
+ *
+ * - `acquire` runs uninterruptibly (once started, it completes)
+ * - `use` runs with the acquired resource
+ * - `release` runs after `use` completes (success, failure, or interruption)
+ *
+ * ```ts
+ * const result = bracket(
+ *   openConnection(),                    // acquire
+ *   (conn) => queryDatabase(conn),       // use
+ *   (conn, exit) => conn.close()         // release (always runs)
+ * );
+ * ```
+ */
+declare function bracket<R, E, A, B>(acquire: Async<R, E, A>, use: (resource: A) => Async<R, E, B>, release: (resource: A, exit: Exit<E, B>) => Async<R, any, void>): Async<R, E, B>;
+/**
+ * Runs `effect` and then runs `finalizer` regardless of the outcome.
+ * The finalizer receives the exit value for inspection.
+ *
+ * ```ts
+ * const result = ensuring(
+ *   doWork(),
+ *   (exit) => logCompletion(exit)
+ * );
+ * ```
+ */
+declare function ensuring<R, E, A>(effect: Async<R, E, A>, finalizer: (exit: Exit<E, A>) => Async<R, any, void>): Async<R, E, A>;
+/**
+ * A Managed resource describes how to acquire and release a resource.
+ * It can be used multiple times — each `use` call acquires a fresh instance.
+ *
+ * ```ts
+ * const dbPool = managed(
+ *   createPool({ max: 10 }),
+ *   (pool) => pool.close()
+ * );
+ *
+ * // Use it:
+ * const result = useManaged(dbPool, (pool) => pool.query("SELECT 1"));
+ * ```
+ */
+type Managed<R, E, A> = {
+    readonly _tag: "Managed";
+    readonly acquire: Async<R, E, A>;
+    readonly release: (resource: A, exit: Exit<any, any>) => Async<R, any, void>;
+};
+/**
+ * Creates a Managed resource descriptor.
+ */
+declare function managed<R, E, A>(acquire: Async<R, E, A>, release: (resource: A, exit?: Exit<any, any>) => Async<R, any, void>): Managed<R, E, A>;
+/**
+ * Uses a Managed resource: acquires, runs the body, and releases.
+ */
+declare function useManaged<R, E, A, B>(m: Managed<R, E, A>, body: (resource: A) => Async<R, E, B>): Async<R, E, B>;
+/**
+ * Combines multiple Managed resources. All are acquired in order,
+ * and released in reverse order (LIFO).
+ *
+ * ```ts
+ * const resources = managedAll([dbPool, cacheConn, fileHandle]);
+ * const result = useManaged(resources, ([db, cache, file]) => ...);
+ * ```
+ */
+declare function managedAll<R, E, Resources extends readonly any[]>(manageds: {
+    [K in keyof Resources]: Managed<R, E, Resources[K]>;
+}): Managed<R, E, Resources>;
+
+type Semaphore = {
+    /** Current number of available permits. */
+    readonly available: () => number;
+    /** Total number of permits (capacity). */
+    readonly capacity: number;
+    /** Number of effects waiting for a permit. */
+    readonly waiting: () => number;
+    /** Acquire a permit, run the effect, and release the permit. */
+    readonly withPermit: <R, E, A>(effect: Async<R, E, A>) => Async<R, E, A>;
+    /** Acquire a permit (manual). Must call release() when done. */
+    readonly acquire: () => Async<unknown, never, void>;
+    /** Release a permit (manual). */
+    readonly release: () => void;
+};
+type SemaphoreStats = {
+    readonly capacity: number;
+    readonly available: number;
+    readonly waiting: number;
+    readonly acquired: number;
+    readonly released: number;
+};
+/**
+ * Creates a counting semaphore with `n` permits.
+ *
+ * ```ts
+ * const sem = makeSemaphore(5); // max 5 concurrent
+ *
+ * // Automatic acquire/release:
+ * const result = await run(sem.withPermit(fetchData()));
+ *
+ * // Manual acquire/release:
+ * await run(sem.acquire());
+ * try { ... } finally { sem.release(); }
+ * ```
+ */
+declare function makeSemaphore(n: number): Semaphore;
+
+type Ref<A> = {
+    /** Get the current value. */
+    readonly get: () => Async<unknown, never, A>;
+    /** Set a new value. */
+    readonly set: (value: A) => Async<unknown, never, void>;
+    /** Modify the value with a function and return the new value. */
+    readonly update: (f: (current: A) => A) => Async<unknown, never, A>;
+    /** Modify the value and return a derived result. */
+    readonly modify: <B>(f: (current: A) => [B, A]) => Async<unknown, never, B>;
+    /** Get the current value synchronously (for non-effect contexts). */
+    readonly unsafeGet: () => A;
+};
+/**
+ * Creates a mutable reference with an initial value.
+ *
+ * ```ts
+ * const counter = makeRef(0);
+ *
+ * // In effects:
+ * await run(counter.update(n => n + 1));
+ * const value = await run(counter.get());
+ *
+ * // Synchronous access (outside effects):
+ * counter.unsafeGet();
+ * ```
+ */
+declare function makeRef<A>(initial: A): Ref<A>;
+/**
+ * Creates a derived Ref that applies a lens to a parent Ref.
+ *
+ * ```ts
+ * const state = makeRef({ count: 0, name: "test" });
+ * const countRef = derivedRef(state, s => s.count, (s, c) => ({ ...s, count: c }));
+ * ```
+ */
+declare function derivedRef<A, B>(parent: Ref<A>, get: (a: A) => B, set: (a: A, b: B) => A): Ref<B>;
+
+type ScheduleDecision = {
+    readonly continue: boolean;
+    readonly delayMs: number;
+};
+/**
+ * A Schedule<I, O> takes an input I (typically the error or output of an effect)
+ * and decides whether to continue and with what delay.
+ */
+type Schedule<I, O> = {
+    readonly _tag: "Schedule";
+    /** Initial state */
+    readonly initial: () => any;
+    /** Given current state and input, produce a decision and next state */
+    readonly step: (state: any, input: I) => [ScheduleDecision, any, O];
+};
+/** Retry/repeat up to N times with no delay. */
+declare function recurs(n: number): Schedule<unknown, number>;
+/** Fixed delay between each retry/repeat. */
+declare function fixed(delayMs: number): Schedule<unknown, number>;
+/** Exponential backoff: delay doubles each time, capped at maxDelayMs. */
+declare function exponential(baseMs: number, maxMs?: number): Schedule<unknown, number>;
+/** Exponential backoff with full jitter (random in [0, delay]). */
+declare function jittered(baseMs: number, maxMs?: number): Schedule<unknown, number>;
+/** Stop after a total elapsed time. */
+declare function elapsed(maxMs: number): Schedule<unknown, number>;
+/** Only continue while a predicate holds on the input. */
+declare function whileInput<I>(pred: (input: I) => boolean): Schedule<I, I>;
+/** Limit a schedule to N repetitions. */
+declare function take$1<I, O>(schedule: Schedule<I, O>, n: number): Schedule<I, O>;
+/** Compose two schedules: use the first, then switch to the second. */
+declare function andThen$1<I, O1, O2>(first: Schedule<I, O1>, second: Schedule<I, O2>): Schedule<I, O1 | O2>;
+/** Run both schedules and continue while BOTH say continue. Use max delay. */
+declare function intersect<I, O1, O2>(left: Schedule<I, O1>, right: Schedule<I, O2>): Schedule<I, [O1, O2]>;
+/** Run both schedules and continue while EITHER says continue. Use min delay. */
+declare function union<I, O1, O2>(left: Schedule<I, O1>, right: Schedule<I, O2>): Schedule<I, [O1, O2]>;
+/**
+ * Retry an effect according to a schedule.
+ * The schedule receives the error as input on each failure.
+ */
+declare function retryWithSchedule<R, E, A, O>(effect: Async<R, E, A>, schedule: Schedule<E, O>): Async<R, E, A>;
+/**
+ * Repeat an effect according to a schedule.
+ * The schedule receives the success value as input on each iteration.
+ * Returns the last successful value.
+ */
+declare function repeatWithSchedule<R, E, A, O>(effect: Async<R, E, A>, schedule: Schedule<A, O>): Async<R, E, A>;
+
+type ShutdownConfig = {
+    /** Max time to wait for in-flight work to complete. Default: 30000ms */
+    readonly timeoutMs?: number;
+    /** Called when shutdown starts. */
+    readonly onStart?: () => void;
+    /** Called when shutdown completes. */
+    readonly onComplete?: (stats: ShutdownStats) => void;
+    /** Called if shutdown times out. */
+    readonly onTimeout?: (stats: ShutdownStats) => void;
+};
+type ShutdownStats = {
+    readonly startedAt: number;
+    readonly completedAt: number;
+    readonly elapsedMs: number;
+    readonly timedOut: boolean;
+};
+/**
+ * Performs a graceful shutdown of the runtime.
+ *
+ * 1. Signals the scheduler to stop accepting new work
+ * 2. Waits for in-flight fibers to complete (up to timeoutMs)
+ * 3. Calls the runtime's shutdown hook
+ * 4. Reports stats
+ *
+ * ```ts
+ * await gracefulShutdown(runtime, {
+ *   timeoutMs: 5000,
+ *   onStart: () => console.log("Shutting down..."),
+ *   onComplete: (stats) => console.log(`Done in ${stats.elapsedMs}ms`),
+ * });
+ * ```
+ */
+declare function gracefulShutdown<R>(runtime: Runtime<R>, config?: ShutdownConfig): Promise<ShutdownStats>;
+/**
+ * Registers process signal handlers for graceful shutdown.
+ * Handles SIGTERM and SIGINT (Ctrl+C).
+ *
+ * ```ts
+ * registerShutdownHooks(runtime, {
+ *   timeoutMs: 10000,
+ *   onComplete: () => process.exit(0),
+ *   onTimeout: () => process.exit(1),
+ * });
+ * ```
+ */
+declare function registerShutdownHooks<R>(runtime: Runtime<R>, config?: ShutdownConfig): () => void;
+
+type TestRuntimeOptions = {
+    /** If true, effects run synchronously where possible. Default: true */
+    readonly synchronous?: boolean;
+};
+/**
+ * Creates a test runtime that provides controlled execution.
+ *
+ * ```ts
+ * const { runtime, run, runExit } = makeTestRuntime();
+ *
+ * const result = await run(myEffect);
+ * const exit = await runExit(myEffect); // get full Exit (success or failure)
+ * ```
+ */
+declare function makeTestRuntime<R = {}>(env?: R, options?: TestRuntimeOptions): {
+    runtime: Runtime<R>;
+    run: <E, A>(effect: Async<R, E, A>) => Promise<A>;
+    runExit: <E, A>(effect: Async<R, E, A>) => Promise<Exit<E, A>>;
+};
+/**
+ * Asserts that an effect succeeds with a specific value.
+ *
+ * ```ts
+ * await assertSucceeds(myEffect, 42);
+ * ```
+ */
+declare function assertSucceeds<R, E, A>(effect: Async<R, E, A>, expected: A, runtime?: Runtime<R>): Promise<void>;
+/**
+ * Asserts that an effect fails with a specific error.
+ *
+ * ```ts
+ * await assertFails(myEffect, "not found");
+ * ```
+ */
+declare function assertFails<R, E, A>(effect: Async<R, E, A>, expectedError: E, runtime?: Runtime<R>): Promise<void>;
+/**
+ * Asserts that an effect fails with an error matching a predicate.
+ *
+ * ```ts
+ * await assertFailsWith(myEffect, (e) => e._tag === "NotFound");
+ * ```
+ */
+declare function assertFailsWith<R, E, A>(effect: Async<R, E, A>, predicate: (error: E) => boolean, runtime?: Runtime<R>): Promise<void>;
+/**
+ * Asserts that an effect completes within a time limit.
+ *
+ * ```ts
+ * await assertCompletesWithin(myEffect, 100); // must finish in 100ms
+ * ```
+ */
+declare function assertCompletesWithin<R, E, A>(effect: Async<R, E, A>, maxMs: number, runtime?: Runtime<R>): Promise<A>;
+/**
+ * Creates an effect that fails on the first N calls, then succeeds.
+ * Useful for testing retry logic.
+ *
+ * ```ts
+ * const flaky = flakyEffect(3, "success!", "temporary error");
+ * // Fails 3 times, then returns "success!"
+ * ```
+ */
+declare function flakyEffect<E, A>(failCount: number, successValue: A, errorValue: E): Async<unknown, E, A>;
+/**
+ * Creates an effect that takes a specific amount of time to complete.
+ * Useful for testing timeouts and concurrency.
+ *
+ * ```ts
+ * const slow = delayedEffect(100, "done"); // completes after 100ms
+ * ```
+ */
+declare function delayedEffect<A>(ms: number, value: A): Async<unknown, never, A>;
+/**
+ * Creates an effect that never completes (hangs forever).
+ * Useful for testing timeouts and interruption.
+ */
+declare function neverEffect<A = never>(): Async<unknown, never, A>;
+
+/**
+ * A Layer describes how to build a service.
+ *
+ * - RIn: dependencies required to build this service
+ * - E: possible failure during construction
+ * - ROut: the service produced
+ */
+type Layer<RIn, E, ROut> = {
+    readonly _tag: "Layer";
+    readonly build: (deps: RIn) => Async<unknown, E, {
+        service: ROut;
+        release: () => Async<unknown, never, void>;
+    }>;
+};
+/**
+ * Creates a Layer from an acquire/release pair.
+ *
+ * ```ts
+ * const DbLayer = layer(
+ *   () => createPool({ max: 10 }),
+ *   (pool) => pool.close()
+ * );
+ * ```
+ */
+declare function layer<ROut, E = never>(acquire: () => Async<unknown, E, ROut>, release?: (service: ROut) => Async<unknown, never, void>): Layer<unknown, E, ROut>;
+/**
+ * Creates a Layer that depends on another service.
+ *
+ * ```ts
+ * const RepoLayer = layerFrom<DbPool>()(
+ *   (pool) => createRepo(pool),
+ *   (repo) => repo.close()
+ * );
+ * ```
+ */
+declare function layerFrom<RIn>(): <ROut, E = never>(acquire: (deps: RIn) => Async<unknown, E, ROut>, release?: (service: ROut) => Async<unknown, never, void>) => Layer<RIn, E, ROut>;
+/**
+ * Creates a Layer from a pure value (no lifecycle).
+ *
+ * ```ts
+ * const ConfigLayer = layerSucceed({ port: 3000, host: "localhost" });
+ * ```
+ */
+declare function layerSucceed<ROut>(value: ROut): Layer<unknown, never, ROut>;
+/**
+ * Creates a Layer that always fails.
+ */
+declare function layerFail<E>(error: E): Layer<unknown, E, never>;
+/**
+ * Compose two layers: the output of `from` feeds into `to`.
+ *
+ * ```ts
+ * const AppLayer = compose(DbLayer, RepoLayer);
+ * // DbLayer produces DbPool → RepoLayer consumes DbPool → produces Repo
+ * ```
+ */
+declare function compose$1<R1, E1, Mid, E2, ROut>(from: Layer<R1, E1, Mid>, to: Layer<Mid, E2, ROut>): Layer<R1, E1 | E2, ROut>;
+/**
+ * Merge two independent layers into one that produces both services.
+ *
+ * ```ts
+ * const AppLayer = merge(DbLayer, CacheLayer);
+ * // Produces { db: DbPool, cache: CacheClient }
+ * ```
+ */
+declare function merge<R1, E1, A, R2, E2, B>(left: Layer<R1, E1, A>, right: Layer<R2, E2, B>): Layer<R1 & R2, E1 | E2, A & B>;
+/**
+ * Map the output of a layer.
+ */
+declare function mapLayer<RIn, E, A, B>(l: Layer<RIn, E, A>, f: (a: A) => B): Layer<RIn, E, B>;
+/**
+ * Builds a layer, runs an effect with the produced service, and releases.
+ *
+ * ```ts
+ * const result = await run(
+ *   provideLayer(AppLayer, (services) => services.db.query("SELECT 1"))
+ * );
+ * ```
+ */
+declare function provideLayer<RIn, E, ROut, E2, A>(l: Layer<RIn, E, ROut>, use: (service: ROut) => Async<unknown, E2, A>, deps?: RIn): Async<unknown, E | E2, A>;
+
+type WorkerPoolConfig = {
+    /** Number of worker threads. Default: number of CPUs - 1 */
+    readonly size?: number;
+    /** Max queued tasks. Tasks beyond this are rejected. Default: 1000 */
+    readonly maxQueue?: number;
+    /** Task timeout in ms. Default: 30000 */
+    readonly taskTimeoutMs?: number;
+};
+type WorkerPoolError = {
+    readonly _tag: "WorkerPoolFull";
+    readonly queued: number;
+} | {
+    readonly _tag: "WorkerTaskTimeout";
+    readonly ms: number;
+} | {
+    readonly _tag: "WorkerTaskError";
+    readonly message: string;
+} | {
+    readonly _tag: "WorkerPoolClosed";
+};
+type WorkerPool = {
+    /** Execute a function in a worker thread. */
+    readonly execute: <A>(fn: () => A) => Async<unknown, WorkerPoolError, A>;
+    /** Execute a serializable task (function source + args). */
+    readonly run: <A>(taskSource: string, args?: any[]) => Async<unknown, WorkerPoolError, A>;
+    /** Current pool stats. */
+    readonly stats: () => WorkerPoolStats;
+    /** Shutdown the pool (terminate all workers). */
+    readonly shutdown: () => Promise<void>;
+};
+type WorkerPoolStats = {
+    readonly size: number;
+    readonly busy: number;
+    readonly idle: number;
+    readonly queued: number;
+    readonly completed: number;
+    readonly failed: number;
+    readonly timedOut: number;
+};
+/**
+ * Creates a worker pool for CPU-intensive tasks.
+ *
+ * NOTE: This is a simplified implementation that uses setTimeout to simulate
+ * async execution. For real worker_threads support, the pool would need to
+ * spawn actual Worker instances. This provides the API contract and can be
+ * upgraded to real threads when needed.
+ *
+ * ```ts
+ * const pool = makeWorkerPool({ size: 4 });
+ *
+ * const result = await run(pool.execute(() => heavyComputation()));
+ *
+ * await pool.shutdown();
+ * ```
+ */
+declare function makeWorkerPool(config?: WorkerPoolConfig): WorkerPool;
+
+type MetricType = "counter" | "gauge" | "histogram";
+type MetricValue = {
+    readonly name: string;
+    readonly type: MetricType;
+    readonly value: number;
+    readonly labels: Record<string, string>;
+    readonly timestamp: number;
+};
+type HistogramBuckets = {
+    readonly boundaries: readonly number[];
+    counts: number[];
+    sum: number;
+    count: number;
+    min: number;
+    max: number;
+};
+type MetricsRegistry = {
+    /** Create or get a counter. */
+    readonly counter: (name: string, labels?: Record<string, string>) => Counter;
+    /** Create or get a gauge. */
+    readonly gauge: (name: string, labels?: Record<string, string>) => Gauge;
+    /** Create or get a histogram. */
+    readonly histogram: (name: string, boundaries?: number[], labels?: Record<string, string>) => Histogram;
+    /** Get all current metric values. */
+    readonly snapshot: () => MetricSnapshot;
+    /** Reset all metrics. */
+    readonly reset: () => void;
+};
+type Counter = {
+    readonly increment: (n?: number) => void;
+    readonly value: () => number;
+};
+type Gauge = {
+    readonly set: (value: number) => void;
+    readonly increment: (n?: number) => void;
+    readonly decrement: (n?: number) => void;
+    readonly value: () => number;
+};
+type Histogram = {
+    readonly observe: (value: number) => void;
+    readonly buckets: () => HistogramBuckets;
+    readonly percentile: (p: number) => number;
+};
+type MetricSnapshot = {
+    readonly counters: Array<{
+        name: string;
+        labels: Record<string, string>;
+        value: number;
+    }>;
+    readonly gauges: Array<{
+        name: string;
+        labels: Record<string, string>;
+        value: number;
+    }>;
+    readonly histograms: Array<{
+        name: string;
+        labels: Record<string, string>;
+        buckets: HistogramBuckets;
+    }>;
+};
+/**
+ * Creates a metrics registry.
+ *
+ * ```ts
+ * const metrics = makeMetrics();
+ *
+ * const requestCount = metrics.counter("http_requests_total", { method: "GET" });
+ * requestCount.increment();
+ *
+ * const latency = metrics.histogram("http_request_duration_ms");
+ * latency.observe(42.5);
+ *
+ * const activeConns = metrics.gauge("active_connections");
+ * activeConns.set(10);
+ *
+ * console.log(metrics.snapshot());
+ * ```
+ */
+declare function makeMetrics(): MetricsRegistry;
+
+/**
+ * Base type for tagged errors. All errors should extend this pattern:
+ *
+ * ```ts
+ * type NetworkError = { _tag: "NetworkError"; url: string; status: number };
+ * type TimeoutError = { _tag: "TimeoutError"; ms: number };
+ * type AppError = NetworkError | TimeoutError;
+ * ```
+ */
+type TaggedError = {
+    readonly _tag: string;
+};
+/**
+ * Catches a specific error by its `_tag` field and handles it.
+ * Other errors pass through unchanged.
+ *
+ * ```ts
+ * const result = catchTag(effect, "NetworkError", (e) => fallbackValue);
+ * // e is narrowed to NetworkError
+ * ```
+ */
+declare function catchTag<R, E extends TaggedError, A, Tag extends E["_tag"], B>(effect: Async<R, E, A>, tag: Tag, handler: (error: Extract<E, {
+    _tag: Tag;
+}>) => Async<R, Exclude<E, {
+    _tag: Tag;
+}>, A | B>): Async<R, Exclude<E, {
+    _tag: Tag;
+}>, A | B>;
+/**
+ * Catches multiple error tags with a single handler map.
+ *
+ * ```ts
+ * const result = catchTags(effect, {
+ *   NetworkError: (e) => asyncSucceed(defaultValue),
+ *   TimeoutError: (e) => retry(effect),
+ * });
+ * ```
+ */
+declare function catchTags<R, E extends TaggedError, A, Handlers extends Partial<{
+    [K in E["_tag"]]: (error: Extract<E, {
+        _tag: K;
+    }>) => Async<R, any, any>;
+}>>(effect: Async<R, E, A>, handlers: Handlers): Async<R, Exclude<E, {
+    _tag: keyof Handlers & string;
+}>, A>;
+/**
+ * Maps the error channel of an effect.
+ *
+ * ```ts
+ * const result = mapError(effect, (e) => ({ _tag: "Wrapped", cause: e }));
+ * ```
+ */
+declare function mapError<R, E, E2, A>(effect: Async<R, E, A>, f: (error: E) => E2): Async<R, E2, A>;
+/**
+ * Wraps any error with a tag, making it part of a discriminated union.
+ *
+ * ```ts
+ * const typed = tagError(fetchData(), "NetworkError", (e) => ({ url, cause: e }));
+ * // Error type becomes { _tag: "NetworkError"; url: string; cause: unknown }
+ * ```
+ */
+declare function tagError<R, E, A, Tag extends string, Fields extends Record<string, unknown>>(effect: Async<R, E, A>, tag: Tag, enrich?: (error: E) => Fields): Async<R, {
+    _tag: Tag;
+} & Fields, A>;
+/**
+ * If the effect fails, run the fallback instead.
+ *
+ * ```ts
+ * const result = orElse(primary(), () => fallback());
+ * ```
+ */
+declare function orElse<R, E, A, R2, E2, B>(effect: Async<R, E, A>, fallback: (error: E) => Async<R2, E2, B>): Async<R & R2, E2, A | B>;
 
 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 +686,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 +720,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 +796,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 +885,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 +913,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 +957,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 +998,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, type Counter, 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 Gauge, type Histogram, type HistogramBuckets, type Hub, type HubClosed, type HubStrategy, type InternalFiberStatus, JsFiberEngine, type Layer, type Managed as ManagedResource, type MetricSnapshot, type MetricType, type MetricValue, type MetricsRegistry, NONE_U32, NodeId, OpcodeNode, OpcodeProgram, OpcodeTagCode, Option, PURE_PIPELINE_TAG, type PurePipelineMetadata, type PurePipelineTag, type Queue, type QueueClosed, type QueueOptions, type ReadyQueueScheduleKind, type Ref, RefId, type RetryPolicy, type RetryState, RingBufferOptions, Runtime, RuntimeFiber, type Schedule, type ScheduleDecision, Scope, type Semaphore, type SemaphoreStats, type SerializedFusedPipeline, type SerializedStep, type ShutdownConfig, type ShutdownStats, type Strategy, type StreamChunkEngine, type StreamChunkOptions, type StreamChunkStats, type Subscription, type TaggedError, type TestRuntimeOptions, type TimeoutError, WasmBridge, WasmEngineRuntime, WasmFiberRegistryBridge, type WasmFiberRegistryStats, WasmPackFiberBridge, type WorkerPool, type WorkerPoolConfig, type WorkerPoolError, type WorkerPoolStats, type ZPipeline, ZStream, andThen, andThen$1 as andThenSchedule, applyFused, assertCompletesWithin, assertFails, assertFailsWith, assertSucceeds, bounded, bracket, broadcast, broadcastToHub, buffer, bufferP, catchTag, catchTags, chunks, chunksP, collectAllPar, compose, compose$1 as composeLayer, debounce, decodeEvent, decodeEventBatch, delayedEffect, derivedRef, deserializeFusedPipeline, dropP, drop as dropStream, elapsed, encodeOpcodeNodes, encodeOpcodeProgram, ensuring, exponential, filterMapP, filterP, fixed, flakyEffect, fromHub, fuse, getStats, gracefulShutdown, groupedP, identity, initState, interleave, intersect, isFusionEnabled, isFusionVerbose, jittered, layer, layerFail, layerFrom, layerSucceed, makeFiberReadyQueue, makeHub, makeMetrics, makeRef, makeSemaphore, makeStreamChunker, makeTestRuntime, makeWorkerPool, managed, managedAll, mapChunks, mapChunksEffect, mapChunksEffectP, mapEffectP, mapError as mapErrorTyped, mapLayer, mapP, merge as mergeLayer, neverEffect, orElse, provideLayer, race, raceWith, recurs, registerShutdownHooks, repeatWithSchedule, retry, retryN, retryWithBackoff, retryWithSchedule, runFusedArray, scan, serializeFusedPipeline, setFusionEnabled, setFusionVerbose, sleep, tagError, takeP, take$1 as takeSchedule, take as takeStream, tapEffectP, throttle, timeout, union, useManaged, via, whileInput, zipPar, zip as zipStream, zipWith };