brass-runtime 1.12.1 → 1.13.2

package/dist/effect-ISvXPLgc.d.ts

@@ -0,0 +1,797 @@
+type Canceler = () => void;
+type CancelToken = {
+    /** true si ya fue cancelado */
+    readonly isCancelled: () => boolean;
+    /**
+     * Registra un callback que se ejecuta cuando se cancela.
+     * Si ya estaba cancelado, lo ejecuta inmediatamente.
+     * Devuelve un "unsubscribe" para desregistrar.
+     */
+    readonly onCancel: (f: Canceler) => Canceler;
+};
+/** Implementación simple de CancelToken */
+declare function makeCancelToken(): CancelToken & {
+    cancel: Canceler;
+};
+/**
+ * Helper: conecta un AbortController a un CancelToken.
+ * Devuelve una función para desenganchar (unsubscribe).
+ */
+declare function linkAbortController(token: CancelToken, ac: AbortController): Canceler;
+
+type RuntimeCapabilities = {
+    wasmAvailable: boolean;
+    wasmFiberEngine: boolean;
+    wasmRingBuffer: boolean;
+    wasmScheduler: boolean;
+    wasmFiberRegistry: boolean;
+    wasmStreamChunks: boolean;
+};
+declare function runtimeCapabilities(): RuntimeCapabilities;
+
+declare const enum PushStatus {
+    Ok = 0,
+    Grew = 1,
+    Dropped = 2
+}
+declare class RingBuffer<T> {
+    private buf;
+    private head;
+    private tail;
+    private size_;
+    private readonly maxCap;
+    constructor(initialCapacity?: number, maxCapacity?: number);
+    get length(): number;
+    get capacity(): number;
+    isEmpty(): boolean;
+    push(value: T): PushStatus;
+    shift(): T | undefined;
+    clear(): void;
+    private grow;
+}
+
+type EngineKind = "js" | "wasm";
+type EngineStats<T> = {
+    engine: EngineKind;
+    data: T;
+    fallbackUsed: boolean;
+};
+type EngineSelectionMode = "auto" | EngineKind;
+type EngineSelection<T> = EngineStats<T> & {
+    requested: EngineSelectionMode;
+};
+declare function engineStats<T>(engine: EngineKind, data: T, fallbackUsed?: boolean): EngineStats<T>;
+declare function selectedEngineStats<T>(requested: EngineSelectionMode, engine: EngineKind, data: T): EngineSelection<T>;
+
+type RingBufferStatsData = {
+    len: number;
+    capacity: number;
+    pushes: number;
+    shifts: number;
+    clears: number;
+    dropped: number;
+};
+type RingLike<T> = {
+    readonly length: number;
+    readonly capacity: number;
+    readonly engine: "js" | "wasm";
+    readonly fallbackUsed: boolean;
+    isEmpty(): boolean;
+    push(value: T): PushStatus;
+    shift(): T | undefined;
+    clear(): void;
+    stats(): EngineStats<RingBufferStatsData>;
+};
+type RingBufferEngine = "auto" | "js" | "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 SchedulerStatsData = {
+    len: number;
+    capacity?: number;
+    phase?: string;
+    scheduledFlushes?: number;
+    completedFlushes?: number;
+    enqueuedTasks?: number;
+    executedTasks?: number;
+    droppedTasks?: number;
+    yieldedByBudget?: number;
+};
+type SchedulerStats = EngineStats<SchedulerStatsData>;
+type SchedulerOptions = RingBufferOptions & {
+    engine?: SchedulerEngine;
+    initialCapacity?: number;
+    maxCapacity?: number;
+    flushBudget?: number;
+    microThreshold?: number;
+};
+declare class Scheduler {
+    private readonly engine;
+    private readonly js?;
+    private readonly wasm?;
+    private readonly flushBudget;
+    private readonly microThreshold;
+    private readonly fallbackUsed;
+    private readonly boundFlush;
+    constructor(options?: SchedulerOptions);
+    schedule(task: Task, tag?: string): void;
+    stats(): SchedulerStats;
+    private scheduleWasm;
+    private scheduleJs;
+    private requestFlush;
+    private flush;
+    private flushWasm;
+    private flushJs;
+}
+declare const globalScheduler: Scheduler;
+
+type RuntimeEvent = {
+    type: "fiber.start";
+    fiberId: number;
+    parentFiberId?: number;
+    scopeId?: number;
+    name?: string;
+} | {
+    type: "fiber.end";
+    fiberId: number;
+    status: "success" | "failure" | "interrupted";
+    error?: unknown;
+} | {
+    type: "fiber.suspend";
+    fiberId: number;
+    reason?: string;
+} | {
+    type: "fiber.resume";
+    fiberId: number;
+} | {
+    type: "scope.open";
+    scopeId: number;
+    parentScopeId?: number;
+} | {
+    type: "scope.close";
+    scopeId: number;
+    status: "success" | "failure" | "interrupted";
+    error?: unknown;
+} | {
+    type: "log";
+    level: "debug" | "info" | "warn" | "error";
+    message: string;
+    fields?: Record<string, unknown>;
+};
+type RuntimeEmitContext = {
+    fiberId?: number;
+    scopeId?: number;
+    traceId?: string;
+    spanId?: string;
+};
+interface RuntimeHooks {
+    emit(ev: RuntimeEvent, ctx: RuntimeEmitContext): void;
+}
+type RuntimeEventRecord = RuntimeEvent & RuntimeEmitContext & {
+    seq: number;
+    wallTs: number;
+    ts: number;
+    /**
+     * Convenience fields for generic event consumers. They are present for
+     * log events and absent for fiber/scope events, but keeping them optional
+     * lets subscribers inspect records without narrowing the RuntimeEvent
+     * union first.
+     */
+    level?: "debug" | "info" | "warn" | "error";
+    message?: string;
+    fields?: Record<string, unknown>;
+};
+
+type FiberRunState = "Queued" | "Running" | "Suspended" | "Done";
+type FiberInfo = {
+    fiberId: number;
+    parentFiberId?: number;
+    name?: string;
+    runState: FiberRunState;
+    status: "Running" | "Done" | "Interrupted";
+    createdAt: number;
+    lastActiveAt: number;
+    scopeId?: number;
+    traceId?: string;
+    spanId?: string;
+    awaiting?: {
+        reason: string;
+        detail?: string;
+    };
+    lastEnd?: {
+        status: string;
+        error?: string;
+    };
+};
+type ScopeInfo = {
+    scopeId: number;
+    parentScopeId?: number;
+    ownerFiberId?: number;
+    openAt: number;
+    closedAt?: number;
+    finalizers: Array<{
+        id: number;
+        label?: string;
+        status: "added" | "running" | "done";
+    }>;
+};
+declare class RuntimeRegistry implements RuntimeHooks {
+    fibers: Map<number, FiberInfo>;
+    scopes: Map<number, ScopeInfo>;
+    private seq;
+    private recent;
+    private recentCap;
+    emit(ev: RuntimeEvent, ctx: RuntimeEmitContext): void;
+    getRecentEvents(): RuntimeEventRecord[];
+}
+
+type HostActionKind = "http" | "db" | "queue" | "custom";
+type HttpHostAction = {
+    readonly kind: "http";
+    readonly actionId?: string;
+    readonly method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
+    readonly target: string;
+    readonly path?: string;
+    readonly headers?: Record<string, string>;
+    readonly body?: Uint8Array;
+    readonly timeoutMs?: number;
+    readonly responseLimitBytes?: number;
+    readonly idempotencyKey?: string;
+};
+type DbHostAction = {
+    readonly kind: "db";
+    readonly actionId?: string;
+    readonly operation: "get" | "put" | "query" | "delete";
+    readonly target: string;
+    readonly payload: Uint8Array;
+    readonly timeoutMs?: number;
+    readonly idempotencyKey?: string;
+};
+type QueueHostAction = {
+    readonly kind: "queue";
+    readonly actionId?: string;
+    readonly target: string;
+    readonly payload: Uint8Array;
+    readonly timeoutMs?: number;
+    readonly idempotencyKey?: string;
+};
+type CustomHostAction = {
+    readonly kind: "custom";
+    readonly actionId?: string;
+    readonly target: string;
+    readonly payload?: Uint8Array;
+    readonly timeoutMs?: number;
+    readonly idempotencyKey?: string;
+};
+type HostAction = HttpHostAction | DbHostAction | QueueHostAction | CustomHostAction;
+type HostActionResult<A = unknown> = {
+    readonly kind: "ok";
+    readonly actionId?: string;
+    readonly value: A;
+    readonly metadata?: Record<string, unknown>;
+} | {
+    readonly kind: "error";
+    readonly actionId?: string;
+    readonly error: unknown;
+    readonly metadata?: Record<string, unknown>;
+};
+type HostExecutionContext<R = unknown> = {
+    readonly fiberId: number;
+    readonly env: R;
+    readonly signal: AbortSignal;
+    readonly deadlineAt?: number;
+};
+interface HostExecutor<R = unknown> {
+    execute(action: HostAction, context: HostExecutionContext<R>): Promise<HostActionResult>;
+}
+declare const DefaultHostExecutor: HostExecutor<any>;
+
+type NodeId = number;
+type RefId = number;
+type FiberId$1 = number;
+type OpcodeNode = {
+    readonly tag: "Succeed";
+    readonly valueRef: RefId;
+} | {
+    readonly tag: "Fail";
+    readonly errorRef: RefId;
+} | {
+    readonly tag: "Sync";
+    readonly fnRef: RefId;
+} | {
+    readonly tag: "Async";
+    readonly registerRef: RefId;
+} | {
+    readonly tag: "FlatMap";
+    readonly first: NodeId;
+    readonly fnRef: RefId;
+} | {
+    readonly tag: "Fold";
+    readonly first: NodeId;
+    readonly onFailureRef: RefId;
+    readonly onSuccessRef: RefId;
+} | {
+    readonly tag: "Fork";
+    readonly effectRef: RefId;
+    readonly scopeId?: number;
+} | {
+    readonly tag: "HostAction";
+    readonly actionRef: RefId;
+    readonly decodeRef?: RefId;
+};
+type OpcodeProgram = {
+    readonly version: 1;
+    readonly root: NodeId;
+    readonly nodes: OpcodeNode[];
+};
+type ProgramPatch = {
+    readonly root: NodeId;
+    readonly nodes: OpcodeNode[];
+};
+type SyncRef<R = unknown> = (env: R) => unknown;
+type AsyncRegisterRef<R = unknown> = (env: R, cb: (exit: unknown) => void) => void | (() => void);
+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;
+declare class HostRegistry {
+    private nextRef;
+    private readonly refs;
+    register<T>(value: T): RefId;
+    get<T>(ref: RefId): T;
+    set(ref: RefId, value: unknown): void;
+    delete(ref: RefId): void;
+    clear(): void;
+    size(): number;
+}
+type CompiledProgram = {
+    readonly program: OpcodeProgram;
+    readonly registry: HostRegistry;
+};
+declare class ProgramBuilder {
+    private readonly nodes;
+    private readonly registry;
+    compile(effect: Async<unknown, unknown, unknown>): CompiledProgram;
+    append(effect: Async<unknown, unknown, unknown>): ProgramPatch;
+    private add;
+    private visit;
+}
+
+type FiberEngineKind = "js" | "wasm" | "wasm-reference";
+type RuntimeEngineMode = FiberEngineKind | "auto";
+type FiberEngineStats = {
+    readonly engine: string;
+    readonly startedFibers: number;
+    readonly runningFibers: number;
+    readonly suspendedFibers: number;
+    readonly queuedFibers: number;
+    readonly completedFibers: number;
+    readonly failedFibers: number;
+    readonly interruptedFibers: number;
+    readonly pendingHostEffects: number;
+    readonly hostRegistryRefs?: number;
+    readonly wasm?: unknown;
+    readonly fiberRegistry?: unknown;
+};
+interface FiberEngine<R = unknown> {
+    readonly kind: FiberEngineKind;
+    fork<E, A>(effect: Async<R, E, A>, scopeId?: number): Fiber<E, A> & {
+        schedule?: (tag?: string) => void;
+    };
+    stats(): FiberEngineStats;
+    shutdown?(): Promise<void> | void;
+}
+type WasmEngineRuntime<R = unknown> = {
+    readonly env: R;
+    readonly hostExecutor: HostExecutor<R>;
+    readonly scheduler: {
+        schedule(task: () => void, label?: string): void;
+    };
+    readonly hooks: {
+        emit(ev: any, ctx: any): void;
+    };
+    fork<E, A>(effect: Async<R, E, A>, scopeId?: number): Fiber<E, A>;
+};
+type EngineEvent = {
+    readonly kind: "Continue";
+    readonly fiberId: FiberId$1;
+} | {
+    readonly kind: "Done";
+    readonly fiberId: FiberId$1;
+    readonly valueRef: RefId;
+} | {
+    readonly kind: "Failed";
+    readonly fiberId: FiberId$1;
+    readonly errorRef: RefId;
+} | {
+    readonly kind: "Interrupted";
+    readonly fiberId: FiberId$1;
+    readonly reasonRef: RefId;
+} | {
+    readonly kind: "InvokeSync";
+    readonly fiberId: FiberId$1;
+    readonly fnRef: RefId;
+} | {
+    readonly kind: "InvokeAsync";
+    readonly fiberId: FiberId$1;
+    readonly registerRef: RefId;
+} | {
+    readonly kind: "InvokeFlatMap";
+    readonly fiberId: FiberId$1;
+    readonly fnRef: RefId;
+    readonly valueRef: RefId;
+} | {
+    readonly kind: "InvokeFoldFailure";
+    readonly fiberId: FiberId$1;
+    readonly fnRef: RefId;
+    readonly errorRef: RefId;
+} | {
+    readonly kind: "InvokeFoldSuccess";
+    readonly fiberId: FiberId$1;
+    readonly fnRef: RefId;
+    readonly valueRef: RefId;
+} | {
+    readonly kind: "InvokeFork";
+    readonly fiberId: FiberId$1;
+    readonly effectRef: RefId;
+    readonly scopeId?: number;
+} | {
+    readonly kind: "InvokeHostAction";
+    readonly fiberId: FiberId$1;
+    readonly actionRef: RefId;
+    readonly decodeRef?: RefId;
+};
+interface WasmBridge {
+    readonly kind: "wasm" | "wasm-reference";
+    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;
+}
+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 startedFibers;
+    private runningFibers;
+    private suspendedFibers;
+    private completedFibers;
+    private failedFibers;
+    private interruptedFibers;
+    private pendingHostEffects;
+    private readonly states;
+    private readonly fiberRegistry?;
+    constructor(runtime: WasmEngineRuntime<R> & any, options?: WasmFiberEngineOptions);
+    fork<E, A>(effect: Async<R, E, A>, scopeId?: number): Fiber<E, A> & {
+        schedule?: (tag?: string) => void;
+    };
+    stats(): FiberEngineStats;
+    shutdown(): Promise<void>;
+    private scheduleWakeup;
+    private drainWakeups;
+    private driveById;
+    private drive;
+    private scheduleAsync;
+    private scheduleHostAction;
+    private resumeWithExit;
+    private resumeWithValue;
+    private resumeWithError;
+    private interruptById;
+    private interruptState;
+    private markSuspended;
+    private markRunning;
+    private completeSuccess;
+    private completeFailure;
+    private completeDie;
+    private completeInterrupted;
+    private cleanupState;
+}
+
+declare const NoopHooks: RuntimeHooks;
+/**
+ * --- Runtime como objeto único (ZIO-style) ---
+ * Un valor que representa "cómo" se ejecutan los efectos: scheduler + environment + hooks.
+ */
+type RuntimeOptions<R> = {
+    env: R;
+    scheduler?: Scheduler;
+    hooks?: RuntimeHooks;
+    /**
+     * Selects the fiber interpreter used by fork().
+     *
+     * - js: existing 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.
+     */
+    engine?: RuntimeEngineMode;
+    /** Executor used by HostAction opcodes when running on the WASM engine. */
+    hostExecutor?: HostExecutor<R>;
+    /** Optional low-level WASM bridge options, mostly for tests and local experiments. */
+    wasm?: WasmFiberEngineOptions;
+};
+declare class Runtime<R> {
+    readonly env: R;
+    readonly scheduler: Scheduler;
+    readonly hooks: RuntimeHooks;
+    readonly hostExecutor: HostExecutor<R>;
+    readonly engineMode: RuntimeEngineMode;
+    readonly wasmOptions?: WasmFiberEngineOptions;
+    readonly fiberEngine: FiberEngine<R>;
+    readonly fallbackUsed: boolean;
+    readonly forkPolicy: {
+        initChild(fiber: RuntimeFiber<any, any, any> & any, parent?: (RuntimeFiber<any, any, any> & any) | null, scopeId?: number): void;
+    };
+    registry?: RuntimeRegistry;
+    constructor(args: RuntimeOptions<R>);
+    private makeFiberEngine;
+    /** Returns true when the runtime has real hooks (not the no-op singleton). */
+    hasActiveHooks(): boolean;
+    /** Deriva un runtime con env extendido (estilo provide/locally) */
+    provide<R2>(env: R2): Runtime<R & R2>;
+    emit(ev: RuntimeEvent): void;
+    /**
+     * ✅ CAMBIO: fork(effect, scopeId?) y pasa scopeId a forkPolicy
+     */
+    fork<E, A>(effect: Async<R, E, A>, scopeId?: number): Fiber<E, A>;
+    stats(): EngineStats<ReturnType<FiberEngine<R>["stats"]>>;
+    capabilities(): RuntimeCapabilities;
+    shutdown(): Promise<void> | void;
+    unsafeRunAsync<E, A>(effect: Async<R, E, A>, cb: (exit: Exit<E, A>) => void): void;
+    toPromise<E, A>(effect: Async<R, E, A>): Promise<A>;
+    unsafeRun<E, A>(effect: Async<R, E, A>): void;
+    delay<E, A>(ms: number, eff: Async<R, E, A>): Async<R, E, A>;
+    static make<R>(env: R, scheduler?: Scheduler): Runtime<R>;
+    static makeWithEngine<R>(env: R, engine: RuntimeEngineMode, options?: Omit<RuntimeOptions<R>, "env" | "engine">): Runtime<R>;
+    /** Convenience logger: emits a RuntimeEvent of type "log". */
+    log(level: "debug" | "info" | "warn" | "error", message: string, fields?: Record<string, unknown>): void;
+}
+/** 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>;
+/** 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>;
+/**
+ * Create an Async from an abortable Promise.
+ * 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 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[] | {
+    [k: string]: JSONValue;
+};
+type ContextNode = {
+    parent: ContextNode | null;
+    patch: Record<string, JSONValue>;
+};
+type TraceContext = {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    sampled?: boolean;
+};
+type FiberContext = {
+    log: ContextNode;
+    trace: TraceContext | null;
+};
+
+type FiberId = number;
+type FiberStatus = "Running" | "Done" | "Interrupted";
+type Interrupted = {
+    readonly _tag: "Interrupt";
+};
+type Fiber<E, A> = {
+    readonly id: FiberId;
+    readonly status: () => FiberStatus;
+    readonly join: (cb: (exit: Exit<E, A>) => void) => void;
+    readonly interrupt: () => void;
+    readonly addFinalizer: (f: (exit: Exit<E, A>) => void) => void;
+};
+declare function setBenchmarkBudget(budget: number | undefined): void;
+declare function getBenchmarkBudget(): number | undefined;
+declare class RuntimeFiber<R, E, A> implements Fiber<E, A> {
+    readonly id: FiberId;
+    readonly runtime: Runtime<R>;
+    private closing;
+    private finishing;
+    private runState;
+    private interrupted;
+    private result;
+    private readonly joiners;
+    private current;
+    private readonly stack;
+    private readonly fiberFinalizers;
+    private finalizersDrained;
+    fiberContext: FiberContext;
+    name?: string;
+    scopeId?: number;
+    /**
+     * Cached closure for the scheduler callback — avoids creating a new
+     * closure on every `schedule()` call.  The tag parameter used by the
+     * scheduler is only part of the label string, not the callback logic,
+     * so a single cached closure is sufficient.
+     */
+    private readonly boundStep;
+    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;
+    status(): FiberStatus;
+    join(cb: (exit: Exit<E, A>) => void): void;
+    interrupt(): void;
+    schedule(tag?: string): void;
+    private runFinalizersOnce;
+    private notify;
+    private onSuccess;
+    private onFailure;
+    private budget;
+    private step;
+}
+declare function getCurrentFiber(): RuntimeFiber<any, any, any> | null;
+/**
+ * Unsafe (but convenient) access to the runtime that is currently executing.
+ * Throws if called outside of a running fiber.
+ */
+declare function unsafeGetCurrentRuntime<R>(): Runtime<R>;
+declare function withCurrentFiber<T>(fiber: RuntimeFiber<any, any, any>, f: () => T): T;
+
+type ScopeId = number;
+type CloseOptions = {
+    awaitChildren?: boolean;
+};
+declare class Scope<R> {
+    private readonly runtime;
+    private readonly parentScopeId?;
+    readonly id: ScopeId;
+    private closed;
+    private readonly children;
+    private readonly subScopes;
+    private readonly finalizers;
+    constructor(runtime: Runtime<R>, parentScopeId?: ScopeId | undefined);
+    /** registra un finalizer (LIFO) */
+    addFinalizer(f: (exit: Exit<any, any>) => Async<R, any, any>): void;
+    /** crea un sub scope (mismo runtime) */
+    subScope(): Scope<R>;
+    /** ✅ fork en este scope */
+    fork<E, A>(eff: Async<R, E, A>): Fiber<E, A>;
+    /** close fire-and-forget (no bloquea) */
+    close(exit?: Exit<any, any>): void;
+    /** Emit the scope.close event if hooks are active. */
+    private emitCloseEvent;
+    /**
+     * Build an effect that executes finalizers in LIFO order.
+     *
+     * Optimization over the original: instead of wrapping every finalizer in
+     * `asyncFold(fin(exit), () => unit(), () => unit())` which creates 3 effect
+     * nodes per finalizer (Fold + 2 Succeed), we use a single Sync thunk per
+     * finalizer that catches errors inline.  When the finalizer returns a
+     * Succeed effect (like `unit()`), the Sync thunk completes without creating
+     * additional effect nodes.
+     */
+    private buildFinalizerEffect;
+    closeAsync(exit?: Exit<any, any>, opts?: CloseOptions): Async<R, any, void>;
+}
+declare function withScopeAsync<R, E, A>(runtime: Runtime<R>, f: (scope: Scope<R>) => Async<R, E, A>): Async<R, E, A>;
+
+declare function withScope<R>(runtime: Runtime<R>, f: (scope: Scope<R>) => void): Async<R, never, void>;
+declare function withScope<R, E, A>(runtime: Runtime<R>, f: (scope: Scope<R>) => Async<R, E, A>): Async<R, E, A>;
+
+type Async<R, E, A> = {
+    readonly _tag: "Succeed";
+    readonly value: A;
+} | {
+    readonly _tag: "Fail";
+    readonly error: E;
+} | {
+    readonly _tag: "Sync";
+    readonly thunk: (env: R) => A;
+} | {
+    readonly _tag: "Async";
+    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 _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 _tag: "Fork";
+    readonly effect: Async<R, E, any>;
+    readonly scopeId?: number;
+};
+declare const Async: {
+    succeed: <R, E, A>(value: A) => Async<R, E, A>;
+    fail: <R, E, A = never>(error: E) => Async<R, E, A>;
+    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 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>;
+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 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 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> & {
+    toPromise: (env: R) => Promise<A>;
+    unsafeRunPromise: () => Promise<A>;
+};
+declare const withAsyncPromise: <R, E, A>(run: (eff: Async<R, E, A>, env: R) => Promise<A>) => (eff: Async<R, E, A>) => AsyncWithPromise<R, E, A>;
+declare const mapAsync: <R, E, A, B>(fa: Async<R, E, A>, f: (a: A) => B) => Async<R, E, B>;
+declare const mapTryAsync: <R, E, A, B>(fa: Async<R, E, A>, f: (a: A) => B) => Async<R, E, B>;
+
+type None = {
+    readonly _tag: "None";
+};
+type Some<A> = {
+    readonly _tag: "Some";
+    readonly value: A;
+};
+type Option<A> = None | Some<A>;
+declare const none: Option<never>;
+declare const some: <A>(value: A) => Option<A>;
+
+type Cause<E> = {
+    readonly _tag: "Fail";
+    readonly error: E;
+} | {
+    readonly _tag: "Interrupt";
+} | {
+    readonly _tag: "Die";
+    readonly defect: unknown;
+};
+declare const Cause: {
+    fail: <E>(error: E) => Cause<E>;
+    interrupt: <E = never>() => Cause<E>;
+    die: <E = never>(defect: unknown) => Cause<E>;
+};
+type Exit<E, A> = {
+    _tag: "Success";
+    value: A;
+} | {
+    _tag: "Failure";
+    cause: Cause<E>;
+};
+declare const Exit: {
+    succeed: <E = never, A = never>(value: A) => Exit<E, A>;
+    failCause: <E = never, A = never>(cause: Cause<E>) => Exit<E, A>;
+};
+type ZIO<R, E, A> = Async<R, E, A>;
+declare const succeed: <A>(value: A) => ZIO<unknown, never, A>;
+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 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 };