brass-runtime 1.14.0 → 1.15.0

package/dist/core/index.js

@@ -0,0 +1,216 @@
+import {
+  andThen,
+  assertCompletesWithin,
+  assertFails,
+  assertFailsWith,
+  assertSucceeds,
+  bracket,
+  catchTag,
+  catchTags,
+  compose,
+  delayedEffect,
+  derivedRef,
+  elapsed,
+  ensuring,
+  exponential,
+  fixed,
+  flakyEffect,
+  gracefulShutdown,
+  intersect,
+  jittered,
+  layer,
+  layerFail,
+  layerFrom,
+  layerSucceed,
+  linkAbortController,
+  makeCancelToken,
+  makeMetrics,
+  makeRef,
+  makeSemaphore,
+  makeTestRuntime,
+  makeTracer,
+  makeWorkerPool,
+  managed,
+  managedAll,
+  mapError as mapError2,
+  mapLayer,
+  merge,
+  neverEffect,
+  orElse,
+  provideLayer,
+  recurs,
+  registerShutdownHooks,
+  repeatWithSchedule,
+  retryWithSchedule,
+  tagError,
+  take,
+  union,
+  useManaged,
+  whileInput
+} from "../chunk-AR22SXML.js";
+import {
+  makeCircuitBreaker,
+  retry,
+  retryN,
+  retryWithBackoff,
+  sleep,
+  timeout
+} from "../chunk-BDYEENHT.js";
+import {
+  Async,
+  Cause,
+  Exit,
+  NoopHooks,
+  Runtime,
+  RuntimeFiber,
+  Scope,
+  abortablePromiseStats,
+  acquireRelease,
+  asyncCatchAll,
+  asyncEffect,
+  asyncFail,
+  asyncFlatMap,
+  asyncFold,
+  asyncInterruptible,
+  asyncMap,
+  asyncMapError,
+  asyncSucceed,
+  asyncSync,
+  asyncTotal,
+  catchAll,
+  end,
+  fail,
+  flatMap,
+  fork,
+  fromPromiseAbortable,
+  getBenchmarkBudget,
+  getCurrentFiber,
+  map,
+  mapAsync,
+  mapError,
+  mapTryAsync,
+  none,
+  orElseOptional,
+  resetAbortablePromiseStats,
+  runtimeForCaller,
+  setBenchmarkBudget,
+  some,
+  succeed,
+  sync,
+  toPromise,
+  toPromiseByCaller,
+  unit,
+  unsafeGetCurrentRuntime,
+  unsafeRunAsync,
+  unsafeRunFoldWithEnv,
+  withAsyncPromise,
+  withCurrentFiber,
+  withScope,
+  withScopeAsync
+} from "../chunk-BMH5AV44.js";
+export {
+  Async,
+  Cause,
+  Exit,
+  NoopHooks,
+  Runtime,
+  RuntimeFiber,
+  Scope,
+  abortablePromiseStats,
+  acquireRelease,
+  andThen as andThenSchedule,
+  assertCompletesWithin,
+  assertFails,
+  assertFailsWith,
+  assertSucceeds,
+  asyncEffect as async,
+  asyncCatchAll,
+  asyncFail,
+  asyncFlatMap,
+  asyncFold,
+  asyncInterruptible,
+  asyncMap,
+  asyncMapError,
+  asyncSucceed,
+  asyncSync,
+  asyncTotal,
+  bracket,
+  catchAll,
+  catchTag,
+  catchTags,
+  compose as composeLayer,
+  delayedEffect,
+  derivedRef,
+  elapsed,
+  end,
+  ensuring,
+  exponential,
+  fail,
+  fixed,
+  flakyEffect,
+  flatMap,
+  fork,
+  fromPromiseAbortable,
+  getBenchmarkBudget,
+  getCurrentFiber,
+  gracefulShutdown,
+  intersect,
+  jittered,
+  layer,
+  layerFail,
+  layerFrom,
+  layerSucceed,
+  linkAbortController,
+  makeCancelToken,
+  makeCircuitBreaker,
+  makeMetrics,
+  makeRef,
+  makeSemaphore,
+  makeTestRuntime,
+  makeTracer,
+  makeWorkerPool,
+  managed,
+  managedAll,
+  map,
+  mapAsync,
+  mapError,
+  mapError2 as mapErrorTyped,
+  mapLayer,
+  mapTryAsync,
+  merge as mergeLayer,
+  neverEffect,
+  none,
+  orElse,
+  orElseOptional,
+  provideLayer,
+  recurs,
+  registerShutdownHooks,
+  repeatWithSchedule,
+  resetAbortablePromiseStats,
+  retry,
+  retryN,
+  retryWithBackoff,
+  retryWithSchedule,
+  runtimeForCaller,
+  setBenchmarkBudget,
+  sleep,
+  some,
+  succeed,
+  sync,
+  tagError,
+  take as takeSchedule,
+  timeout,
+  toPromise,
+  toPromiseByCaller,
+  union,
+  unit,
+  unsafeGetCurrentRuntime,
+  unsafeRunAsync,
+  unsafeRunFoldWithEnv,
+  useManaged,
+  whileInput,
+  withAsyncPromise,
+  withCurrentFiber,
+  withScope,
+  withScopeAsync
+};

package/dist/core/index.mjs

@@ -0,0 +1,216 @@
+import {
+  andThen,
+  assertCompletesWithin,
+  assertFails,
+  assertFailsWith,
+  assertSucceeds,
+  bracket,
+  catchTag,
+  catchTags,
+  compose,
+  delayedEffect,
+  derivedRef,
+  elapsed,
+  ensuring,
+  exponential,
+  fixed,
+  flakyEffect,
+  gracefulShutdown,
+  intersect,
+  jittered,
+  layer,
+  layerFail,
+  layerFrom,
+  layerSucceed,
+  linkAbortController,
+  makeCancelToken,
+  makeMetrics,
+  makeRef,
+  makeSemaphore,
+  makeTestRuntime,
+  makeTracer,
+  makeWorkerPool,
+  managed,
+  managedAll,
+  mapError as mapError2,
+  mapLayer,
+  merge,
+  neverEffect,
+  orElse,
+  provideLayer,
+  recurs,
+  registerShutdownHooks,
+  repeatWithSchedule,
+  retryWithSchedule,
+  tagError,
+  take,
+  union,
+  useManaged,
+  whileInput
+} from "../chunk-JFPU5GQI.mjs";
+import {
+  makeCircuitBreaker,
+  retry,
+  retryN,
+  retryWithBackoff,
+  sleep,
+  timeout
+} from "../chunk-UMAZLXAB.mjs";
+import {
+  Async,
+  Cause,
+  Exit,
+  NoopHooks,
+  Runtime,
+  RuntimeFiber,
+  Scope,
+  abortablePromiseStats,
+  acquireRelease,
+  asyncCatchAll,
+  asyncEffect,
+  asyncFail,
+  asyncFlatMap,
+  asyncFold,
+  asyncInterruptible,
+  asyncMap,
+  asyncMapError,
+  asyncSucceed,
+  asyncSync,
+  asyncTotal,
+  catchAll,
+  end,
+  fail,
+  flatMap,
+  fork,
+  fromPromiseAbortable,
+  getBenchmarkBudget,
+  getCurrentFiber,
+  map,
+  mapAsync,
+  mapError,
+  mapTryAsync,
+  none,
+  orElseOptional,
+  resetAbortablePromiseStats,
+  runtimeForCaller,
+  setBenchmarkBudget,
+  some,
+  succeed,
+  sync,
+  toPromise,
+  toPromiseByCaller,
+  unit,
+  unsafeGetCurrentRuntime,
+  unsafeRunAsync,
+  unsafeRunFoldWithEnv,
+  withAsyncPromise,
+  withCurrentFiber,
+  withScope,
+  withScopeAsync
+} from "../chunk-BDF4AMWX.mjs";
+export {
+  Async,
+  Cause,
+  Exit,
+  NoopHooks,
+  Runtime,
+  RuntimeFiber,
+  Scope,
+  abortablePromiseStats,
+  acquireRelease,
+  andThen as andThenSchedule,
+  assertCompletesWithin,
+  assertFails,
+  assertFailsWith,
+  assertSucceeds,
+  asyncEffect as async,
+  asyncCatchAll,
+  asyncFail,
+  asyncFlatMap,
+  asyncFold,
+  asyncInterruptible,
+  asyncMap,
+  asyncMapError,
+  asyncSucceed,
+  asyncSync,
+  asyncTotal,
+  bracket,
+  catchAll,
+  catchTag,
+  catchTags,
+  compose as composeLayer,
+  delayedEffect,
+  derivedRef,
+  elapsed,
+  end,
+  ensuring,
+  exponential,
+  fail,
+  fixed,
+  flakyEffect,
+  flatMap,
+  fork,
+  fromPromiseAbortable,
+  getBenchmarkBudget,
+  getCurrentFiber,
+  gracefulShutdown,
+  intersect,
+  jittered,
+  layer,
+  layerFail,
+  layerFrom,
+  layerSucceed,
+  linkAbortController,
+  makeCancelToken,
+  makeCircuitBreaker,
+  makeMetrics,
+  makeRef,
+  makeSemaphore,
+  makeTestRuntime,
+  makeTracer,
+  makeWorkerPool,
+  managed,
+  managedAll,
+  map,
+  mapAsync,
+  mapError,
+  mapError2 as mapErrorTyped,
+  mapLayer,
+  mapTryAsync,
+  merge as mergeLayer,
+  neverEffect,
+  none,
+  orElse,
+  orElseOptional,
+  provideLayer,
+  recurs,
+  registerShutdownHooks,
+  repeatWithSchedule,
+  resetAbortablePromiseStats,
+  retry,
+  retryN,
+  retryWithBackoff,
+  retryWithSchedule,
+  runtimeForCaller,
+  setBenchmarkBudget,
+  sleep,
+  some,
+  succeed,
+  sync,
+  tagError,
+  take as takeSchedule,
+  timeout,
+  toPromise,
+  toPromiseByCaller,
+  union,
+  unit,
+  unsafeGetCurrentRuntime,
+  unsafeRunAsync,
+  unsafeRunFoldWithEnv,
+  useManaged,
+  whileInput,
+  withAsyncPromise,
+  withCurrentFiber,
+  withScope,
+  withScopeAsync
+};

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

@@ -878,16 +878,16 @@ type Async<R, E, A> = {
     readonly register: (env: R, cb: (exit: Exit<E, A>) => void) => void | (() => void);
 } | {
     readonly _tag: "FlatMap";
-    readonly first: Async<R, E, any>;
-    readonly andThen: (a: any) => Async<R, E, A>;
+    readonly first: Async<any, any, any>;
+    readonly andThen: (a: any) => Async<any, any, A>;
 } | {
     readonly _tag: "Fold";
-    readonly first: Async<R, E, any>;
-    readonly onFailure: (e: any) => Async<R, E, A>;
-    readonly onSuccess: (a: any) => Async<R, E, A>;
+    readonly first: Async<any, any, any>;
+    readonly onFailure: (e: any) => Async<any, any, A>;
+    readonly onSuccess: (a: any) => Async<any, any, A>;
 } | {
     readonly _tag: "Fork";
-    readonly effect: Async<R, E, any>;
+    readonly effect: Async<any, any, any>;
     readonly scopeId?: number;
 };
 declare const Async: {
@@ -896,7 +896,7 @@ declare const Async: {
     sync: <R, E, A>(thunk: (env: R) => A) => Async<R, E, A>;
     async: <R, E, A>(register: (env: R, cb: (exit: Exit<E, A>) => void) => void | (() => void)) => Async<R, E, A>;
 };
-declare function asyncFold<R, E, A, B>(fa: Async<R, E, A>, onFailure: (e: E) => Async<R, E, B>, onSuccess: (a: A) => Async<R, E, B>): Async<R, E, B>;
+declare function asyncFold<R, E, A, RFail, EFail, B, RSuccess, ESuccess, C>(fa: Async<R, E, A>, onFailure: (e: E) => Async<RFail, EFail, B>, onSuccess: (a: A) => Async<RSuccess, ESuccess, C>): Async<R & RFail & RSuccess, EFail | ESuccess, B | C>;
 declare function asyncCatchAll<R, E, A, R2, E2, B>(fa: Async<R, E, A>, handler: (e: E) => Async<R2, E2, B>): Async<R & R2, E2, A | B>;
 declare function asyncMapError<R, E, E2, A>(fa: Async<R, E, A>, f: (e: E) => E2): Async<R, E2, A>;
 declare const unit: <R>() => Async<R, never, void>;
@@ -904,9 +904,10 @@ declare const asyncSucceed: <A>(value: A) => Async<unknown, never, A>;
 declare const asyncFail: <E>(error: E) => Async<unknown, E, never>;
 declare const asyncSync: <R, A>(thunk: (env: R) => A) => Async<R, unknown, A>;
 declare const asyncTotal: <A>(thunk: () => A) => Async<unknown, unknown, A>;
-declare const async: <R, E, A>(register: (env: R, cb: (exit: Exit<E, A>) => void) => void | Canceler) => Async<R, E, A>;
+declare const asyncEffect: <R, E, A>(register: (env: R, cb: (exit: Exit<E, A>) => void) => void | Canceler) => Async<R, E, A>;
+
 declare function asyncMap<R, E, A, B>(fa: Async<R, E, A>, f: (a: A) => B): Async<R, E, B>;
-declare function asyncFlatMap<R, E, A, B>(fa: Async<R, E, A>, f: (a: A) => Async<R, E, B>): Async<R, E, B>;
+declare function asyncFlatMap<R, E, A, R2, E2, B>(fa: Async<R, E, A>, f: (a: A) => Async<R2, E2, B>): Async<R & R2, E | E2, B>;
 declare function acquireRelease<R, E, A>(acquire: Async<R, E, A>, release: (res: A, exit: Exit<E, any>) => Async<R, any, any>, scope: Scope<R>): Async<R, E, A>;
 declare function asyncInterruptible<R, E, A>(register: (env: R, cb: (exit: Exit<E, A>) => void) => void | Canceler): Async<R, E, A>;
 type AsyncWithPromise<R, E, A> = Async<R, E, A> & {
@@ -959,9 +960,9 @@ declare const fail: <E>(error: E) => ZIO<unknown, E, never>;
 declare const sync: <R, A>(thunk: (env: R) => A) => ZIO<R, unknown, A>;
 declare const map: <R, E, A, B>(fa: ZIO<R, E, A>, f: (a: A) => B) => Async<R, E, B>;
 declare const flatMap: <R, E, A, R2, E2, B>(fa: ZIO<R, E, A>, f: (a: A) => ZIO<R2, E2, B>) => ZIO<R & R2, E | E2, B>;
-declare const mapError: <R, E, E2, A>(fa: ZIO<R, E, A>, f: (e: E) => E2) => any;
+declare const mapError: <R, E, E2, A>(fa: ZIO<R, E, A>, f: (e: E) => E2) => ZIO<R, E2, A>;
 declare const catchAll: <R, E, A, R2, E2, B>(fa: ZIO<R, E, A>, handler: (e: E) => ZIO<R2, E2, B>) => ZIO<R & R2, E2, A | B>;
 declare function orElseOptional<R, E, A, R2, A2>(fa: ZIO<R, Option<E>, A>, that: () => ZIO<R2, Option<E>, A2>): ZIO<R & R2, Option<E>, A | A2>;
 declare const end: <E>() => ZIO<unknown, Option<E>, never>;
 
-export { type Interrupted as $, Async as A, DefaultHostExecutor as B, type CancelToken as C, type DbHostAction as D, Exit as E, type FiberEngine as F, type EngineKind as G, type EngineSelection as H, type EngineSelectionMode as I, type FiberEngineKind as J, type FlatMapRef as K, type FoldFailureRef as L, type FoldSuccessRef as M, type NodeId as N, type Option as O, type HostAction as P, type HostActionKind as Q, Runtime as R, Scope as S, type HostActionResult as T, type HostExecutionContext as U, type HostExecutor as V, type WasmEngineRuntime as W, HostRegistry as X, type HostRegistryStats as Y, type ZIO as Z, type HttpHostAction as _, type AsyncWithPromise as a, sanitizeLaneKey as a$, type Joiner as a0, type LaneStatsData as a1, type None as a2, NoopHooks as a3, ProgramBuilder as a4, type ProgramPatch as a5, PushStatus as a6, type QueueHostAction as a7, RingBuffer as a8, type RingBufferEngine as a9, asyncSucceed as aA, asyncSync as aB, asyncTotal as aC, catchAll as aD, end as aE, engineStats as aF, fail as aG, flatMap as aH, fork as aI, fromPromiseAbortable as aJ, getBenchmarkBudget as aK, getCurrentFiber as aL, globalScheduler as aM, inferCallerLaneFromStack as aN, laneTag as aO, linkAbortController as aP, makeBoundedRingBuffer as aQ, makeCancelToken as aR, map as aS, mapAsync as aT, mapError as aU, mapTryAsync as aV, none as aW, orElseOptional as aX, resetAbortablePromiseStats as aY, runtimeCapabilities as aZ, runtimeForCaller as a_, type RingBufferStatsData as aa, type RuntimeCapabilities as ab, type RuntimeEngineMode as ac, type RuntimeOptions as ad, type ScheduleResult as ae, Scheduler as af, type SchedulerEngine as ag, type SchedulerOptions as ah, type SchedulerStats as ai, type SchedulerStatsData as aj, type ScopeId as ak, type Some as al, type SyncRef as am, type Task as an, WasmFiberEngine as ao, type WasmFiberEngineOptions as ap, abortablePromiseStats as aq, acquireRelease as ar, async as as, asyncCatchAll as at, asyncFail as au, asyncFlatMap as av, asyncFold as aw, asyncInterruptible as ax, asyncMap as ay, asyncMapError as az, RuntimeFiber as b, selectedEngineStats as b0, setBenchmarkBudget as b1, some as b2, succeed as b3, sync as b4, toPromise as b5, toPromiseByCaller as b6, unit as b7, unsafeGetCurrentRuntime as b8, unsafeRunAsync as b9, unsafeRunFoldWithEnv as ba, withAsyncPromise as bb, withCurrentFiber as bc, withScope as bd, withScopeAsync as be, type FiberEngineStats as c, type Fiber as d, type FiberId as e, type FiberStatus as f, type RuntimeEvent as g, type WasmBridge as h, type OpcodeProgram as i, type FiberId$1 as j, type EngineEvent as k, type RefId as l, type OpcodeNode as m, type RingBufferOptions as n, type EngineStats as o, type AbortablePromiseFinish as p, type AbortablePromiseLabelStats as q, type AbortablePromiseOptions as r, type AbortablePromiseOutcome as s, type AbortablePromiseStats as t, type AsyncRegisterRef as u, type RingLike as v, type Canceler as w, Cause as x, type CustomHostAction as y, type DecodeRef as z };
+export { type Joiner as $, Async as A, type EngineKind as B, type CancelToken as C, type DbHostAction as D, Exit as E, type FiberEngine as F, type EngineSelection as G, type EngineSelectionMode as H, type FiberEngineKind as I, type FlatMapRef as J, type FoldFailureRef as K, type FoldSuccessRef as L, type HostAction as M, type NodeId as N, type Option as O, type HostActionKind as P, type HostActionResult as Q, RuntimeFiber as R, Scope as S, type HostExecutionContext as T, type HostExecutor as U, HostRegistry as V, type WasmEngineRuntime as W, type HostRegistryStats as X, type HttpHostAction as Y, type ZIO as Z, type Interrupted as _, type FiberEngineStats as a, sanitizeLaneKey as a$, type LaneStatsData as a0, type None as a1, NoopHooks as a2, ProgramBuilder as a3, type ProgramPatch as a4, PushStatus as a5, type QueueHostAction as a6, RingBuffer as a7, type RingBufferEngine as a8, type RingBufferStatsData as a9, asyncSucceed as aA, asyncSync as aB, asyncTotal as aC, catchAll as aD, end as aE, engineStats as aF, fail as aG, flatMap as aH, fork as aI, fromPromiseAbortable as aJ, getBenchmarkBudget as aK, getCurrentFiber as aL, globalScheduler as aM, inferCallerLaneFromStack as aN, laneTag as aO, linkAbortController as aP, makeBoundedRingBuffer as aQ, makeCancelToken as aR, map as aS, mapAsync as aT, mapError as aU, mapTryAsync as aV, none as aW, orElseOptional as aX, resetAbortablePromiseStats as aY, runtimeCapabilities as aZ, runtimeForCaller as a_, Runtime as aa, type RuntimeCapabilities as ab, type RuntimeEngineMode as ac, type RuntimeOptions as ad, type ScheduleResult as ae, Scheduler as af, type SchedulerEngine as ag, type SchedulerOptions as ah, type SchedulerStats as ai, type SchedulerStatsData as aj, type ScopeId as ak, type Some as al, type SyncRef as am, type Task as an, WasmFiberEngine as ao, type WasmFiberEngineOptions as ap, abortablePromiseStats as aq, acquireRelease as ar, asyncEffect as as, asyncCatchAll as at, asyncFail as au, asyncFlatMap as av, asyncFold as aw, asyncInterruptible as ax, asyncMap as ay, asyncMapError as az, type Fiber as b, selectedEngineStats as b0, setBenchmarkBudget as b1, some as b2, succeed as b3, sync as b4, toPromise as b5, toPromiseByCaller as b6, unit as b7, unsafeGetCurrentRuntime as b8, unsafeRunAsync as b9, unsafeRunFoldWithEnv as ba, withAsyncPromise as bb, withCurrentFiber as bc, withScope as bd, withScopeAsync as be, type FiberId as c, type FiberStatus as d, type RuntimeEvent as e, type WasmBridge as f, type OpcodeProgram as g, type FiberId$1 as h, type EngineEvent as i, type RefId as j, type OpcodeNode as k, type RingBufferOptions as l, type EngineStats as m, type AbortablePromiseFinish as n, type AbortablePromiseLabelStats as o, type AbortablePromiseOptions as p, type AbortablePromiseOutcome as q, type AbortablePromiseStats as r, type AsyncRegisterRef as s, type AsyncWithPromise as t, type RingLike as u, type Canceler as v, Cause as w, type CustomHostAction as x, type DecodeRef as y, DefaultHostExecutor as z };