functype 1.6.3 → 1.8.0

package/dist/{index-CCuIZ-ut.d.ts → index-CIS_THnu.d.ts}

@@ -1,6 +1,5 @@
 import { t as Brand } from "./Brand-bfnGXuum.js";
-import { d as Type, l as Pipe, o as Serializable, r as Typeable, t as Tuple, u as Foldable } from "./Tuple-8yRldBty.js";
-
+import { d as Type, l as Pipe, o as Serializable, r as Typeable, t as Tuple, u as Foldable } from "./Tuple-B8KM-H8Y.js";
 //#region src/conditional/Cond.d.ts
 /**
  * Conditional expression that enforces exhaustive returns without early returns.
@@ -2022,8 +2021,11 @@ type TaskResult<T> = Promise<TaskOutcome<T>>;
  * Cancellation is cooperative, meaning the task must check the token and respond to cancellation requests
  */
 type CancellationToken = {
-  /** Whether the token has been cancelled */readonly isCancelled: boolean; /** Signal that can be used with fetch and other abortable APIs */
-  readonly signal: AbortSignal; /** Register a callback to be called when cancellation occurs */
+  /** Whether the token has been cancelled */
+  readonly isCancelled: boolean;
+  /** Signal that can be used with fetch and other abortable APIs */
+  readonly signal: AbortSignal;
+  /** Register a callback to be called when cancellation occurs */
   onCancel(callback: () => void): void;
 };
 /**
@@ -2031,7 +2033,9 @@ type CancellationToken = {
  * The controller can be used to cancel operations that use the token
  */
 type CancellationTokenSource = {
-  /** The token to be passed to cancellable operations */readonly token: CancellationToken; /** Cancel all operations using this token */
+  /** The token to be passed to cancellable operations */
+  readonly token: CancellationToken;
+  /** Cancel all operations using this token */
   cancel(): void;
 };
 /**
@@ -2295,7 +2299,7 @@ declare const Decoder: {
     try: <A>(inner: Decoder$1<A>) => Decoder$1<Try<A>>;
     list: <A>(inner: Decoder$1<A>) => Decoder$1<List<A>>;
     map: <V>(inner: Decoder$1<V>) => Decoder$1<Map$1<string, V>>;
-    obj: <T extends Record<string, unknown>>(shape: { [K in keyof T]: Decoder$1<T[K]> }) => Decoder$1<T>;
+    obj: <T extends Record<string, unknown>>(shape: { [K in keyof T]: Decoder$1<T[K]>; }) => Decoder$1<T>;
   };
   string: Decoder$1<string>;
   number: Decoder$1<number>;
@@ -2317,7 +2321,7 @@ declare const Decoder: {
   list: <A>(inner: Decoder$1<A>) => Decoder$1<List<A>>;
   array: <A>(inner: Decoder$1<A>) => Decoder$1<A[]>;
   map: <V>(inner: Decoder$1<V>) => Decoder$1<Map$1<string, V>>;
-  object: <T extends Record<string, unknown>>(shape: { [K in keyof T]: Decoder$1<T[K]> }) => Decoder$1<T>;
+  object: <T extends Record<string, unknown>>(shape: { [K in keyof T]: Decoder$1<T[K]>; }) => Decoder$1<T>;
 };
 //#endregion
 //#region src/do/index.d.ts
@@ -2527,12 +2531,19 @@ type ErrorChainElement = {
  * Options for formatting error chains
  */
 type ErrorFormatterOptions = {
-  /** Include task names in the formatted output */includeTasks?: boolean; /** Include stack traces in the formatted output */
-  includeStackTrace?: boolean; /** Separator between error lines (default: newline) */
-  separator?: string; /** Include detailed error data in the output */
-  includeData?: boolean; /** Maximum number of stack frames to include if stack trace is enabled */
-  maxStackFrames?: number; /** Title to display at the start of the formatted error */
-  title?: string; /** Format the output with colors for console display */
+  /** Include task names in the formatted output */
+  includeTasks?: boolean;
+  /** Include stack traces in the formatted output */
+  includeStackTrace?: boolean;
+  /** Separator between error lines (default: newline) */
+  separator?: string;
+  /** Include detailed error data in the output */
+  includeData?: boolean;
+  /** Maximum number of stack frames to include if stack trace is enabled */
+  maxStackFrames?: number;
+  /** Title to display at the start of the formatted error */
+  title?: string;
+  /** Format the output with colors for console display */
   colors?: boolean;
 };
 /**
@@ -2777,7 +2788,7 @@ declare const Validation: (<T extends Type>(rule: ValidationRule) => Validator<T
    * }
    * const result = Validation.form(schema, { name: "John", email: "john@example.com", age: 25 })
    */
-  form: <T extends Record<string, Type>>(schema: { [K in keyof T]: Validator<T[K]> }, data: Record<string, unknown>) => FormValidation<T>;
+  form: <T extends Record<string, Type>>(schema: { [K in keyof T]: Validator<T[K]>; }, data: Record<string, unknown>) => FormValidation<T>;
 };
 //#endregion
 //#region src/io/Tag.d.ts
@@ -2976,12 +2987,33 @@ type HasService<C, S> = S extends ContextServices<C> ? true : false;
 /**
  * Possible outcome types for an Exit
  */
-type ExitTag = "Success" | "Failure" | "Interrupted";
+type ExitTag = "Success" | "Failure" | "Die" | "Interrupted";
 /**
  * Exit represents the outcome of running an IO effect.
  * - Success: The effect completed successfully with a value
- * - Failure: The effect failed with a typed error
+ * - Failure: The effect failed with a typed error — a value from the declared `E` channel
+ * - Die: The effect produced a *defect* — a value that is **not** an `E`
  * - Interrupted: The effect was cancelled/interrupted
+ *
+ * `Die` exists so the error channel stops lying. `IO.sync` and `IO.die` declare
+ * `E = never`, so nothing they put in the error channel can be an `E`: a throwing
+ * `IO.sync` thunk, a throwing `map`/`flatMap`/`mapError` callback, and `IO.die` all
+ * produce values the declared type says cannot exist. Before `Die` these collapsed
+ * into `Failure`, so a consumer that pattern-matched on `error._tag` got `undefined`
+ * with no runtime signal that anything was wrong.
+ *
+ * Defects remain **recoverable** — `recover` / `recoverWith` / `fold` / `mapError`
+ * treat `Die` exactly as they treat `Failure`. That is deliberate, and it is where
+ * functype parts company with ZIO: promoting defects to uncatchable would silently
+ * change what every existing `.recover()` catches. `Die` is an *observability* fix,
+ * not a control-flow one — it records what the outcome really was when nothing
+ * recovered it.
+ *
+ * Note the sync interpreter cannot distinguish the two. `runSync` returns
+ * `Either<E, A>`, which has no third branch to put a defect in, and the sync
+ * interpreter signals failure by throwing the raw value — so `Fail` and `Die` arrive
+ * identically. `Die` is observable through the async terminals (`runExit`) and
+ * through the `Exit` handed to a `bracketExit` release.
  */
 interface Exit<E extends Type, A extends Type> {
   readonly [Symbol.toStringTag]: string;
@@ -3000,6 +3032,13 @@ interface Exit<E extends Type, A extends Type> {
     readonly _tag: "Failure";
     error: E;
   };
+  /**
+   * Type guard to check if this is a Die (a defect — the carried value is not an `E`)
+   */
+  isDie(): this is Exit<E, A> & {
+    readonly _tag: "Die";
+    defect: unknown;
+  };
   /**
    * Type guard to check if this is Interrupted
    */
@@ -3024,16 +3063,25 @@ interface Exit<E extends Type, A extends Type> {
    */
   flatMap<B extends Type>(f: (a: A) => Exit<E, B>): Exit<E, B>;
   /**
-   * Pattern matches over the Exit
+   * Pattern matches over the Exit.
+   *
+   * `onDie` is optional and appended rather than inserted so existing three-argument
+   * calls keep compiling. Omitting it routes a defect to `onFailure` — the pre-`Die`
+   * behaviour, where defects were indistinguishable from typed failures. Supply it
+   * when the distinction matters; note the value it receives is `unknown`, not `E`.
    */
-  fold<T>(onFailure: (e: E) => T, onSuccess: (a: A) => T, onInterrupted?: (fiberId: string) => T): T;
+  fold<T>(onFailure: (e: E) => T, onSuccess: (a: A) => T, onInterrupted?: (fiberId: string) => T, onDie?: (defect: unknown) => T): T;
   /**
-   * Pattern matches over the Exit with object patterns
+   * Pattern matches over the Exit with object patterns.
+   *
+   * `Die` is optional for the same back-compat reason as {@link fold}'s `onDie`, and
+   * falls back to `Failure` when absent.
    */
   match<T>(patterns: {
     Success: (value: A) => T;
     Failure: (error: E) => T;
     Interrupted: (fiberId: string) => T;
+    Die?: (defect: unknown) => T;
   }): T;
   /**
    * Returns the success value or throws
@@ -3050,6 +3098,9 @@ interface Exit<E extends Type, A extends Type> {
   /**
    * Converts to Either (Right for Success, Left for Failure)
    * Throws if Interrupted
+   *
+   * A `Die` becomes `Left(defect)`, which widens the Left beyond `E` — the same
+   * lossiness `IO.run()` already has. Use {@link isDie} first if the distinction matters.
    */
   toEither(): Either<E, A>;
   /**
@@ -3059,6 +3110,7 @@ interface Exit<E extends Type, A extends Type> {
     _tag: ExitTag;
     value?: A;
     error?: E;
+    defect?: unknown;
     fiberId?: string;
   };
   /**
@@ -3072,6 +3124,7 @@ interface Exit<E extends Type, A extends Type> {
     _tag: ExitTag;
     value?: A;
     error?: E;
+    defect?: unknown;
     fiberId?: string;
   };
 }
@@ -3100,6 +3153,10 @@ declare const Exit: (<E extends Type, A extends Type>(value: A) => Exit<E, A>) &
    * Creates a Failure Exit
    */
   fail: <E extends Type, A extends Type>(error: E) => Exit<E, A>;
+  /**
+   * Creates a Die Exit carrying a defect — a value that is not an `E`
+   */
+  die: <E extends Type, A extends Type>(defect: unknown) => Exit<E, A>;
   /**
    * Creates an Interrupted Exit with a fiber ID
    */
@@ -3122,6 +3179,12 @@ declare const Exit: (<E extends Type, A extends Type>(value: A) => Exit<E, A>) &
     readonly _tag: "Failure";
     error: E;
   };
+  /**
+   * Type guard for Die
+   */
+  isDie: <E extends Type, A extends Type>(exit: Exit<E, A>) => exit is Exit<E, A> & {
+    readonly _tag: "Die";
+  };
   /**
    * Type guard for Interrupted
    */
@@ -3293,6 +3356,23 @@ declare class InterruptedError extends Error {
   readonly _tag: "InterruptedError";
   constructor(message?: string);
 }
+/**
+ * Error thrown when a combinator that cannot run on the synchronous interpreter is
+ * reached by `runSync`. `timeout` and `race` are inherently asynchronous — there is no
+ * sync semantics for "wait `ms` then give up", or for racing concurrent effects.
+ *
+ * This is a **programmer error, not a domain failure**: it says the effect was built
+ * wrong for the terminal it was run with, so recovery combinators deliberately do not
+ * catch it (see {@link rethrowIfNonRecoverable}). Before it had its own type it was a
+ * plain `Error`, indistinguishable from a failed effect, so any downstream `.recover()`
+ * absorbed it and silently produced the fallback — `IO.succeed(1).timeoutTo(50, 99)`
+ * returned `Right(99)` under `runSync()`. See #246.
+ */
+declare class UnsupportedSyncOperationError extends Error {
+  readonly operation: "timeout" | "race";
+  readonly _tag: "UnsupportedSyncOperationError";
+  constructor(operation: "timeout" | "race");
+}
 /**
  * Error surfaced by value-driven repeat combinators when the iteration bound is
  * reached without the predicate being satisfied. Carries the last observed
@@ -4056,7 +4136,7 @@ declare const IO: (<A extends Type>(f: () => A | Promise<A>) => IO<never, unknow
    * )
    * ```
    */
-  withServices: <Services extends Record<string, Tag<Type>>, A extends Type>(services: Services, f: (ctx: { [K in keyof Services]: TagService<Services[K]> }) => A | Promise<A>) => IO<TagService<Services[keyof Services]>, unknown, A>;
+  withServices: <Services extends Record<string, Tag<Type>>, A extends Type>(services: Services, f: (ctx: { [K in keyof Services]: TagService<Services[K]>; }) => A | Promise<A>) => IO<TagService<Services[keyof Services]>, unknown, A>;
   /**
    * Runs all IOs in parallel and collects results.
    */
@@ -5840,7 +5920,7 @@ type RequireExhaustive<T, Cases> = IsUnion<T> extends true ? (keyof Cases extend
  * Pattern types for nested matching
  * @internal
  */
-type Pattern<T> = T | { [K in keyof T]?: Pattern<T[K]> } | ((value: T) => boolean) | {
+type Pattern<T> = T | { [K in keyof T]?: Pattern<T[K]>; } | ((value: T) => boolean) | {
   _: (value: T) => boolean;
 };
 /**
@@ -6078,7 +6158,7 @@ declare const Match: (<T extends Type>(value: T) => UntypedMatch<T>) & {
    *   .build()
    */
   struct: <T extends Type, R extends Type>() => {
-    case: (pattern: Pattern<T>, handler: (value: T) => R) => /*elided*/any;
+    case: (pattern: Pattern<T>, handler: (value: T) => R) => /*elided*/ any;
     build: () => (value: T) => R;
   };
   /**
@@ -6097,12 +6177,12 @@ declare const Match: (<T extends Type>(value: T) => UntypedMatch<T>) & {
    *   .build()
    */
   builder: <T extends Type, R extends Type>() => {
-    case: (pattern: Pattern<T>, result: PatternResult<T, R>) => /*elided*/any;
-    when: (guard: (value: T) => boolean, result: PatternResult<T, R>) => /*elided*/any;
+    case: (pattern: Pattern<T>, result: PatternResult<T, R>) => /*elided*/ any;
+    when: (guard: (value: T) => boolean, result: PatternResult<T, R>) => /*elided*/ any;
     default: (result: PatternResult<T, R>) => {
       build: () => (value: T) => R;
     };
   };
 };
 //#endregion
-export { LayerInput as $, EitherBase as $n, TaskParams as $t, HttpQueryParams as A, Set as An, EmptyListError as At, ResponseDecodeError as B, createSerializationCompanion as Bn, DecoderErrorComposite as Bt, TryKind as C, Functype as Cn, ParseError as Cr, formatError as Ct, HttpClient as D, Matchable as Dn, Do as Dt, Http as E, Traversable as En, Cond as Er, $ as Et, DecodeError as F, Serialization_d_exports as Fn, NoneError as Ft, InterruptedError as G, fromJSON as Gn, Err as Gt, TestClockTag as H, createTaggedSerializer as Hn, Async as Ht, HttpError as I, FUNCTYPE_MARKER as In, isDoCapable as It, Task as J, SerializedError as Jn, TaggedThrowable as Jt, RIO as K, fromYAML as Kn, Ok as Kt, HttpMethod as L, FunctypeEnvelope as Ln, unwrap as Lt, HttpRequestView as M, Try as Mn, FailureErrorType as Mt, HttpResponse as N, TypeNames as Nn, LeftError as Nt, HttpClientConfig as O, MatchableUtils as On, DoAsync as Ot, ParseMode as P, JSONValue as Pn, LeftErrorType as Pt, LayerError as Q, Either as Qn, TaskOutcome as Qt, HttpStatusError as R, SerializationResult as Rn, Decoder as Rt, OptionKind as S, FunctypeSum as Sn, isExtractable as Sr, createErrorSerializer as St, FoldableUtils as T, FunctypeCollection as Tn, Doable as Tr, safeStringify as Tt, TestContext as U, envelope as Un, CancellationToken as Ut, TestClock as V, createSerializer as Vn, DecoderErrorLeaf as Vt, IO as W, fromBinary as Wn, CancellationTokenSource as Wt, UIO as X, serializeError as Xn, TaskFailure as Xt, TimeoutError as Y, deserializeError as Yn, Task$1 as Yt, Layer as Z, LazyList as Zn, TaskMetadata as Zt, Identity as _, PositiveNumber as _n, Functor as _r, TypedErrorContext as _t, OptionConstructor as a, Throwable as an, TypeCheckLeft as ar, HasService as at, Kind as b, ValidatedBrand as bn, ContainerOps as br, ErrorWithTaskInfo as bt, Valuable as c, BoundedNumber as cn, isRight as cr, FieldValidation as ct, Obj as d, ISO8601Date as dn, Widen as dr, ValidationRule as dt, TaskResult as en, Left as er, LayerOutput as et, ESMap as f, IntegerNumber as fn, reduceRightWiden as fr, Validator as ft, Lazy as g, PositiveInteger as gn, AsyncMonad as gr, TypedError as gt, KVTraversable as h, PatternString as hn, Applicative as hr, ErrorStatus as ht, Option as i, NAME as in, TestEither as ir, ContextServices as it, HttpRequestOptions as j, List as jn, FailureError as jt, HttpMethodOptions as k, Collection as kn, DoGenerator as kt, ValuableParams as l, BoundedString as ln, tryCatch as lr, FormValidation as lt, Map$1 as m, NonNegativeNumber as mn, Promisable as mr, ErrorMessage as mt, UntypedMatch as n, createCancellationTokenSource as nn, Right as nr, ExitTag as nt, Some as o, ThrowableType as on, TypeCheckRight as or, Tag as ot, ESMapType as p, NonEmptyString as pn, reduceWiden as pr, ErrorCode as pt, RepeatExhausted as q, taggedEnvelope as qn, Sync as qt, None as r, isTaggedThrowable as rn, RightOf as rr, Context as rt, Stack as s, Base as sn, isLeft as sr, TagService as st, Match as t, TaskSuccess as tn, LeftOf as tr, Exit as tt, Ref as u, EmailAddress as un, tryCatchAsync as ur, Validation as ut, EitherKind as v, UUID as vn, Monad as vr, ErrorChainElement as vt, UniversalContainer as w, FunctypeBase as wn, DoResult as wr, formatStackTrace as wt, ListKind as x, ValidatedBrandCompanion as xn, Extractable as xr, TaskErrorInfo as xt, HKT as y, UrlString as yn, CollectionOps as yr, ErrorFormatterOptions as yt, NetworkError as z, createCustomSerializer as zn, DecoderError as zt };
+export { LayerError as $, Either as $n, TaskOutcome as $t, HttpQueryParams as A, Collection as An, DoGenerator as At, ResponseDecodeError as B, createCustomSerializer as Bn, DecoderError as Bt, TryKind as C, FunctypeSum as Cn, isExtractable as Cr, createErrorSerializer as Ct, HttpClient as D, Traversable as Dn, Cond as Dr, $ as Dt, Http as E, FunctypeCollection as En, Doable as Er, safeStringify as Et, DecodeError as F, JSONValue as Fn, LeftErrorType as Ft, InterruptedError as G, fromBinary as Gn, CancellationTokenSource as Gt, TestClockTag as H, createSerializer as Hn, DecoderErrorLeaf as Ht, HttpError as I, Serialization_d_exports as In, NoneError as It, Task as J, taggedEnvelope as Jn, Sync as Jt, RIO as K, fromJSON as Kn, Err as Kt, HttpMethod as L, FUNCTYPE_MARKER as Ln, isDoCapable as Lt, HttpRequestView as M, List as Mn, FailureError as Mt, HttpResponse as N, Try as Nn, FailureErrorType as Nt, HttpClientConfig as O, Matchable as On, Do as Ot, ParseMode as P, TypeNames as Pn, LeftError as Pt, Layer as Q, LazyList as Qn, TaskMetadata as Qt, HttpStatusError as R, FunctypeEnvelope as Rn, unwrap as Rt, OptionKind as S, ValidatedBrandCompanion as Sn, Extractable as Sr, TaskErrorInfo as St, FoldableUtils as T, FunctypeBase as Tn, DoResult as Tr, formatStackTrace as Tt, TestContext as U, createTaggedSerializer as Un, Async as Ut, TestClock as V, createSerializationCompanion as Vn, DecoderErrorComposite as Vt, IO as W, envelope as Wn, CancellationToken as Wt, UIO as X, deserializeError as Xn, Task$1 as Xt, TimeoutError as Y, SerializedError as Yn, TaggedThrowable as Yt, UnsupportedSyncOperationError as Z, serializeError as Zn, TaskFailure as Zt, Identity as _, PositiveInteger as _n, AsyncMonad as _r, TypedError as _t, OptionConstructor as a, NAME as an, TestEither as ar, ContextServices as at, Kind as b, UrlString as bn, CollectionOps as br, ErrorFormatterOptions as bt, Valuable as c, Base as cn, isLeft as cr, TagService as ct, Obj as d, EmailAddress as dn, tryCatchAsync as dr, Validation as dt, TaskParams as en, EitherBase as er, LayerInput as et, ESMap as f, ISO8601Date as fn, Widen as fr, ValidationRule as ft, Lazy as g, PatternString as gn, Applicative as gr, ErrorStatus as gt, KVTraversable as h, NonNegativeNumber as hn, Promisable as hr, ErrorMessage as ht, Option as i, isTaggedThrowable as in, RightOf as ir, Context as it, HttpRequestOptions as j, Set as jn, EmptyListError as jt, HttpMethodOptions as k, MatchableUtils as kn, DoAsync as kt, ValuableParams as l, BoundedNumber as ln, isRight as lr, FieldValidation as lt, Map$1 as m, NonEmptyString as mn, reduceWiden as mr, ErrorCode as mt, UntypedMatch as n, TaskSuccess as nn, LeftOf as nr, Exit as nt, Some as o, Throwable as on, TypeCheckLeft as or, HasService as ot, ESMapType as p, IntegerNumber as pn, reduceRightWiden as pr, Validator as pt, RepeatExhausted as q, fromYAML as qn, Ok as qt, None as r, createCancellationTokenSource as rn, Right as rr, ExitTag as rt, Stack as s, ThrowableType as sn, TypeCheckRight as sr, Tag as st, Match as t, TaskResult as tn, Left as tr, LayerOutput as tt, Ref as u, BoundedString as un, tryCatch as ur, FormValidation as ut, EitherKind as v, PositiveNumber as vn, Functor as vr, TypedErrorContext as vt, UniversalContainer as w, Functype as wn, ParseError as wr, formatError as wt, ListKind as x, ValidatedBrand as xn, ContainerOps as xr, ErrorWithTaskInfo as xt, HKT as y, UUID as yn, Monad as yr, ErrorChainElement as yt, NetworkError as z, SerializationResult as zn, Decoder as zt };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { a as ExtractBrand, c as hasBrand, i as BrandedString, l as unwrapBrand, n as BrandedBoolean, o as Unwrap, r as BrandedNumber, s as createBrander, t as Brand } from "./Brand-bfnGXuum.js";
-import { i as Companion, n as InstanceType, r as isCompanion, t as CompanionMethods } from "./CompanionTypes-CAxuM7qS.js";
-import { a as isTypeable, c as SerializationMethods, d as Type, i as TypeableParams, l as Pipe, n as ExtractTag, o as Serializable, r as Typeable, s as SerializableEnvelope, t as Tuple, u as Foldable } from "./Tuple-8yRldBty.js";
-import { $ as LayerInput, $n as EitherBase, $t as TaskParams, A as HttpQueryParams, An as Set, At as EmptyListError, B as ResponseDecodeError, Bn as createSerializationCompanion, Bt as DecoderErrorComposite, C as TryKind, Cn as Functype, Cr as ParseError, Ct as formatError, D as HttpClient, Dn as Matchable, Dt as Do, E as Http, En as Traversable, Er as Cond, Et as $, F as DecodeError, Fn as Serialization_d_exports, Ft as NoneError, G as InterruptedError, Gn as fromJSON, Gt as Err, H as TestClockTag, Hn as createTaggedSerializer, Ht as Async, I as HttpError, In as FUNCTYPE_MARKER, It as isDoCapable, J as Task, Jn as SerializedError, Jt as TaggedThrowable, K as RIO, Kn as fromYAML, Kt as Ok, L as HttpMethod, Ln as FunctypeEnvelope, Lt as unwrap, M as HttpRequestView, Mn as Try, Mt as FailureErrorType, N as HttpResponse, Nn as TypeNames, Nt as LeftError, O as HttpClientConfig, On as MatchableUtils, Ot as DoAsync, P as ParseMode, Pn as JSONValue, Pt as LeftErrorType, Q as LayerError, Qn as Either, Qt as TaskOutcome, R as HttpStatusError, Rn as SerializationResult, Rt as Decoder, S as OptionKind, Sn as FunctypeSum, Sr as isExtractable, St as createErrorSerializer, T as FoldableUtils, Tn as FunctypeCollection, Tr as Doable, Tt as safeStringify, U as TestContext, Un as envelope, Ut as CancellationToken, V as TestClock, Vn as createSerializer, Vt as DecoderErrorLeaf, W as IO, Wn as fromBinary, Wt as CancellationTokenSource, X as UIO, Xn as serializeError, Xt as TaskFailure, Y as TimeoutError, Yn as deserializeError, Yt as Task$1, Z as Layer, Zn as LazyList, Zt as TaskMetadata, _ as Identity, _n as PositiveNumber, _r as Functor, _t as TypedErrorContext, a as OptionConstructor, an as Throwable, ar as TypeCheckLeft, at as HasService, b as Kind, bn as ValidatedBrand, br as ContainerOps, bt as ErrorWithTaskInfo, c as Valuable, cn as BoundedNumber, cr as isRight, ct as FieldValidation, d as Obj, dn as ISO8601Date, dr as Widen, dt as ValidationRule, en as TaskResult, er as Left, et as LayerOutput, f as ESMap, fn as IntegerNumber, fr as reduceRightWiden, ft as Validator, g as Lazy, gn as PositiveInteger, gr as AsyncMonad, gt as TypedError, h as KVTraversable, hn as PatternString, hr as Applicative, ht as ErrorStatus, i as Option, in as NAME, ir as TestEither, it as ContextServices, j as HttpRequestOptions, jn as List, jt as FailureError, k as HttpMethodOptions, kn as Collection, kt as DoGenerator, l as ValuableParams, ln as BoundedString, lr as tryCatch, lt as FormValidation, m as Map, mn as NonNegativeNumber, mr as Promisable, mt as ErrorMessage, n as UntypedMatch, nn as createCancellationTokenSource, nr as Right, nt as ExitTag, o as Some, on as ThrowableType, or as TypeCheckRight, ot as Tag, p as ESMapType, pn as NonEmptyString, pr as reduceWiden, pt as ErrorCode, q as RepeatExhausted, qn as taggedEnvelope, qt as Sync, r as None, rn as isTaggedThrowable, rr as RightOf, rt as Context, s as Stack, sn as Base, sr as isLeft, st as TagService, t as Match, tn as TaskSuccess, tr as LeftOf, tt as Exit, u as Ref, un as EmailAddress, ur as tryCatchAsync, ut as Validation, v as EitherKind, vn as UUID, vr as Monad, vt as ErrorChainElement, w as UniversalContainer, wn as FunctypeBase, wr as DoResult, wt as formatStackTrace, x as ListKind, xn as ValidatedBrandCompanion, xr as Extractable, xt as TaskErrorInfo, y as HKT, yn as UrlString, yr as CollectionOps, yt as ErrorFormatterOptions, z as NetworkError, zn as createCustomSerializer, zt as DecoderError } from "./index-CCuIZ-ut.js";
+import { i as Companion, n as InstanceType, r as isCompanion, t as CompanionMethods } from "./CompanionTypes-Cc90cQ4P.js";
+import { a as isTypeable, c as SerializationMethods, d as Type, i as TypeableParams, l as Pipe, n as ExtractTag, o as Serializable, r as Typeable, s as SerializableEnvelope, t as Tuple, u as Foldable } from "./Tuple-B8KM-H8Y.js";
+import { $ as LayerError, $n as Either, $t as TaskOutcome, A as HttpQueryParams, An as Collection, At as DoGenerator, B as ResponseDecodeError, Bn as createCustomSerializer, Bt as DecoderError, C as TryKind, Cn as FunctypeSum, Cr as isExtractable, Ct as createErrorSerializer, D as HttpClient, Dn as Traversable, Dr as Cond, Dt as $, E as Http, En as FunctypeCollection, Er as Doable, Et as safeStringify, F as DecodeError, Fn as JSONValue, Ft as LeftErrorType, G as InterruptedError, Gn as fromBinary, Gt as CancellationTokenSource, H as TestClockTag, Hn as createSerializer, Ht as DecoderErrorLeaf, I as HttpError, In as Serialization_d_exports, It as NoneError, J as Task, Jn as taggedEnvelope, Jt as Sync, K as RIO, Kn as fromJSON, Kt as Err, L as HttpMethod, Ln as FUNCTYPE_MARKER, Lt as isDoCapable, M as HttpRequestView, Mn as List, Mt as FailureError, N as HttpResponse, Nn as Try, Nt as FailureErrorType, O as HttpClientConfig, On as Matchable, Ot as Do, P as ParseMode, Pn as TypeNames, Pt as LeftError, Q as Layer, Qn as LazyList, Qt as TaskMetadata, R as HttpStatusError, Rn as FunctypeEnvelope, Rt as unwrap, S as OptionKind, Sn as ValidatedBrandCompanion, Sr as Extractable, St as TaskErrorInfo, T as FoldableUtils, Tn as FunctypeBase, Tr as DoResult, Tt as formatStackTrace, U as TestContext, Un as createTaggedSerializer, Ut as Async, V as TestClock, Vn as createSerializationCompanion, Vt as DecoderErrorComposite, W as IO, Wn as envelope, Wt as CancellationToken, X as UIO, Xn as deserializeError, Xt as Task$1, Y as TimeoutError, Yn as SerializedError, Yt as TaggedThrowable, Z as UnsupportedSyncOperationError, Zn as serializeError, Zt as TaskFailure, _ as Identity, _n as PositiveInteger, _r as AsyncMonad, _t as TypedError, a as OptionConstructor, an as NAME, ar as TestEither, at as ContextServices, b as Kind, bn as UrlString, br as CollectionOps, bt as ErrorFormatterOptions, c as Valuable, cn as Base, cr as isLeft, ct as TagService, d as Obj, dn as EmailAddress, dr as tryCatchAsync, dt as Validation, en as TaskParams, er as EitherBase, et as LayerInput, f as ESMap, fn as ISO8601Date, fr as Widen, ft as ValidationRule, g as Lazy, gn as PatternString, gr as Applicative, gt as ErrorStatus, h as KVTraversable, hn as NonNegativeNumber, hr as Promisable, ht as ErrorMessage, i as Option, in as isTaggedThrowable, ir as RightOf, it as Context, j as HttpRequestOptions, jn as Set, jt as EmptyListError, k as HttpMethodOptions, kn as MatchableUtils, kt as DoAsync, l as ValuableParams, ln as BoundedNumber, lr as isRight, lt as FieldValidation, m as Map, mn as NonEmptyString, mr as reduceWiden, mt as ErrorCode, n as UntypedMatch, nn as TaskSuccess, nr as LeftOf, nt as Exit, o as Some, on as Throwable, or as TypeCheckLeft, ot as HasService, p as ESMapType, pn as IntegerNumber, pr as reduceRightWiden, pt as Validator, q as RepeatExhausted, qn as fromYAML, qt as Ok, r as None, rn as createCancellationTokenSource, rr as Right, rt as ExitTag, s as Stack, sn as ThrowableType, sr as TypeCheckRight, st as Tag, t as Match, tn as TaskResult, tr as Left, tt as LayerOutput, u as Ref, un as BoundedString, ur as tryCatch, ut as FormValidation, v as EitherKind, vn as PositiveNumber, vr as Functor, vt as TypedErrorContext, w as UniversalContainer, wn as Functype, wr as ParseError, wt as formatError, x as ListKind, xn as ValidatedBrand, xr as ContainerOps, xt as ErrorWithTaskInfo, y as HKT, yn as UUID, yr as Monad, yt as ErrorChainElement, z as NetworkError, zn as SerializationResult, zt as Decoder } from "./index-CIS_THnu.js";
 import { t as Logger } from "./Logger-BmprRS8v.js";
-export { $, type Applicative, Async, type AsyncMonad, Base, BoundedNumber, BoundedString, Brand, BrandedBoolean, type BrandedBoolean as BrandedBooleanType, BrandedNumber, type BrandedNumber as BrandedNumberType, BrandedString, type BrandedString as BrandedStringType, CancellationToken, CancellationTokenSource, Collection, type CollectionOps, Companion, CompanionMethods, Cond, type ContainerOps, Context, type Context as ContextType, type ContextServices, type DecodeError, Decoder, DecoderError, type DecoderErrorComposite, type DecoderErrorLeaf, Do, DoAsync, DoGenerator, type DoResult, type Doable, ESMap, ESMapType, Either, EitherBase, EitherKind, EmailAddress, EmptyListError, Err, ErrorChainElement, ErrorCode, ErrorFormatterOptions, ErrorMessage, ErrorStatus, ErrorWithTaskInfo, Exit, type Exit as ExitType, type ExitTag, type ExtractBrand, ExtractTag, type Extractable, FUNCTYPE_MARKER, FailureError, FailureErrorType, FieldValidation, Foldable, FoldableUtils, FormValidation, type Functor, Functype, FunctypeBase, FunctypeCollection, FunctypeEnvelope, FunctypeSum, HKT, type HasService, Http, HttpClient, type HttpClientConfig, type HttpError, HttpError as HttpErrors, type HttpMethod, type HttpMethodOptions, type HttpQueryParams, type HttpRequestOptions, type HttpRequestView, type HttpResponse, type HttpStatusError, IO, type IO as IOType, type Task as IOTask, ISO8601Date, Identity, InstanceType, IntegerNumber, InterruptedError, type JSONValue, KVTraversable, Kind, Layer, type Layer as LayerType, type LayerError, type LayerInput, type LayerOutput, Lazy, type Lazy as LazyType, LazyList, Left, LeftError, LeftErrorType, LeftOf, List, ListKind, type Logger, Map, Match, type Matchable, MatchableUtils, type Monad, NAME, type NetworkError, NonEmptyString, NonNegativeNumber, None, NoneError, Obj, Ok, Option, OptionConstructor, OptionKind, ParseError, type ParseMode, PatternString, Pipe, PositiveInteger, PositiveNumber, type Promisable, type RIO, Ref, type Ref as RefType, RepeatExhausted, type ResponseDecodeError, Right, RightOf, Serializable, SerializableEnvelope, Serialization_d_exports as Serialization, SerializationMethods, SerializationResult, SerializedError, Set, Some, Stack, Sync, Tag, type Tag as TagType, type TagService, TaggedThrowable, Task$1 as Task, TaskErrorInfo, TaskFailure, TaskMetadata, TaskOutcome, TaskParams, TaskResult, TaskSuccess, TestClock, type TestClock as TestClockType, TestClockTag, TestContext, type TestContext as TestContextType, TestEither, Throwable, ThrowableType, TimeoutError, Traversable, Try, TryKind, Tuple, Type, TypeCheckLeft, TypeCheckRight, TypeNames, Typeable, TypeableParams, TypedError, TypedErrorContext, type UIO, UUID, UniversalContainer, UntypedMatch, type Unwrap, UrlString, ValidatedBrand, type ValidatedBrand as ValidatedBrandType, type ValidatedBrandCompanion, Validation, ValidationRule, Validator, Valuable, ValuableParams, type Widen, createBrander, createCancellationTokenSource, createCustomSerializer, createErrorSerializer, createSerializationCompanion, createSerializer, createTaggedSerializer, deserializeError, envelope, formatError, formatStackTrace, fromBinary, fromJSON, fromYAML, hasBrand, isCompanion, isDoCapable, isExtractable, isLeft, isRight, isTaggedThrowable, isTypeable, reduceRightWiden, reduceWiden, safeStringify, serializeError, taggedEnvelope, tryCatch, tryCatchAsync, unwrap, unwrapBrand };
+export { $, type Applicative, Async, type AsyncMonad, Base, BoundedNumber, BoundedString, Brand, BrandedBoolean, type BrandedBoolean as BrandedBooleanType, BrandedNumber, type BrandedNumber as BrandedNumberType, BrandedString, type BrandedString as BrandedStringType, CancellationToken, CancellationTokenSource, Collection, type CollectionOps, Companion, CompanionMethods, Cond, type ContainerOps, Context, type Context as ContextType, type ContextServices, type DecodeError, Decoder, DecoderError, type DecoderErrorComposite, type DecoderErrorLeaf, Do, DoAsync, DoGenerator, type DoResult, type Doable, ESMap, ESMapType, Either, EitherBase, EitherKind, EmailAddress, EmptyListError, Err, ErrorChainElement, ErrorCode, ErrorFormatterOptions, ErrorMessage, ErrorStatus, ErrorWithTaskInfo, Exit, type Exit as ExitType, type ExitTag, type ExtractBrand, ExtractTag, type Extractable, FUNCTYPE_MARKER, FailureError, FailureErrorType, FieldValidation, Foldable, FoldableUtils, FormValidation, type Functor, Functype, FunctypeBase, FunctypeCollection, FunctypeEnvelope, FunctypeSum, HKT, type HasService, Http, HttpClient, type HttpClientConfig, type HttpError, HttpError as HttpErrors, type HttpMethod, type HttpMethodOptions, type HttpQueryParams, type HttpRequestOptions, type HttpRequestView, type HttpResponse, type HttpStatusError, IO, type IO as IOType, type Task as IOTask, ISO8601Date, Identity, InstanceType, IntegerNumber, InterruptedError, type JSONValue, KVTraversable, Kind, Layer, type Layer as LayerType, type LayerError, type LayerInput, type LayerOutput, Lazy, type Lazy as LazyType, LazyList, Left, LeftError, LeftErrorType, LeftOf, List, ListKind, type Logger, Map, Match, type Matchable, MatchableUtils, type Monad, NAME, type NetworkError, NonEmptyString, NonNegativeNumber, None, NoneError, Obj, Ok, Option, OptionConstructor, OptionKind, ParseError, type ParseMode, PatternString, Pipe, PositiveInteger, PositiveNumber, type Promisable, type RIO, Ref, type Ref as RefType, RepeatExhausted, type ResponseDecodeError, Right, RightOf, Serializable, SerializableEnvelope, Serialization_d_exports as Serialization, SerializationMethods, SerializationResult, SerializedError, Set, Some, Stack, Sync, Tag, type Tag as TagType, type TagService, TaggedThrowable, Task$1 as Task, TaskErrorInfo, TaskFailure, TaskMetadata, TaskOutcome, TaskParams, TaskResult, TaskSuccess, TestClock, type TestClock as TestClockType, TestClockTag, TestContext, type TestContext as TestContextType, TestEither, Throwable, ThrowableType, TimeoutError, Traversable, Try, TryKind, Tuple, Type, TypeCheckLeft, TypeCheckRight, TypeNames, Typeable, TypeableParams, TypedError, TypedErrorContext, type UIO, UUID, UniversalContainer, UnsupportedSyncOperationError, UntypedMatch, type Unwrap, UrlString, ValidatedBrand, type ValidatedBrand as ValidatedBrandType, type ValidatedBrandCompanion, Validation, ValidationRule, Validator, Valuable, ValuableParams, type Widen, createBrander, createCancellationTokenSource, createCustomSerializer, createErrorSerializer, createSerializationCompanion, createSerializer, createTaggedSerializer, deserializeError, envelope, formatError, formatStackTrace, fromBinary, fromJSON, fromYAML, hasBrand, isCompanion, isDoCapable, isExtractable, isLeft, isRight, isTaggedThrowable, isTypeable, reduceRightWiden, reduceWiden, safeStringify, serializeError, taggedEnvelope, tryCatch, tryCatchAsync, unwrap, unwrapBrand };

package/dist/index.js

@@ -1 +1 @@
-import{Brand as e,BrandedBoolean as t,BrandedNumber as n,BrandedString as r,createBrander as i,hasBrand as a,unwrap as o}from"./branded/index.js";import{$ as s,A as c,At as l,B as u,C as d,Ct as f,D as p,Dt as m,E as h,Et as g,F as _,G as v,H as y,I as b,J as x,K as S,L as C,M as w,Mt as T,N as E,Nt as D,O,Ot as k,P as A,Q as j,R as M,S as N,St as P,T as F,Tt as I,U as L,V as R,W as z,X as B,Y as V,Z as H,_ as U,_t as W,a as G,at as K,b as q,bt as J,c as Y,ct as X,d as Z,dt as Q,et as $,f as ee,ft as te,g as ne,gt as re,h as ie,ht as ae,i as oe,it as se,j as ce,jt as le,k as ue,kt as de,l as fe,lt as pe,m as me,mt as he,n as ge,nt as _e,o as ve,ot as ye,p as be,pt as xe,q as Se,r as Ce,rt as we,s as Te,st as Ee,t as De,tt as Oe,u as ke,ut as Ae,v as je,vt as Me,w as Ne,wt as Pe,x as Fe,xt as Ie,y as Le,yt as Re,z as ze}from"./src-C4olFIr1.js";import{t as Be}from"./Companion-DiOMBHDG.js";import{a as Ve,c as He,d as Ue,f as We,i as Ge,l as Ke,n as qe,o as Je,r as Ye,s as Xe,t as Ze,u as Qe}from"./serialization-my_TLROv.js";import{n as $e,t as et}from"./typeclass-C61yDVYd.js";import{t as tt}from"./CompanionTypes-BVqO7Kc2.js";import{Tuple as nt}from"./tuple/index.js";export{ce as $,H as Base,$ as BoundedNumber,Oe as BoundedString,e as Brand,t as BrandedBoolean,n as BrandedNumber,r as BrandedString,Be as Companion,s as Cond,d as Context,u as Decoder,R as DecoderError,w as Do,E as DoAsync,L as ESMap,xe as Either,_e as EmailAddress,A as EmptyListError,z as Err,N as Exit,Ze as FUNCTYPE_MARKER,_ as FailureError,fe as FoldableUtils,Y as HKT,ke as Http,ee as HttpClient,Z as HttpErrors,je as IO,we as ISO8601Date,Te as Identity,se as IntegerNumber,Le as InterruptedError,U as Layer,ve as Lazy,g as LazyList,he as Left,b as LeftError,P as List,y as Map,j as Match,G as MatchableUtils,V as NAME,K as NonEmptyString,ye as NonNegativeNumber,de as None,C as NoneError,oe as Obj,v as Ok,l as Option,le as OptionConstructor,D as ParseError,Ee as PatternString,X as PositiveInteger,pe as PositiveNumber,m as Ref,q as RepeatExhausted,ae as Right,ge as Serialization,k as Set,T as Some,Ce as Stack,ne as Tag,S as Task,be as TestClock,me as TestClockTag,ie as TestContext,B as Throwable,Fe as TimeoutError,I as Try,nt as Tuple,re as TypeCheckLeft,W as TypeCheckRight,f as Typeable,h as TypedError,Ae as UUID,Q as UrlString,te as ValidatedBrand,F as Validation,De as Valuable,i as createBrander,Se as createCancellationTokenSource,qe as createCustomSerializer,p as createErrorSerializer,Ye as createSerializationCompanion,Ge as createSerializer,Ve as createTaggedSerializer,Ue as deserializeError,Je as envelope,O as formatError,ue as formatStackTrace,Xe as fromBinary,He as fromJSON,Ke as fromYAML,a as hasBrand,tt as isCompanion,M as isDoCapable,Ne as isExtractable,Me as isLeft,Re as isRight,x as isTaggedThrowable,Pe as isTypeable,et as reduceRightWiden,$e as reduceWiden,c as safeStringify,We as serializeError,Qe as taggedEnvelope,J as tryCatch,Ie as tryCatchAsync,ze as unwrap,o as unwrapBrand};
+import{Brand as e,BrandedBoolean as t,BrandedNumber as n,BrandedString as r,createBrander as i,hasBrand as a,unwrap as o}from"./branded/index.js";import{$ as s,A as c,At as l,B as u,C as d,Ct as f,D as p,Dt as m,E as h,Et as g,F as _,G as v,H as y,I as b,J as x,K as S,L as C,M as w,Mt as T,N as E,Nt as D,O,Ot as k,P as A,Pt as j,Q as M,R as N,S as P,St as F,T as I,Tt as L,U as R,V as z,W as B,X as V,Y as H,Z as U,_ as W,_t as G,a as K,at as q,b as J,bt as Y,c as X,ct as Z,d as Q,dt as $,et as ee,f as te,ft as ne,g as re,gt as ie,h as ae,ht as oe,i as se,it as ce,j as le,jt as ue,k as de,kt as fe,l as pe,lt as me,m as he,mt as ge,n as _e,nt as ve,o as ye,ot as be,p as xe,pt as Se,q as Ce,r as we,rt as Te,s as Ee,st as De,t as Oe,tt as ke,u as Ae,ut as je,v as Me,vt as Ne,w as Pe,wt as Fe,x as Ie,xt as Le,y as Re,yt as ze,z as Be}from"./src-CLtqjfLE.js";import{t as Ve}from"./Companion-DiOMBHDG.js";import{a as He,c as Ue,d as We,f as Ge,i as Ke,l as qe,n as Je,o as Ye,r as Xe,s as Ze,t as Qe,u as $e}from"./serialization-my_TLROv.js";import{n as et,t as tt}from"./typeclass-C61yDVYd.js";import{t as nt}from"./CompanionTypes-BVqO7Kc2.js";import{Tuple as rt}from"./tuple/index.js";export{w as $,M as Base,ke as BoundedNumber,ve as BoundedString,e as Brand,t as BrandedBoolean,n as BrandedNumber,r as BrandedString,Ve as Companion,ee as Cond,Pe as Context,z as Decoder,y as DecoderError,E as Do,A as DoAsync,B as ESMap,ge as Either,Te as EmailAddress,_ as EmptyListError,v as Err,d as Exit,Qe as FUNCTYPE_MARKER,b as FailureError,pe as FoldableUtils,X as HKT,Ae as Http,te as HttpClient,Q as HttpErrors,Me as IO,ce as ISO8601Date,Ee as Identity,q as IntegerNumber,Re as InterruptedError,W as Layer,ye as Lazy,m as LazyList,oe as Left,C as LeftError,f as List,R as Map,s as Match,K as MatchableUtils,V as NAME,be as NonEmptyString,De as NonNegativeNumber,l as None,N as NoneError,se as Obj,S as Ok,ue as Option,T as OptionConstructor,j as ParseError,Z as PatternString,me as PositiveInteger,je as PositiveNumber,k as Ref,J as RepeatExhausted,ie as Right,_e as Serialization,fe as Set,D as Some,we as Stack,re as Tag,Ce as Task,xe as TestClock,he as TestClockTag,ae as TestContext,U as Throwable,Ie as TimeoutError,g as Try,rt as Tuple,G as TypeCheckLeft,Ne as TypeCheckRight,Fe as Typeable,p as TypedError,$ as UUID,P as UnsupportedSyncOperationError,ne as UrlString,Se as ValidatedBrand,h as Validation,Oe as Valuable,i as createBrander,x as createCancellationTokenSource,Je as createCustomSerializer,O as createErrorSerializer,Xe as createSerializationCompanion,Ke as createSerializer,He as createTaggedSerializer,We as deserializeError,Ye as envelope,de as formatError,c as formatStackTrace,Ze as fromBinary,Ue as fromJSON,qe as fromYAML,a as hasBrand,nt as isCompanion,Be as isDoCapable,I as isExtractable,ze as isLeft,Y as isRight,H as isTaggedThrowable,L as isTypeable,tt as reduceRightWiden,et as reduceWiden,le as safeStringify,Ge as serializeError,$e as taggedEnvelope,Le as tryCatch,F as tryCatchAsync,u as unwrap,o as unwrapBrand};

package/dist/io/index.d.ts

@@ -1,2 +1,2 @@
-import { $ as LayerInput, G as InterruptedError, H as TestClockTag, J as Task, K as RIO, Q as LayerError, U as TestContext, V as TestClock, W as IO, X as UIO, Y as TimeoutError, Z as Layer, at as HasService, et as LayerOutput, it as ContextServices, nt as ExitTag, ot as Tag, q as RepeatExhausted, rt as Context, st as TagService, tt as Exit } from "../index-CCuIZ-ut.js";
-export { Context, type Context as ContextType, type ContextServices, Exit, type Exit as ExitType, type ExitTag, type HasService, IO, type IO as IOType, type Task as IOTask, InterruptedError, Layer, type Layer as LayerType, type LayerError, type LayerInput, type LayerOutput, type RIO, RepeatExhausted, Tag, type Tag as TagType, type TagService, TestClock, type TestClock as TestClockType, TestClockTag, TestContext, type TestContext as TestContextType, TimeoutError, type UIO };
+import { $ as LayerError, G as InterruptedError, H as TestClockTag, J as Task, K as RIO, Q as Layer, U as TestContext, V as TestClock, W as IO, X as UIO, Y as TimeoutError, Z as UnsupportedSyncOperationError, at as ContextServices, ct as TagService, et as LayerInput, it as Context, nt as Exit, ot as HasService, q as RepeatExhausted, rt as ExitTag, st as Tag, tt as LayerOutput } from "../index-CIS_THnu.js";
+export { Context, type Context as ContextType, type ContextServices, Exit, type Exit as ExitType, type ExitTag, type HasService, IO, type IO as IOType, type Task as IOTask, InterruptedError, Layer, type Layer as LayerType, type LayerError, type LayerInput, type LayerOutput, type RIO, RepeatExhausted, Tag, type Tag as TagType, type TagService, TestClock, type TestClock as TestClockType, TestClockTag, TestContext, type TestContext as TestContextType, TimeoutError, type UIO, UnsupportedSyncOperationError };

package/dist/io/index.js

@@ -1 +1 @@
-import{C as e,S as t,_ as n,b as r,g as i,h as a,m as o,p as s,v as c,x as l,y as u}from"../src-C4olFIr1.js";export{e as Context,t as Exit,c as IO,u as InterruptedError,n as Layer,r as RepeatExhausted,i as Tag,s as TestClock,o as TestClockTag,a as TestContext,l as TimeoutError};
+import{C as e,S as t,_ as n,b as r,g as i,h as a,m as o,p as s,v as c,w as l,x as u,y as d}from"../src-CLtqjfLE.js";export{l as Context,e as Exit,c as IO,d as InterruptedError,n as Layer,r as RepeatExhausted,i as Tag,s as TestClock,o as TestClockTag,a as TestContext,u as TimeoutError,t as UnsupportedSyncOperationError};

package/dist/lazy/index.d.ts

@@ -1,2 +1,2 @@
-import { g as Lazy } from "../index-CCuIZ-ut.js";
+import { g as Lazy } from "../index-CIS_THnu.js";
 export { Lazy, type Lazy as LazyType };

package/dist/lazy/index.js

@@ -1 +1 @@
-import{o as e}from"../src-C4olFIr1.js";export{e as Lazy};
+import{o as e}from"../src-CLtqjfLE.js";export{e as Lazy};

package/dist/list/index.d.ts

@@ -1,2 +1,2 @@
-import { jn as List } from "../index-CCuIZ-ut.js";
+import { Mn as List } from "../index-CIS_THnu.js";
 export { List };

package/dist/list/index.js

@@ -1 +1 @@
-import{St as e}from"../src-C4olFIr1.js";export{e as List};
+import{Ct as e}from"../src-CLtqjfLE.js";export{e as List};

package/dist/map/index.d.ts

@@ -1,2 +1,2 @@
-import { m as Map } from "../index-CCuIZ-ut.js";
+import { m as Map } from "../index-CIS_THnu.js";
 export { Map };

package/dist/map/index.js

@@ -1 +1 @@
-import{H as e}from"../src-C4olFIr1.js";export{e as Map};
+import{U as e}from"../src-CLtqjfLE.js";export{e as Map};

package/dist/obj/index.d.ts

@@ -1,2 +1,2 @@
-import { d as Obj } from "../index-CCuIZ-ut.js";
+import { d as Obj } from "../index-CIS_THnu.js";
 export { Obj };

package/dist/obj/index.js

@@ -1 +1 @@
-import{i as e}from"../src-C4olFIr1.js";export{e as Obj};
+import{i as e}from"../src-CLtqjfLE.js";export{e as Obj};

package/dist/option/index.d.ts

@@ -1,2 +1,2 @@
-import { a as OptionConstructor, i as Option, o as Some, r as None } from "../index-CCuIZ-ut.js";
+import { a as OptionConstructor, i as Option, o as Some, r as None } from "../index-CIS_THnu.js";
 export { None, Option, OptionConstructor, Some };

package/dist/option/index.js

@@ -1 +1 @@
-import{At as e,Mt as t,jt as n,kt as r}from"../src-C4olFIr1.js";export{r as None,e as Option,n as OptionConstructor,t as Some};
+import{At as e,Mt as t,Nt as n,jt as r}from"../src-CLtqjfLE.js";export{e as None,r as Option,t as OptionConstructor,n as Some};

package/dist/serialization/index.d.ts

@@ -1,2 +1,2 @@
-import { Bn as createSerializationCompanion, Gn as fromJSON, Hn as createTaggedSerializer, In as FUNCTYPE_MARKER, Jn as SerializedError, Kn as fromYAML, Ln as FunctypeEnvelope, Pn as JSONValue, Rn as SerializationResult, Un as envelope, Vn as createSerializer, Wn as fromBinary, Xn as serializeError, Yn as deserializeError, qn as taggedEnvelope, zn as createCustomSerializer } from "../index-CCuIZ-ut.js";
+import { Bn as createCustomSerializer, Fn as JSONValue, Gn as fromBinary, Hn as createSerializer, Jn as taggedEnvelope, Kn as fromJSON, Ln as FUNCTYPE_MARKER, Rn as FunctypeEnvelope, Un as createTaggedSerializer, Vn as createSerializationCompanion, Wn as envelope, Xn as deserializeError, Yn as SerializedError, Zn as serializeError, qn as fromYAML, zn as SerializationResult } from "../index-CIS_THnu.js";
 export { FUNCTYPE_MARKER, FunctypeEnvelope, type JSONValue, SerializationResult, SerializedError, createCustomSerializer, createSerializationCompanion, createSerializer, createTaggedSerializer, deserializeError, envelope, fromBinary, fromJSON, fromYAML, serializeError, taggedEnvelope };

package/dist/set/index.d.ts

@@ -1,2 +1,2 @@
-import { An as Set } from "../index-CCuIZ-ut.js";
+import { jn as Set } from "../index-CIS_THnu.js";
 export { Set };

package/dist/set/index.js

@@ -1 +1 @@
-import{Ot as e}from"../src-C4olFIr1.js";export{e as Set};
+import{kt as e}from"../src-CLtqjfLE.js";export{e as Set};