brass-runtime 1.13.8 → 1.15.0

package/dist/{effect-ISvXPLgc.d.ts → effect-CMOQKX8y.d.ts}

@@ -25,6 +25,8 @@ type RuntimeCapabilities = {
     wasmRingBuffer: boolean;
     wasmScheduler: boolean;
     wasmFiberRegistry: boolean;
+    wasmFiberReadyQueue: boolean;
+    wasmBinaryAbi: boolean;
     wasmStreamChunks: boolean;
 };
 declare function runtimeCapabilities(): RuntimeCapabilities;
@@ -50,17 +52,17 @@ declare class RingBuffer<T> {
     private grow;
 }
 
-type EngineKind = "js" | "wasm";
+type EngineKind = "ts" | "wasm";
 type EngineStats<T> = {
     engine: EngineKind;
     data: T;
-    fallbackUsed: boolean;
+    fallbackUsed: false;
 };
-type EngineSelectionMode = "auto" | EngineKind;
+type EngineSelectionMode = EngineKind;
 type EngineSelection<T> = EngineStats<T> & {
     requested: EngineSelectionMode;
 };
-declare function engineStats<T>(engine: EngineKind, data: T, fallbackUsed?: boolean): EngineStats<T>;
+declare function engineStats<T>(engine: EngineKind, data: T): EngineStats<T>;
 declare function selectedEngineStats<T>(requested: EngineSelectionMode, engine: EngineKind, data: T): EngineSelection<T>;
 
 type RingBufferStatsData = {
@@ -74,7 +76,7 @@ type RingBufferStatsData = {
 type RingLike<T> = {
     readonly length: number;
     readonly capacity: number;
-    readonly engine: "js" | "wasm";
+    readonly engine: "ts" | "wasm";
     readonly fallbackUsed: boolean;
     isEmpty(): boolean;
     push(value: T): PushStatus;
@@ -82,14 +84,23 @@ type RingLike<T> = {
     clear(): void;
     stats(): EngineStats<RingBufferStatsData>;
 };
-type RingBufferEngine = "auto" | "js" | "wasm";
+type RingBufferEngine = "ts" | "wasm";
 type RingBufferOptions = {
     engine?: RingBufferEngine;
 };
 declare function makeBoundedRingBuffer<T>(initialCapacity: number, maxCapacity?: number, options?: RingBufferOptions): RingLike<T>;
 
 type Task = () => void;
-type SchedulerEngine = "auto" | "js" | "wasm";
+type ScheduleResult = "accepted" | "dropped";
+type SchedulerEngine = "ts" | "wasm";
+type LaneStatsData = {
+    key: string;
+    len: number;
+    capacity: number;
+    enqueuedTasks: number;
+    executedTasks: number;
+    droppedTasks: number;
+};
 type SchedulerStatsData = {
     len: number;
     capacity?: number;
@@ -100,6 +111,7 @@ type SchedulerStatsData = {
     executedTasks?: number;
     droppedTasks?: number;
     yieldedByBudget?: number;
+    lanes?: LaneStatsData[];
 };
 type SchedulerStats = EngineStats<SchedulerStatsData>;
 type SchedulerOptions = RingBufferOptions & {
@@ -108,23 +120,48 @@ type SchedulerOptions = RingBufferOptions & {
     maxCapacity?: number;
     flushBudget?: number;
     microThreshold?: number;
-};
+    /** Capacity per inferred caller lane. Overflow drops the newly enqueued task in that lane. */
+    laneCapacity?: number;
+    /** Max tasks a single lane can run before rotating to the next lane. */
+    laneBudget?: number;
+    /** Safety cap for distinct lanes. New lanes past this limit go to `overflow`. */
+    maxLanes?: number;
+};
+declare function sanitizeLaneKey(value: string): string;
+declare function laneTag(lane: string, tag?: string): string;
+/**
+ * Infers a logical caller lane from the first non-Brass frame in the stack.
+ * This keeps Brass implementation-agnostic: the first task/fiber gets a stable
+ * key derived from the upper layer that invoked the runtime, and children inherit it.
+ */
+declare function inferCallerLaneFromStack(stack?: string | undefined, fallback?: string): string;
 declare class Scheduler {
     private readonly engine;
     private readonly js?;
     private readonly wasm?;
     private readonly flushBudget;
     private readonly microThreshold;
+    private readonly laneCapacity;
+    private readonly laneBudget;
+    private readonly maxLanes;
     private readonly fallbackUsed;
     private readonly boundFlush;
     constructor(options?: SchedulerOptions);
-    schedule(task: Task, tag?: string): void;
+    schedule(task: Task, tag?: string): ScheduleResult;
+    scheduleBatch(tasks: Array<{
+        fn: Task;
+        tag: string;
+    }>): ScheduleResult[];
     stats(): SchedulerStats;
     private scheduleWasm;
+    private scheduleBatchWasm;
+    private getOrCreateLane;
+    private createLane;
     private scheduleJs;
     private requestFlush;
     private flush;
     private flushWasm;
+    private shiftFromNextLane;
     private flushJs;
 }
 declare const globalScheduler: Scheduler;
@@ -338,15 +375,37 @@ type FlatMapRef<R = unknown> = (value: unknown) => Async<R, unknown, unknown>;
 type FoldFailureRef<R = unknown> = (error: unknown) => Async<R, unknown, unknown>;
 type FoldSuccessRef<R = unknown> = (value: unknown) => Async<R, unknown, unknown>;
 type DecodeRef = (result: HostActionResult) => unknown;
+type HostRegistryStats = {
+    readonly live: number;
+    readonly capacity: number;
+    readonly allocated: number;
+    readonly released: number;
+    readonly reused: number;
+    readonly staleReads: number;
+};
+/**
+ * Slab-backed registry for JS values referenced by the WASM VM.
+ *
+ * Refs are generational u32 handles: stale refs fail fast after a slot is
+ * released/reused. clear() releases all live slots, which is called when a
+ * fiber completes so callbacks, errors, decoders and intermediate values do not
+ * stay retained by the engine.
+ */
 declare class HostRegistry {
-    private nextRef;
-    private readonly refs;
+    private readonly slots;
+    private readonly free;
+    private live;
+    private allocated;
+    private released;
+    private reused;
+    private staleReads;
     register<T>(value: T): RefId;
     get<T>(ref: RefId): T;
     set(ref: RefId, value: unknown): void;
     delete(ref: RefId): void;
     clear(): void;
     size(): number;
+    stats(): HostRegistryStats;
 }
 type CompiledProgram = {
     readonly program: OpcodeProgram;
@@ -361,8 +420,8 @@ declare class ProgramBuilder {
     private visit;
 }
 
-type FiberEngineKind = "js" | "wasm" | "wasm-reference";
-type RuntimeEngineMode = FiberEngineKind | "auto";
+type FiberEngineKind = "ts" | "wasm";
+type RuntimeEngineMode = FiberEngineKind;
 type FiberEngineStats = {
     readonly engine: string;
     readonly startedFibers: number;
@@ -374,8 +433,11 @@ type FiberEngineStats = {
     readonly interruptedFibers: number;
     readonly pendingHostEffects: number;
     readonly hostRegistryRefs?: number;
+    readonly hostRegistryStats?: unknown;
     readonly wasm?: unknown;
     readonly fiberRegistry?: unknown;
+    readonly readyQueue?: unknown;
+    readonly timerWheel?: unknown;
 };
 interface FiberEngine<R = unknown> {
     readonly kind: FiberEngineKind;
@@ -389,7 +451,7 @@ type WasmEngineRuntime<R = unknown> = {
     readonly env: R;
     readonly hostExecutor: HostExecutor<R>;
     readonly scheduler: {
-        schedule(task: () => void, label?: string): void;
+        schedule(task: () => void, label?: string): unknown;
     };
     readonly hooks: {
         emit(ev: any, ctx: any): void;
@@ -446,13 +508,21 @@ type EngineEvent = {
     readonly decodeRef?: RefId;
 };
 interface WasmBridge {
-    readonly kind: "wasm" | "wasm-reference";
+    readonly kind: "wasm";
+    readonly supportsBinary?: boolean;
+    readonly supportsZeroCopy?: boolean;
+    readonly supportsNoJsonMetrics?: boolean;
     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;
 }
@@ -461,12 +531,12 @@ type Joiner<E, A> = (exit: Exit<E, A>) => void;
 type WasmFiberEngineOptions = {
     readonly bridge?: WasmBridge;
     readonly modulePath?: string;
-    readonly reference?: boolean;
 };
 declare class WasmFiberEngine<R> implements FiberEngine<R> {
     private readonly runtime;
     readonly kind: FiberEngineKind;
     private readonly bridge;
+    private readonly readyQueue;
     private startedFibers;
     private runningFibers;
     private suspendedFibers;
@@ -474,8 +544,12 @@ declare class WasmFiberEngine<R> implements FiberEngine<R> {
     private failedFibers;
     private interruptedFibers;
     private pendingHostEffects;
+    private readyDrainScheduled;
+    private readyDraining;
     private readonly states;
+    private readonly pendingResumes;
     private readonly fiberRegistry?;
+    private readonly timerWheel?;
     constructor(runtime: WasmEngineRuntime<R> & any, options?: WasmFiberEngineOptions);
     fork<E, A>(effect: Async<R, E, A>, scopeId?: number): Fiber<E, A> & {
         schedule?: (tag?: string) => void;
@@ -484,13 +558,21 @@ declare class WasmFiberEngine<R> implements FiberEngine<R> {
     shutdown(): Promise<void>;
     private scheduleWakeup;
     private drainWakeups;
+    private enqueueFiber;
+    private enqueueFiberById;
+    private requestReadyDrain;
+    private drainReadyQueue;
     private driveById;
+    private consumePendingResume;
     private drive;
     private scheduleAsync;
     private scheduleHostAction;
+    private onTimerExpired;
     private resumeWithExit;
     private resumeWithValue;
     private resumeWithError;
+    private schedulerTag;
+    private schedulerDropped;
     private interruptById;
     private interruptState;
     private markSuspended;
@@ -510,14 +592,19 @@ declare const NoopHooks: RuntimeHooks;
 type RuntimeOptions<R> = {
     env: R;
     scheduler?: Scheduler;
+    /** Logical caller/lane. When set, every fiber forked by this runtime is scheduled inside this lane. */
+    lane?: string;
+    /** Infer a caller lane from the top-level callsite when no explicit lane/parent lane exists. Defaults to true. */
+    inferLane?: boolean;
     hooks?: RuntimeHooks;
     /**
      * Selects the fiber interpreter used by fork().
      *
-     * - js: existing TypeScript RuntimeFiber interpreter.
+     * Strict mode only accepts:
+     * - ts: TypeScript RuntimeFiber interpreter.
      * - wasm: wasm-pack backed interpreter from wasm/pkg.
-     * - wasm-reference: JS reference bridge with the same host/engine protocol.
-     * - auto: try wasm first and fall back to js when the wasm package is not loadable.
+     *
+     * There is no auto mode and no TS fallback when wasm is requested.
      */
     engine?: RuntimeEngineMode;
     /** Executor used by HostAction opcodes when running on the WASM engine. */
@@ -537,6 +624,8 @@ declare class Runtime<R> {
     readonly forkPolicy: {
         initChild(fiber: RuntimeFiber<any, any, any> & any, parent?: (RuntimeFiber<any, any, any> & any) | null, scopeId?: number): void;
     };
+    readonly lane?: string;
+    readonly inferLane: boolean;
     registry?: RuntimeRegistry;
     constructor(args: RuntimeOptions<R>);
     private makeFiberEngine;
@@ -544,6 +633,12 @@ declare class Runtime<R> {
     hasActiveHooks(): boolean;
     /** Deriva un runtime con env extendido (estilo provide/locally) */
     provide<R2>(env: R2): Runtime<R & R2>;
+    /**
+     * Returns a derived runtime that schedules all work in a caller/lane.
+     * Brass does not need to know the caller implementation; it only sees this stable key.
+     */
+    withLane(lane: string): Runtime<R>;
+    private resolveFiberLane;
     emit(ev: RuntimeEvent): void;
     /**
      * ✅ CAMBIO: fork(effect, scopeId?) y pasa scopeId a forkPolicy
@@ -563,15 +658,65 @@ declare class Runtime<R> {
 }
 /** Create a runtime from `env` and fork the given effect. */
 declare function fork<R, E, A>(effect: Async<R, E, A>, env?: R): Fiber<E, A>;
+/** Create a runtime with a stable lane/caller key. */
+declare function runtimeForCaller<R>(caller: string, env?: R): Runtime<R>;
+/** Run an effect in a caller lane without exposing scheduler internals to the caller. */
+declare function toPromiseByCaller<R, E, A>(caller: string, effect: Async<R, E, A>, env?: R): Promise<A>;
 /** Run an effect with `env` and invoke `cb` with the final Exit. */
 declare function unsafeRunAsync<R, E, A>(effect: Async<R, E, A>, env: R | undefined, cb: (exit: Exit<E, A>) => void): void;
 /** Run an effect with `env` and return a Promise of its success value. */
 declare function toPromise<R, E, A>(effect: Async<R, E, A>, env?: R): Promise<A>;
+type AbortablePromiseOutcome = "success" | "failure" | "interrupt" | "timeout";
+type AbortablePromiseFinish = {
+    readonly label: string;
+    readonly outcome: AbortablePromiseOutcome;
+    readonly durationMs: number;
+    readonly error?: unknown;
+};
+type AbortablePromiseOptions = {
+    /** Logical label used by diagnostics. Keep it low-cardinality: e.g. `http:GET:https://api.foo.com`. */
+    readonly label?: string;
+    /** Fails the effect after this budget and aborts the underlying signal. Disabled when omitted or <= 0. */
+    readonly timeoutMs?: number;
+    /** Custom reason passed to `onReject` when the timeout fires. */
+    readonly timeoutReason?: () => unknown;
+    readonly onStart?: (label: string) => void;
+    readonly onFinish?: (finish: AbortablePromiseFinish) => void;
+};
+type AbortablePromiseLabelStats = {
+    readonly label: string;
+    readonly active: number;
+    readonly started: number;
+    readonly succeeded: number;
+    readonly failed: number;
+    readonly interrupted: number;
+    readonly timedOut: number;
+    readonly lateSettlements: number;
+};
+type AbortablePromiseStats = {
+    readonly active: number;
+    readonly started: number;
+    readonly succeeded: number;
+    readonly failed: number;
+    readonly interrupted: number;
+    readonly timedOut: number;
+    readonly lateSettlements: number;
+    readonly byLabel: AbortablePromiseLabelStats[];
+};
+declare function abortablePromiseStats(): AbortablePromiseStats;
+declare function resetAbortablePromiseStats(): void;
 /**
  * Create an Async from an abortable Promise.
+ *
+ * Improvements over the original helper:
+ * - optional timeout budget;
+ * - global active/late-settlement diagnostics;
+ * - explicit start/finish hooks for transport metrics;
+ * - cleanup on every completion path, so timers/listeners do not retain fibers.
+ *
  * Type params are ordered as `<E, A, R = unknown>` to match call-sites.
  */
-declare function fromPromiseAbortable<E, A, R = unknown>(make: (signal: AbortSignal, env: R) => Promise<A>, onReject: (u: unknown) => E): Async<R, E, A>;
+declare function fromPromiseAbortable<E, A, R = unknown>(make: (signal: AbortSignal, env: R) => Promise<A>, onReject: (u: unknown) => E, options?: AbortablePromiseOptions): Async<R, E, A>;
 declare function unsafeRunFoldWithEnv<R, E, A>(eff: Async<R, E, A>, env: R, onFailure: (cause: Cause<E>) => void, onSuccess: (value: A) => void): void;
 
 type JSONValue = null | boolean | number | string | JSONValue[] | {
@@ -622,6 +767,7 @@ declare class RuntimeFiber<R, E, A> implements Fiber<E, A> {
     fiberContext: FiberContext;
     name?: string;
     scopeId?: number;
+    lane?: string;
     /**
      * Cached closure for the scheduler callback — avoids creating a new
      * closure on every `schedule()` call.  The tag parameter used by the
@@ -629,11 +775,22 @@ declare class RuntimeFiber<R, E, A> implements Fiber<E, A> {
      * so a single cached closure is sufficient.
      */
     private readonly boundStep;
+    private _syncResolved;
+    private _syncExit;
+    private _asyncRegistered;
+    private _asyncDetach;
+    private readonly _asyncCb;
     constructor(runtime: Runtime<R>, effect: Async<R, E, A>);
     private get env();
     private get scheduler();
     private emit;
     addFinalizer(f: (exit: Exit<E, A>) => void): void;
+    /**
+     * Internal finalizers used for suspend cancelers. They are detached as soon
+     * as the async operation completes, so completed HTTP/promises do not keep
+     * canceler closures alive until the fiber itself finishes.
+     */
+    private addTransientFinalizer;
     status(): FiberStatus;
     join(cb: (exit: Exit<E, A>) => void): void;
     interrupt(): void;
@@ -644,6 +801,19 @@ declare class RuntimeFiber<R, E, A> implements Fiber<E, A> {
     private onFailure;
     private budget;
     private step;
+    /**
+     * Sync trampoline: processes FlatMap chains in a tight loop without the
+     * overhead of the general switch/case. Handles:
+     * - FlatMap(Async(sync), k) — the queue/stream hot path
+     * - FlatMap(Succeed(v), k) — pure value chains
+     * - FlatMap(Sync(f), k) — synchronous thunks
+     * - FlatMap(FlatMap(...), k) — left-associated chains (reassociates inline)
+     * - FlatMap(Fold(...), k) — pushes fold frame and continues
+     *
+     * Returns TRAMPOLINE.CONTINUE when it hits a node it can't handle,
+     * leaving this.current set to that node for the normal switch to process.
+     */
+    private syncTrampoline;
 }
 declare function getCurrentFiber(): RuntimeFiber<any, any, any> | null;
 /**
@@ -708,16 +878,16 @@ type Async<R, E, A> = {
     readonly register: (env: R, cb: (exit: Exit<E, A>) => void) => void | (() => void);
 } | {
     readonly _tag: "FlatMap";
-    readonly first: Async<R, E, any>;
-    readonly andThen: (a: any) => Async<R, E, A>;
+    readonly first: Async<any, any, any>;
+    readonly andThen: (a: any) => Async<any, any, A>;
 } | {
     readonly _tag: "Fold";
-    readonly first: Async<R, E, any>;
-    readonly onFailure: (e: any) => Async<R, E, A>;
-    readonly onSuccess: (a: any) => Async<R, E, A>;
+    readonly first: Async<any, any, any>;
+    readonly onFailure: (e: any) => Async<any, any, A>;
+    readonly onSuccess: (a: any) => Async<any, any, A>;
 } | {
     readonly _tag: "Fork";
-    readonly effect: Async<R, E, any>;
+    readonly effect: Async<any, any, any>;
     readonly scopeId?: number;
 };
 declare const Async: {
@@ -726,7 +896,7 @@ declare const Async: {
     sync: <R, E, A>(thunk: (env: R) => A) => Async<R, E, A>;
     async: <R, E, A>(register: (env: R, cb: (exit: Exit<E, A>) => void) => void | (() => void)) => Async<R, E, A>;
 };
-declare function asyncFold<R, E, A, B>(fa: Async<R, E, A>, onFailure: (e: E) => Async<R, E, B>, onSuccess: (a: A) => Async<R, E, B>): Async<R, E, B>;
+declare function asyncFold<R, E, A, RFail, EFail, B, RSuccess, ESuccess, C>(fa: Async<R, E, A>, onFailure: (e: E) => Async<RFail, EFail, B>, onSuccess: (a: A) => Async<RSuccess, ESuccess, C>): Async<R & RFail & RSuccess, EFail | ESuccess, B | C>;
 declare function asyncCatchAll<R, E, A, R2, E2, B>(fa: Async<R, E, A>, handler: (e: E) => Async<R2, E2, B>): Async<R & R2, E2, A | B>;
 declare function asyncMapError<R, E, E2, A>(fa: Async<R, E, A>, f: (e: E) => E2): Async<R, E2, A>;
 declare const unit: <R>() => Async<R, never, void>;
@@ -734,9 +904,10 @@ declare const asyncSucceed: <A>(value: A) => Async<unknown, never, A>;
 declare const asyncFail: <E>(error: E) => Async<unknown, E, never>;
 declare const asyncSync: <R, A>(thunk: (env: R) => A) => Async<R, unknown, A>;
 declare const asyncTotal: <A>(thunk: () => A) => Async<unknown, unknown, A>;
-declare const async: <R, E, A>(register: (env: R, cb: (exit: Exit<E, A>) => void) => void | Canceler) => Async<R, E, A>;
+declare const asyncEffect: <R, E, A>(register: (env: R, cb: (exit: Exit<E, A>) => void) => void | Canceler) => Async<R, E, A>;
+
 declare function asyncMap<R, E, A, B>(fa: Async<R, E, A>, f: (a: A) => B): Async<R, E, B>;
-declare function asyncFlatMap<R, E, A, B>(fa: Async<R, E, A>, f: (a: A) => Async<R, E, B>): Async<R, E, B>;
+declare function asyncFlatMap<R, E, A, R2, E2, B>(fa: Async<R, E, A>, f: (a: A) => Async<R2, E2, B>): Async<R & R2, E | E2, B>;
 declare function acquireRelease<R, E, A>(acquire: Async<R, E, A>, release: (res: A, exit: Exit<E, any>) => Async<R, any, any>, scope: Scope<R>): Async<R, E, A>;
 declare function asyncInterruptible<R, E, A>(register: (env: R, cb: (exit: Exit<E, A>) => void) => void | Canceler): Async<R, E, A>;
 type AsyncWithPromise<R, E, A> = Async<R, E, A> & {
@@ -789,9 +960,9 @@ declare const fail: <E>(error: E) => ZIO<unknown, E, never>;
 declare const sync: <R, A>(thunk: (env: R) => A) => ZIO<R, unknown, A>;
 declare const map: <R, E, A, B>(fa: ZIO<R, E, A>, f: (a: A) => B) => Async<R, E, B>;
 declare const flatMap: <R, E, A, R2, E2, B>(fa: ZIO<R, E, A>, f: (a: A) => ZIO<R2, E2, B>) => ZIO<R & R2, E | E2, B>;
-declare const mapError: <R, E, E2, A>(fa: ZIO<R, E, A>, f: (e: E) => E2) => any;
+declare const mapError: <R, E, E2, A>(fa: ZIO<R, E, A>, f: (e: E) => E2) => ZIO<R, E2, A>;
 declare const catchAll: <R, E, A, R2, E2, B>(fa: ZIO<R, E, A>, handler: (e: E) => ZIO<R2, E2, B>) => ZIO<R & R2, E2, A | B>;
 declare function orElseOptional<R, E, A, R2, A2>(fa: ZIO<R, Option<E>, A>, that: () => ZIO<R2, Option<E>, A2>): ZIO<R & R2, Option<E>, A | A2>;
 declare const end: <E>() => ZIO<unknown, Option<E>, never>;
 
-export { type QueueHostAction as $, Async as A, type FoldFailureRef as B, type CancelToken as C, type DbHostAction as D, Exit as E, type FiberEngine as F, type FoldSuccessRef as G, type HostAction as H, type HostActionKind as I, type HostActionResult as J, type HostExecutionContext as K, type HostExecutor as L, HostRegistry as M, type NodeId as N, type Option as O, type HttpHostAction as P, type Interrupted as Q, RuntimeFiber as R, Scope as S, type Joiner as T, type None as U, NoopHooks as V, type WasmEngineRuntime as W, ProgramBuilder as X, type ProgramPatch as Y, type ZIO as Z, PushStatus as _, type AsyncWithPromise as a, withScopeAsync as a$, RingBuffer as a0, type RingBufferEngine as a1, type RingBufferStatsData as a2, Runtime as a3, type RuntimeCapabilities as a4, type RuntimeEngineMode as a5, type RuntimeOptions as a6, Scheduler as a7, type SchedulerEngine as a8, type SchedulerOptions as a9, fromPromiseAbortable as aA, getBenchmarkBudget as aB, getCurrentFiber as aC, globalScheduler as aD, linkAbortController as aE, makeBoundedRingBuffer as aF, makeCancelToken as aG, map as aH, mapAsync as aI, mapError as aJ, mapTryAsync as aK, none as aL, orElseOptional as aM, runtimeCapabilities as aN, selectedEngineStats as aO, setBenchmarkBudget as aP, some as aQ, succeed as aR, sync as aS, toPromise as aT, unit as aU, unsafeGetCurrentRuntime as aV, unsafeRunAsync as aW, unsafeRunFoldWithEnv as aX, withAsyncPromise as aY, withCurrentFiber as aZ, withScope as a_, type SchedulerStats as aa, type SchedulerStatsData as ab, type ScopeId as ac, type Some as ad, type SyncRef as ae, type Task as af, WasmFiberEngine as ag, type WasmFiberEngineOptions as ah, acquireRelease as ai, async as aj, asyncCatchAll as ak, asyncFail as al, asyncFlatMap as am, asyncFold as an, asyncInterruptible as ao, asyncMap as ap, asyncMapError as aq, asyncSucceed as ar, asyncSync as as, asyncTotal as at, catchAll as au, end as av, engineStats as aw, fail as ax, flatMap as ay, fork as az, type FiberEngineStats as b, type Fiber as c, type FiberId as d, type FiberStatus as e, type RuntimeEvent as f, type WasmBridge as g, type OpcodeProgram as h, type FiberId$1 as i, type EngineEvent as j, type RefId as k, type OpcodeNode as l, type RingBufferOptions as m, type EngineStats as n, type AsyncRegisterRef as o, type RingLike as p, type Canceler as q, Cause as r, type CustomHostAction as s, type DecodeRef as t, DefaultHostExecutor as u, type EngineKind as v, type EngineSelection as w, type EngineSelectionMode as x, type FiberEngineKind as y, type FlatMapRef as z };
+export { type Joiner as $, Async as A, type EngineKind as B, type CancelToken as C, type DbHostAction as D, Exit as E, type FiberEngine as F, type EngineSelection as G, type EngineSelectionMode as H, type FiberEngineKind as I, type FlatMapRef as J, type FoldFailureRef as K, type FoldSuccessRef as L, type HostAction as M, type NodeId as N, type Option as O, type HostActionKind as P, type HostActionResult as Q, RuntimeFiber as R, Scope as S, type HostExecutionContext as T, type HostExecutor as U, HostRegistry as V, type WasmEngineRuntime as W, type HostRegistryStats as X, type HttpHostAction as Y, type ZIO as Z, type Interrupted as _, type FiberEngineStats as a, sanitizeLaneKey as a$, type LaneStatsData as a0, type None as a1, NoopHooks as a2, ProgramBuilder as a3, type ProgramPatch as a4, PushStatus as a5, type QueueHostAction as a6, RingBuffer as a7, type RingBufferEngine as a8, type RingBufferStatsData as a9, asyncSucceed as aA, asyncSync as aB, asyncTotal as aC, catchAll as aD, end as aE, engineStats as aF, fail as aG, flatMap as aH, fork as aI, fromPromiseAbortable as aJ, getBenchmarkBudget as aK, getCurrentFiber as aL, globalScheduler as aM, inferCallerLaneFromStack as aN, laneTag as aO, linkAbortController as aP, makeBoundedRingBuffer as aQ, makeCancelToken as aR, map as aS, mapAsync as aT, mapError as aU, mapTryAsync as aV, none as aW, orElseOptional as aX, resetAbortablePromiseStats as aY, runtimeCapabilities as aZ, runtimeForCaller as a_, Runtime as aa, type RuntimeCapabilities as ab, type RuntimeEngineMode as ac, type RuntimeOptions as ad, type ScheduleResult as ae, Scheduler as af, type SchedulerEngine as ag, type SchedulerOptions as ah, type SchedulerStats as ai, type SchedulerStatsData as aj, type ScopeId as ak, type Some as al, type SyncRef as am, type Task as an, WasmFiberEngine as ao, type WasmFiberEngineOptions as ap, abortablePromiseStats as aq, acquireRelease as ar, asyncEffect as as, asyncCatchAll as at, asyncFail as au, asyncFlatMap as av, asyncFold as aw, asyncInterruptible as ax, asyncMap as ay, asyncMapError as az, type Fiber as b, selectedEngineStats as b0, setBenchmarkBudget as b1, some as b2, succeed as b3, sync as b4, toPromise as b5, toPromiseByCaller as b6, unit as b7, unsafeGetCurrentRuntime as b8, unsafeRunAsync as b9, unsafeRunFoldWithEnv as ba, withAsyncPromise as bb, withCurrentFiber as bc, withScope as bd, withScopeAsync as be, type FiberId as c, type FiberStatus as d, type RuntimeEvent as e, type WasmBridge as f, type OpcodeProgram as g, type FiberId$1 as h, type EngineEvent as i, type RefId as j, type OpcodeNode as k, type RingBufferOptions as l, type EngineStats as m, type AbortablePromiseFinish as n, type AbortablePromiseLabelStats as o, type AbortablePromiseOptions as p, type AbortablePromiseOutcome as q, type AbortablePromiseStats as r, type AsyncRegisterRef as s, type AsyncWithPromise as t, type RingLike as u, type Canceler as v, Cause as w, type CustomHostAction as x, type DecodeRef as y, DefaultHostExecutor as z };