brass-runtime 1.16.0 → 1.16.1

package/dist/core/index.mjs

@@ -1,29 +1,45 @@
 import {
+  Layer,
+  LayerContext,
+  MissingLayerServiceError,
   RuntimeRegistry,
   Supervisor,
+  TestClock,
+  TestScheduler,
   assertCompletesWithin,
   assertFails,
   assertFailsWith,
   assertSucceeds,
+  buildLayer,
   catchTag,
   catchTags,
   compose,
   consoleJsonLogger,
   defaultTracer,
+  defineLayer,
+  defineService,
   delayedEffect,
   derivedRef,
   dumpAllFibers,
   flakyEffect,
+  formatLayerError,
+  getService,
   gracefulShutdown,
   joinSupervised,
   layer,
+  layerEffect,
   layerFail,
   layerFrom,
+  layerFromContext,
   layerSucceed,
+  layerValue,
   linkAbortController,
   makeCancelToken,
+  makeLayerScope,
   makeRef,
+  makeRuntime,
   makeSemaphore,
+  makeServiceTag,
   makeSupervisor,
   makeTestRuntime,
   makeTracer,
@@ -33,51 +49,96 @@ import {
   merge,
   neverEffect,
   orElse,
+  provide,
+  provideContext,
   provideLayer,
+  provideLayerContext,
   registerShutdownHooks,
+  runEffect,
+  runExit,
+  runPromise,
+  serviceTag,
   supervise,
   tagError
-} from "../chunk-CY33PGEX.mjs";
+} from "../chunk-KH4SYAOS.mjs";
 import {
   Resource,
-  andThen,
   bracket,
+  ensuring,
+  makeCircuitBreaker,
+  makeResource,
+  managed,
+  managedAll,
+  resource,
+  resourceAll,
+  resourceFromManaged,
+  resourceSucceed,
+  useManaged,
+  useResource
+} from "../chunk-KN32XNTH.mjs";
+import {
+  fiberRefSnapshot,
+  getFiberRef,
+  locallyFiberRef,
+  locallyFiberRefWith,
+  makeFiberRef,
+  makeRuntimeRecorder,
+  modifyFiberRef,
+  setFiberRef,
+  unsafeGetFiberRef,
+  unsafeSetFiberRef,
+  updateFiberRef
+} from "../chunk-EOC4UHBS.mjs";
+import {
+  Schedule,
+  andThen,
   contramap,
   elapsed,
-  ensuring,
   exponential,
   fibonacci,
   fixed,
+  forever,
   intersect,
   jitter,
   jittered,
   jitteredSchedule,
-  makeCircuitBreaker,
-  makeResource,
-  managed,
-  managedAll,
+  linear,
+  makeScheduleDriver,
   map as map2,
+  maxDelay,
+  maxElapsed,
+  named,
+  never,
+  once,
+  poll,
   recurs,
+  repeat,
   repeatWithSchedule,
-  resource,
-  resourceAll,
-  resourceFromManaged,
-  resourceSucceed,
+  retry,
+  retry2,
+  retryN,
+  retryWithBackoff,
   retryWithSchedule,
+  runSchedule,
+  scheduleDriver,
+  sleep,
+  spaced,
   take,
+  tapDecision,
+  timeout,
   union,
-  useManaged,
-  useResource,
+  untilInput,
+  untilOutput,
+  upTo,
   whileInput,
+  whileOutput,
   windowed
-} from "../chunk-GOV47PPB.mjs";
+} from "../chunk-2HQTDLHF.mjs";
 import {
-  retry,
-  retryN,
-  retryWithBackoff,
-  sleep,
-  timeout
-} from "../chunk-7V4KY4RL.mjs";
+  Scope,
+  withScope,
+  withScopeAsync
+} from "../chunk-A2OM6NEH.mjs";
 import {
   EventBus,
   InMemoryTracer,
@@ -85,12 +146,7 @@ import {
   makeRuntimeEventRecord,
   runtimeEventRecordContext,
   runtimeHooksToEventHandler
-} from "../chunk-VFIUZG7J.mjs";
-import {
-  Scope,
-  withScope,
-  withScopeAsync
-} from "../chunk-CCKHV5BT.mjs";
+} from "../chunk-EJ6BPYVR.mjs";
 import {
   NoopHooks,
   Runtime,
@@ -103,7 +159,9 @@ import {
   fromPromiseAbortable,
   getBenchmarkBudget,
   getCurrentFiber,
+  liveClock,
   resetAbortablePromiseStats,
+  runtimeClockFromEnv,
   runtimeForCaller,
   setBenchmarkBudget,
   toPromise,
@@ -112,7 +170,7 @@ import {
   unsafeRunAsync,
   unsafeRunFoldWithEnv,
   withCurrentFiber
-} from "../chunk-G6IQOE4P.mjs";
+} from "../chunk-GYM3LLGS.mjs";
 import {
   Async,
   Cause,
@@ -133,19 +191,25 @@ import {
   end,
   fail,
   flatMap,
+  formatCause,
+  interruptible,
+  isCause,
   map,
   mapAsync,
   mapError,
   mapTryAsync,
   none,
   orElseOptional,
+  prettyCause,
   some,
   succeed,
   sync,
+  uninterruptible,
+  uninterruptibleMask,
   unit,
   withAsyncPromise
-} from "../chunk-NOYZIMUJ.mjs";
-import "../chunk-U5KWK3PX.mjs";
+} from "../chunk-36I3M4UC.mjs";
+import "../chunk-DNFJLJMW.mjs";
 import "../chunk-Y6FXYEAI.mjs";
 export {
   Async,
@@ -153,13 +217,19 @@ export {
   EventBus,
   Exit,
   InMemoryTracer,
+  Layer,
+  LayerContext,
+  MissingLayerServiceError,
   NoopHooks,
   Resource,
   Runtime,
   RuntimeFiber,
   RuntimeRegistry,
+  Schedule,
   Scope,
   Supervisor,
+  TestClock,
+  TestScheduler,
   abortablePromiseStats,
   acquireRelease,
   andThen as andThenSchedule,
@@ -179,6 +249,7 @@ export {
   asyncSync,
   asyncTotal,
   bracket,
+  buildLayer,
   catchAll,
   catchTag,
   catchTags,
@@ -188,6 +259,8 @@ export {
   ctxExtend,
   ctxToObject,
   defaultTracer,
+  defineLayer,
+  defineService,
   delayedEffect,
   derivedRef,
   dumpAllFibers,
@@ -197,32 +270,53 @@ export {
   ensuring,
   exponential,
   fail,
+  fiberRefSnapshot,
   fibonacci,
   fixed,
   flakyEffect,
   flatMap,
+  forever,
   fork,
+  formatCause,
+  formatLayerError,
   fromPromiseAbortable,
   getBenchmarkBudget,
   getCurrentFiber,
+  getFiberRef,
+  getService,
   gracefulShutdown,
+  interruptible,
   intersect,
+  isCause,
   jitter,
   jittered,
   jitteredSchedule,
   joinSupervised,
   layer,
+  layerEffect,
   layerFail,
   layerFrom,
+  layerFromContext,
   layerSucceed,
+  layerValue,
+  linear,
   linkAbortController,
+  liveClock,
+  locallyFiberRef,
+  locallyFiberRefWith,
   makeCancelToken,
   makeCircuitBreaker,
+  makeFiberRef,
+  makeLayerScope,
   makeMetrics,
   makeRef,
   makeResource,
+  makeRuntime,
   makeRuntimeEventRecord,
+  makeRuntimeRecorder,
+  makeScheduleDriver,
   makeSemaphore,
+  makeServiceTag,
   makeSupervisor,
   makeTestRuntime,
   makeTracer,
@@ -236,15 +330,27 @@ export {
   mapLayer,
   map2 as mapSchedule,
   mapTryAsync,
+  maxDelay,
+  maxElapsed,
   merge as mergeLayer,
+  modifyFiberRef,
+  named as namedSchedule,
+  never,
   neverEffect,
   none,
+  once,
   orElse,
   orElseOptional,
+  poll as pollWithSchedule,
+  prettyCause,
+  provide,
+  provideContext,
   provideLayer,
+  provideLayerContext,
   recurs,
   registerShutdownHooks,
   repeatWithSchedule,
+  repeat as repeatWithScheduleAlias,
   resetAbortablePromiseStats,
   resource,
   resourceAll,
@@ -254,28 +360,48 @@ export {
   retryN,
   retryWithBackoff,
   retryWithSchedule,
+  retry2 as retryWithScheduleAlias,
+  runEffect,
+  runExit,
+  runPromise,
+  runSchedule,
+  runtimeClockFromEnv,
   runtimeEventRecordContext,
   runtimeForCaller,
   runtimeHooksToEventHandler,
+  scheduleDriver,
+  serviceTag,
   setBenchmarkBudget,
+  setFiberRef,
   sleep,
   some,
+  spaced,
   succeed,
   supervise,
   sync,
   tagError,
   take as takeSchedule,
+  tapDecision,
   timeout,
   toPromise,
   toPromiseByCaller,
+  uninterruptible,
+  uninterruptibleMask,
   union,
   unit,
   unsafeGetCurrentRuntime,
+  unsafeGetFiberRef,
   unsafeRunAsync,
   unsafeRunFoldWithEnv,
+  unsafeSetFiberRef,
+  untilInput,
+  untilOutput,
+  upTo,
+  updateFiberRef,
   useManaged,
   useResource,
   whileInput,
+  whileOutput,
   windowed,
   withAsyncPromise,
   withCurrentFiber,

package/dist/{effect-CGNl5Rqp.d.ts → effect-DIUHZ9IN.d.ts}

@@ -232,6 +232,16 @@ type RuntimeEvent = {
 } | {
     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";
@@ -669,6 +679,7 @@ declare class WasmFiberEngine<R> implements FiberEngine<R> {
     private scheduleHostAction;
     private onTimerExpired;
     private resumeWithExit;
+    private completeCause;
     private resumeWithValue;
     private resumeWithError;
     private schedulerTag;
@@ -749,6 +760,7 @@ declare class Runtime<R> {
     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>;
+    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>;
@@ -841,6 +853,7 @@ type TraceContext = {
 type FiberContext = {
     log: ContextNode;
     trace: TraceContext | null;
+    fiberRefs?: Map<number, unknown>;
 };
 
 type FiberId = number;
@@ -870,6 +883,7 @@ declare class RuntimeFiber<R, E, A> implements Fiber<E, A> {
     private readonly stack;
     private readonly fiberFinalizers;
     private finalizersDrained;
+    private interruptibilityDepth;
     fiberContext: FiberContext;
     name?: string;
     scopeId?: number;
@@ -903,8 +917,15 @@ declare class RuntimeFiber<R, E, A> implements Fiber<E, A> {
     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;
     /**
@@ -970,6 +991,8 @@ declare function withScopeAsync<R, E, A>(runtime: Runtime<R>, f: (scope: Scope<R
 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;
@@ -995,12 +1018,29 @@ type Async<R, E, 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>;
@@ -1035,6 +1075,12 @@ 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;
@@ -1043,12 +1089,51 @@ type Cause<E> = {
 } | {
     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;
@@ -1068,7 +1153,10 @@ declare const map: <R, E, A, B>(fa: ZIO<R, E, A>, f: (a: A) => B) => Async<R, E,
 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 FiberInfo as $, Async as A, type Baggage as B, type AsyncWithPromise as C, type RingLike as D, Exit as E, type FiberEngine as F, type CancelToken as G, type Canceler as H, Cause as I, type JSONValue as J, type ContextNode as K, type CustomHostAction as L, type DbHostAction as M, type NodeId as N, type Option as O, type DecodeRef as P, DefaultHostExecutor as Q, type RuntimeHooks as R, Scope as S, type TraceContext as T, type EngineKind as U, type EngineSelection as V, type WasmEngineRuntime as W, type EngineSelectionMode as X, type FiberContext as Y, type ZIO as Z, type FiberEngineKind as _, type RingBufferOptions as a, fail as a$, type FiberReadyQueue as a0, type FiberReadyQueueOptions as a1, type FiberReadyQueueStats as a2, type FiberRunState as a3, type FlatMapRef as a4, type FoldFailureRef as a5, type FoldSuccessRef as a6, type HostAction as a7, type HostActionKind as a8, type HostActionResult as a9, type SchedulerStatsData as aA, type ScopeId as aB, type ScopeInfo as aC, type Some as aD, type SyncRef as aE, type Task as aF, WasmFiberEngine as aG, type WasmFiberEngineOptions as aH, abortablePromiseStats as aI, acquireRelease as aJ, asyncEffect as aK, asyncCatchAll as aL, asyncFail as aM, asyncFlatMap as aN, asyncFold as aO, asyncInterruptible as aP, asyncMap as aQ, asyncMapError as aR, asyncSucceed as aS, asyncSync as aT, asyncTotal as aU, catchAll as aV, ctxExtend as aW, ctxToObject as aX, emptyContext as aY, end as aZ, engineStats as a_, type HostExecutionContext as aa, type HostExecutor as ab, HostRegistry as ac, type HostRegistryStats as ad, type HttpHostAction as ae, type Interrupted as af, type Joiner as ag, type LaneStatsData as ah, type None as ai, NoopHooks as aj, ProgramBuilder as ak, type ProgramPatch as al, PushStatus as am, type QueueHostAction as an, type ReadyQueueScheduleKind as ao, RingBuffer as ap, type RingBufferEngine as aq, type RingBufferStatsData as ar, type RuntimeCapabilities as as, type RuntimeEngineMode as at, type ScheduleResult as au, Scheduler as av, type SchedulerEngine as aw, type SchedulerLaneMode as ax, type SchedulerOptions as ay, type SchedulerStats as az, type RuntimeEvent as b, flatMap as b0, fork as b1, fromPromiseAbortable as b2, getBenchmarkBudget as b3, getCurrentFiber as b4, globalScheduler as b5, inferCallerLaneFromStack as b6, laneTag as b7, linkAbortController as b8, makeBoundedRingBuffer as b9, withCurrentFiber as bA, withScope as bB, withScopeAsync as bC, makeCancelToken as ba, makeFiberReadyQueue as bb, makeRuntimeEventRecord as bc, map as bd, mapAsync as be, mapError as bf, mapTryAsync as bg, none as bh, orElseOptional as bi, resetAbortablePromiseStats as bj, runtimeCapabilities as bk, runtimeEventRecordContext as bl, runtimeForCaller as bm, sanitizeLaneKey as bn, selectedEngineStats as bo, setBenchmarkBudget as bp, some as bq, succeed as br, sync as bs, toPromise as bt, toPromiseByCaller as bu, unit as bv, unsafeGetCurrentRuntime as bw, unsafeRunAsync as bx, unsafeRunFoldWithEnv as by, withAsyncPromise as bz, type RuntimeEmitContext as c, type RuntimeEventRecord as d, type RuntimeSpanLink as e, Runtime as f, RuntimeRegistry as g, type RuntimeOptions 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 AsyncRegisterRef as z };
+export { type FiberEngineKind as $, Async as A, type Baggage as B, type AsyncWithPromise as C, type RingLike as D, Exit as E, type FiberEngine as F, type CancelToken as G, type Canceler as H, Cause as I, type JSONValue as J, type CausePrettyOptions as K, type ContextNode as L, type CustomHostAction as M, type NodeId as N, type Option as O, type DbHostAction as P, type DecodeRef as Q, type RuntimeHooks as R, Scope as S, type TraceContext as T, DefaultHostExecutor as U, type EngineKind as V, type WasmEngineRuntime as W, type EngineSelection as X, type EngineSelectionMode as Y, type ZIO as Z, type FiberContext as _, type RuntimeEmitContext as a, emptyContext as a$, type FiberInfo as a0, type FiberReadyQueue as a1, type FiberReadyQueueOptions as a2, type FiberReadyQueueStats as a3, type FiberRunState as a4, type FlatMapRef as a5, type FoldFailureRef as a6, type FoldSuccessRef as a7, type HostAction as a8, type HostActionKind as a9, type SchedulerLaneMode as aA, type SchedulerOptions as aB, type SchedulerStats as aC, type SchedulerStatsData as aD, type ScopeId as aE, type ScopeInfo as aF, type Some as aG, type SyncRef as aH, type Task as aI, WasmFiberEngine as aJ, type WasmFiberEngineOptions as aK, abortablePromiseStats as aL, acquireRelease as aM, asyncEffect as aN, asyncCatchAll as aO, asyncFail as aP, asyncFlatMap as aQ, asyncFold as aR, asyncInterruptible as aS, asyncMap as aT, asyncMapError as aU, asyncSucceed as aV, asyncSync as aW, asyncTotal as aX, catchAll as aY, ctxExtend as aZ, ctxToObject as a_, type HostActionResult as aa, type HostExecutionContext as ab, type HostExecutor as ac, HostRegistry as ad, type HostRegistryStats as ae, type HttpHostAction as af, type Interrupted as ag, type InterruptibilityMode as ah, type Joiner as ai, type LaneStatsData as aj, type None as ak, NoopHooks as al, ProgramBuilder as am, type ProgramPatch as an, PushStatus as ao, type QueueHostAction as ap, type ReadyQueueScheduleKind as aq, type RestoreInterruptibility as ar, RingBuffer as as, type RingBufferEngine as at, type RingBufferStatsData as au, type RuntimeCapabilities as av, type RuntimeEngineMode as aw, type ScheduleResult as ax, Scheduler as ay, type SchedulerEngine as az, type RingBufferOptions as b, end as b0, engineStats as b1, fail as b2, flatMap as b3, fork as b4, formatCause as b5, fromPromiseAbortable as b6, getBenchmarkBudget as b7, getCurrentFiber as b8, globalScheduler as b9, toPromise as bA, toPromiseByCaller as bB, uninterruptible as bC, uninterruptibleMask as bD, unit as bE, unsafeGetCurrentRuntime as bF, unsafeRunAsync as bG, unsafeRunFoldWithEnv as bH, withAsyncPromise as bI, withCurrentFiber as bJ, withScope as bK, withScopeAsync as bL, inferCallerLaneFromStack as ba, interruptible as bb, isCause as bc, laneTag as bd, linkAbortController as be, makeBoundedRingBuffer as bf, makeCancelToken as bg, makeFiberReadyQueue as bh, makeRuntimeEventRecord as bi, map as bj, mapAsync as bk, mapError as bl, mapTryAsync as bm, none as bn, orElseOptional as bo, prettyCause as bp, resetAbortablePromiseStats as bq, runtimeCapabilities as br, runtimeEventRecordContext as bs, runtimeForCaller as bt, sanitizeLaneKey as bu, selectedEngineStats as bv, setBenchmarkBudget as bw, some as bx, succeed as by, sync as bz, type RuntimeEvent as c, type RuntimeEventRecord as d, type RuntimeSpanLink as e, Runtime as f, RuntimeRegistry as g, type RuntimeOptions 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 AsyncRegisterRef as z };

package/dist/effectRunner-CFLC32IK.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkL6VB5N7Qcjs = require('./chunk-L6VB5N7Q.cjs');
+require('./chunk-MVGUEJ5Z.cjs');
+require('./chunk-OBGZSXTJ.cjs');
+
+
+exports.registerHttpEffect = _chunkL6VB5N7Qcjs.registerHttpEffect;

package/dist/{effectRunner-A4CHJXJI.js → effectRunner-L4S7IPT3.js}

@@ -1,7 +1,7 @@
 import {
   registerHttpEffect
-} from "./chunk-H55LI6WY.js";
-import "./chunk-PNVFW245.js";
+} from "./chunk-TRM4JUZQ.js";
+import "./chunk-UB4B6OFY.js";
 import "./chunk-3RG5ZIWI.js";
 export {
   registerHttpEffect

package/dist/{effectRunner-OPUF6QRN.mjs → effectRunner-NNGG75QA.mjs}

@@ -1,7 +1,7 @@
 import {
   registerHttpEffect
-} from "./chunk-K2T3DV26.mjs";
-import "./chunk-NOYZIMUJ.mjs";
+} from "./chunk-MOO4L7F4.mjs";
+import "./chunk-36I3M4UC.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 export {
   registerHttpEffect