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;
    wasmFiberReadyQueue: boolean;
    wasmBinaryAbi: 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 = "ts" | "wasm";
type EngineStats<T> = {
    engine: EngineKind;
    data: T;
    fallbackUsed: false;
};
type EngineSelectionMode = EngineKind;
type EngineSelection<T> = EngineStats<T> & {
    requested: EngineSelectionMode;
};
declare function engineStats<T>(engine: EngineKind, data: T): 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: "ts" | "wasm";
    readonly fallbackUsed: boolean;
    isEmpty(): boolean;
    push(value: T): PushStatus;
    shift(): T | undefined;
    clear(): void;
    stats(): EngineStats<RingBufferStatsData>;
};
type RingBufferEngine = "ts" | "wasm";
type RingBufferOptions = {
    engine?: RingBufferEngine;
};
declare function makeBoundedRingBuffer<T>(initialCapacity: number, maxCapacity?: number, options?: RingBufferOptions): RingLike<T>;

type Task = () => void;
type ScheduleResult = "accepted" | "dropped";
type SchedulerLaneMode = "fair" | "single";
type SchedulerEngine = "ts" | "wasm";
type LaneStatsData = {
    key: string;
    len: number;
    capacity: number;
    enqueuedTasks: number;
    executedTasks: number;
    droppedTasks: number;
};
type SchedulerStatsData = {
    len: number;
    capacity?: number;
    phase?: string;
    scheduledFlushes?: number;
    completedFlushes?: number;
    enqueuedTasks?: number;
    executedTasks?: number;
    droppedTasks?: number;
    yieldedByBudget?: number;
    lanes?: LaneStatsData[];
};
type SchedulerStats = EngineStats<SchedulerStatsData>;
type SchedulerOptions = RingBufferOptions & {
    engine?: SchedulerEngine;
    /** fair keeps per-lane round-robin scheduling; single uses one direct TS queue for maximum throughput. */
    laneMode?: SchedulerLaneMode;
    initialCapacity?: number;
    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 jsSingle?;
    private readonly wasm?;
    private readonly flushBudget;
    private readonly microThreshold;
    private readonly laneCapacity;
    private readonly laneBudget;
    private readonly maxLanes;
    private readonly fallbackUsed;
    private readonly boundFlush;
    private shiftedTag;
    constructor(options?: SchedulerOptions);
    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 scheduleJsSingle;
    private scheduleBatchJsSingle;
    private scheduleJs;
    private requestFlush;
    private flush;
    private flushWasm;
    private flushJsSingle;
    private shiftFromNextLane;
    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: "supervisor.child.start";
    supervisorId: number;
    childId: number;
    name?: string;
    restartCount: number;
} | {
    type: "supervisor.child.end";
    supervisorId: number;
    childId: number;
    name?: string;
    status: "success" | "failure" | "interrupted";
    error?: unknown;
} | {
    type: "supervisor.child.restart";
    supervisorId: number;
    childId: number;
    name?: string;
    restartCount: number;
    delayMs: number;
    reason?: string;
} | {
    type: "supervisor.child.escalate";
    supervisorId: number;
    childId: number;
    name?: string;
    reason?: string;
    error?: unknown;
} | {
    type: "supervisor.shutdown";
    supervisorId: number;
} | {
    type: "schedule.decision";
    name?: string;
    attempt: number;
    elapsedMs: number;
    delayMs: number;
    continue: boolean;
    reason?: string;
    input?: unknown;
    output?: unknown;
} | {
    type: "log";
    level: "debug" | "info" | "warn" | "error";
    message: string;
    fields?: Record<string, unknown>;
} | {
    type: "span.start";
    name: string;
    attributes?: Record<string, unknown>;
    links?: RuntimeSpanLink[];
} | {
    type: "span.event";
    name: string;
    attributes?: Record<string, unknown>;
} | {
    type: "span.end";
    name?: string;
    status: "success" | "failure" | "interrupted";
    error?: unknown;
    attributes?: Record<string, unknown>;
};
type RuntimeEmitContext = {
    fiberId?: number;
    scopeId?: number;
    traceId?: string;
    spanId?: string;
    parentSpanId?: string;
    traceState?: string;
    baggage?: Record<string, string>;
    sampled?: boolean;
};
type RuntimeSpanLink = {
    traceId: string;
    spanId: string;
    traceState?: string;
    attributes?: Record<string, string | number | boolean>;
};
interface RuntimeHooks {
    emit(ev: RuntimeEvent, ctx: RuntimeEmitContext): void;
}
type RuntimeEventRecord = RuntimeEvent & RuntimeEmitContext & {
    seq: number;
    wallTs: number;
    ts: number;
    /**
     * The ambient fiber/scope from RuntimeEmitContext. Event payload fields
     * keep priority in the merged record, so these preserve the context when
     * an event also has a fiberId/scopeId of its own.
     */
    contextFiberId?: number;
    contextScopeId?: 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>;
};
declare function makeRuntimeEventRecord(ev: RuntimeEvent, ctx: RuntimeEmitContext, seq: number): RuntimeEventRecord;
declare function runtimeEventRecordContext(record: RuntimeEventRecord): RuntimeEmitContext;

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;
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 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;
    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 = "ts" | "wasm";
type RuntimeEngineMode = FiberEngineKind;
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 hostRegistryStats?: unknown;
    readonly wasm?: unknown;
    readonly fiberRegistry?: unknown;
    readonly readyQueue?: unknown;
    readonly timerWheel?: 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): unknown;
    };
    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";
    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;
}
type Joiner<E, A> = (exit: Exit<E, A>) => void;

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;

type WasmFiberEngineOptions = {
    readonly bridge?: WasmBridge;
    readonly modulePath?: string;
    readonly readyQueue?: Omit<FiberReadyQueueOptions, "engine">;
};
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;
    private completedFibers;
    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;
    };
    stats(): FiberEngineStats;
    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 completeCause;
    private resumeWithValue;
    private resumeWithError;
    private schedulerTag;
    private schedulerDropped;
    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;
    /** 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().
     *
     * Strict mode only accepts:
     * - ts: TypeScript RuntimeFiber interpreter.
     * - wasm: wasm-pack backed interpreter from wasm/pkg.
     *
     * 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. */
    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;
    };
    readonly lane?: string;
    readonly inferLane: boolean;
    registry?: RuntimeRegistry;
    constructor(args: RuntimeOptions<R>);
    private readonly staticFastPathOk;
    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>;
    /**
     * 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
     */
    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;
    private static exitToError;
    toPromise<E, A>(effect: Async<R, E, A>): Promise<A>;
    private tryRunNativeTopLevel;
    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>;
/** 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;
};
/**
 * Duck-typed timer wheel interface for use in AbortablePromiseOptions.
 * Avoids importing from `src/http/timerWheel.ts` to prevent circular dependencies.
 * Any object with a compatible `schedule` method can be used.
 */
interface AbortablePromiseTimerWheel {
    schedule(timeoutMs: number, cb: () => void): {
        cancel(): void;
    };
}
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;
    /** Optional timer wheel for efficient timeout scheduling. When provided, uses wheel.schedule() instead of setTimeout. */
    readonly timerWheel?: AbortablePromiseTimerWheel;
};
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[];
};
/**
 * Enable or disable per-label tracking for abortable promise diagnostics.
 * When disabled (default), only global integer counters are incremented on the hot path,
 * avoiding Map allocations entirely. Returns the previous enabled state.
 */
declare function setAbortablePromisePerLabelTracking(enabled: boolean): boolean;
declare const recordAbortablePromiseStart: (label: string) => void;
declare const recordAbortablePromiseFinish: (label: string, outcome: AbortablePromiseOutcome) => void;
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, 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[] | {
    [k: string]: JSONValue;
};
type ContextNode = {
    parent: ContextNode | null;
    patch: Record<string, JSONValue>;
};
declare const emptyContext: ContextNode;
declare function ctxExtend(parent: ContextNode, patch: Record<string, JSONValue>): ContextNode;
declare function ctxToObject(ctx: ContextNode): Record<string, JSONValue>;
type Baggage = Record<string, string>;
type TraceContext = {
    traceId: string;
    spanId: string;
    parentSpanId?: string;
    sampled?: boolean;
    traceState?: string;
    baggage?: Baggage;
};
type FiberContext = {
    log: ContextNode;
    trace: TraceContext | null;
    fiberRefs?: Map<number, unknown>;
};

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;
    private interruptibilityDepth;
    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
     * scheduler is only part of the label string, not the callback logic,
     * 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;
    schedule(tag?: string): void;
    private runFinalizersOnce;
    private notify;
    private isInterruptible;
    private shouldInterruptNow;
    private enterInterruptibility;
    private restoreInterruptibility;
    private fiberRefs;
    private restoreFiberRef;
    private onSuccess;
    private onFailure;
    private onCause;
    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;
/**
 * 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;
/**
 * Direct setter for the current fiber. Used by NativeTopLevelRunner to avoid
 * the closure allocation of withCurrentFiber when running tight loops.
 * Caller MUST restore the previous value via setCurrentFiber to maintain invariants.
 */
declare function setCurrentFiber(fiber: RuntimeFiber<any, any, any> | null): RuntimeFiber<any, any, any> | null;

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 InterruptibilityMode = "uninterruptible" | "interruptible";
type RestoreInterruptibility = <R, E, A>(effect: 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<any, any, any>;
    readonly andThen: (a: any) => Async<any, any, A>;
} | {
    readonly _tag: "Fold";
    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<any, any, any>;
    readonly scopeId?: number;
} | {
    readonly _tag: "Interruptibility";
    readonly mode: InterruptibilityMode;
    readonly effect: Async<any, any, A>;
} | {
    readonly _tag: "InterruptibilityMask";
    readonly body: (restore: RestoreInterruptibility) => Async<any, any, A>;
} | {
    readonly _tag: "InterruptibilityRestore";
    readonly depth: number;
    readonly effect: Async<any, any, A>;
} | {
    readonly _tag: "FiberRefLocally";
    readonly refId: number;
    readonly value: unknown;
    readonly effect: Async<any, any, A>;
};
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>;
    interruptibility: <R, E, A>(mode: InterruptibilityMode, effect: Async<R, E, A>) => Async<R, E, A>;
};
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>;
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 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, 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> & {
    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 CausePrettyOptions<E = unknown> = {
    readonly renderError?: (error: E) => string;
    readonly renderDefect?: (defect: unknown) => string;
    readonly indent?: string;
    readonly singleLine?: boolean;
};
type Cause<E> = {
    readonly _tag: "Fail";
    readonly error: E;
} | {
    readonly _tag: "Interrupt";
} | {
    readonly _tag: "Die";
    readonly defect: unknown;
} | {
    readonly _tag: "Then";
    readonly left: Cause<E>;
    readonly right: Cause<E>;
} | {
    readonly _tag: "Both";
    readonly left: Cause<E>;
    readonly right: Cause<E>;
};
declare const Cause: {
    fail: <E>(error: E) => Cause<E>;
    interrupt: <E = never>() => Cause<E>;
    die: <E = never>(defect: unknown) => Cause<E>;
    then: <E, E2>(left: Cause<E>, right: Cause<E2>) => Cause<E | E2>;
    both: <E, E2>(left: Cause<E>, right: Cause<E2>) => Cause<E | E2>;
    isCause: typeof isCauseValue;
    failures: typeof causeFailures;
    defects: typeof causeDefects;
    firstFailure: typeof firstCauseFailure;
    firstDefect: typeof firstCauseDefect;
    containsFailure: typeof causeContainsFailure;
    containsDefect: typeof causeContainsDefect;
    containsInterrupt: typeof causeContainsInterrupt;
    isInterruptedOnly: typeof causeIsInterruptedOnly;
    isFailureOnly: typeof causeIsFailureOnly;
    squash: typeof squashCause;
    toError: typeof causeToError;
    pretty: typeof prettyCause;
    format: typeof prettyCause;
};
declare function isCause(value: unknown): value is Cause<unknown>;
declare function prettyCause<E>(cause: Cause<E>, options?: CausePrettyOptions<E>): string;
declare const formatCause: typeof prettyCause;
declare function isCauseValue(value: unknown): value is Cause<unknown>;
declare function causeFailures<E>(cause: Cause<E>): readonly E[];
declare function causeDefects<E>(cause: Cause<E>): readonly unknown[];
declare function firstCauseFailure<E>(cause: Cause<E>): Option<E>;
declare function firstCauseDefect<E>(cause: Cause<E>): Option<unknown>;
declare function causeContainsFailure<E>(cause: Cause<E>): boolean;
declare function causeContainsDefect<E>(cause: Cause<E>): boolean;
declare function causeContainsInterrupt<E>(cause: Cause<E>): boolean;
declare function causeIsInterruptedOnly<E>(cause: Cause<E>): boolean;
declare function causeIsFailureOnly<E>(cause: Cause<E>): boolean;
declare function squashCause<E>(cause: Cause<E>): unknown;
declare function causeToError<E>(cause: Cause<E>): Error;
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) => 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 const uninterruptible: <R, E, A>(effect: ZIO<R, E, A>) => ZIO<R, E, A>;
declare const interruptible: <R, E, A>(effect: ZIO<R, E, A>) => ZIO<R, E, A>;
declare function uninterruptibleMask<R, E, A>(body: (restore: RestoreInterruptibility) => ZIO<R, E, A>): ZIO<R, E, A>;
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 FiberContext as $, Async as A, type Baggage as B, type AsyncRegisterRef as C, type AsyncWithPromise as D, Exit as E, type FiberEngine as F, type RingLike as G, type CancelToken as H, type Canceler as I, type JSONValue as J, Cause as K, type CausePrettyOptions as L, type ContextNode as M, type NodeId as N, type Option as O, type CustomHostAction as P, type DbHostAction as Q, type RuntimeHooks as R, Scope as S, type TraceContext as T, type DecodeRef as U, DefaultHostExecutor as V, type WasmEngineRuntime as W, type EngineKind as X, type EngineSelection as Y, type ZIO as Z, type EngineSelectionMode as _, type RuntimeOptions as a, ctxToObject as a$, type FiberEngineKind as a0, type FiberInfo as a1, type FiberReadyQueue as a2, type FiberReadyQueueOptions as a3, type FiberReadyQueueStats as a4, type FiberRunState as a5, type FlatMapRef as a6, type FoldFailureRef as a7, type FoldSuccessRef as a8, type HostAction as a9, type SchedulerEngine as aA, type SchedulerLaneMode as aB, type SchedulerOptions as aC, type SchedulerStats as aD, type SchedulerStatsData as aE, type ScopeId as aF, type ScopeInfo as aG, type Some as aH, type SyncRef as aI, type Task as aJ, WasmFiberEngine as aK, type WasmFiberEngineOptions as aL, abortablePromiseStats as aM, acquireRelease as aN, asyncEffect as aO, asyncCatchAll as aP, asyncFail as aQ, asyncFlatMap as aR, asyncFold as aS, asyncInterruptible as aT, asyncMap as aU, asyncMapError as aV, asyncSucceed as aW, asyncSync as aX, asyncTotal as aY, catchAll as aZ, ctxExtend as a_, type HostActionKind as aa, type HostActionResult as ab, type HostExecutionContext as ac, type HostExecutor as ad, HostRegistry as ae, type HostRegistryStats as af, type HttpHostAction as ag, type Interrupted as ah, type InterruptibilityMode as ai, type Joiner as aj, type LaneStatsData as ak, type None as al, NoopHooks as am, ProgramBuilder as an, type ProgramPatch as ao, PushStatus as ap, type QueueHostAction as aq, type ReadyQueueScheduleKind as ar, type RestoreInterruptibility as as, RingBuffer as at, type RingBufferEngine as au, type RingBufferStatsData as av, type RuntimeCapabilities as aw, type RuntimeEngineMode as ax, type ScheduleResult as ay, Scheduler as az, Runtime as b, emptyContext as b0, end as b1, engineStats as b2, fail as b3, flatMap as b4, fork as b5, formatCause as b6, fromPromiseAbortable as b7, getBenchmarkBudget as b8, getCurrentFiber as b9, setBenchmarkBudget as bA, setCurrentFiber as bB, some as bC, succeed as bD, sync as bE, toPromise as bF, toPromiseByCaller as bG, uninterruptible as bH, uninterruptibleMask as bI, unit as bJ, unsafeGetCurrentRuntime as bK, unsafeRunAsync as bL, unsafeRunFoldWithEnv as bM, withAsyncPromise as bN, withCurrentFiber as bO, withScope as bP, withScopeAsync as bQ, globalScheduler as ba, inferCallerLaneFromStack as bb, interruptible as bc, isCause as bd, laneTag as be, linkAbortController as bf, makeBoundedRingBuffer as bg, makeCancelToken as bh, makeFiberReadyQueue as bi, makeRuntimeEventRecord as bj, map as bk, mapAsync as bl, mapError as bm, mapTryAsync as bn, none as bo, orElseOptional as bp, prettyCause as bq, recordAbortablePromiseFinish as br, recordAbortablePromiseStart as bs, resetAbortablePromiseStats as bt, runtimeCapabilities as bu, runtimeEventRecordContext as bv, runtimeForCaller as bw, sanitizeLaneKey as bx, selectedEngineStats as by, setAbortablePromisePerLabelTracking as bz, type RingBufferOptions as c, type RuntimeEvent as d, type RuntimeEmitContext as e, type RuntimeEventRecord as f, type RuntimeSpanLink as g, RuntimeRegistry as h, RuntimeFiber as i, type FiberEngineStats as j, type Fiber as k, type FiberId as l, type FiberStatus as m, type WasmBridge as n, type OpcodeProgram as o, type FiberId$1 as p, type EngineEvent as q, type RefId as r, type OpcodeNode as s, type EngineStats as t, type AbortablePromiseFinish as u, type AbortablePromiseLabelStats as v, type AbortablePromiseOptions as w, type AbortablePromiseOutcome as x, type AbortablePromiseStats as y, type AbortablePromiseTimerWheel as z };