functype 1.1.0 → 1.2.0

package/dist/{index-pSswBNzx.d.ts → index-DAKubqXO.d.ts}

@@ -1,5 +1,5 @@
 import { t as Brand } from "./Brand-bfnGXuum.js";
-import { c as Pipe, l as Foldable, o as Serializable, r as Typeable, t as Tuple, u as Type } from "./Tuple-BmPH46pK.js";
+import { d as Type, l as Pipe, o as Serializable, r as Typeable, t as Tuple, u as Foldable } from "./Tuple-8yRldBty.js";
 
 //#region src/error/ParseError.d.ts
 declare const ParseError: (message?: string) => Error & {
@@ -200,6 +200,13 @@ declare const LazyList: (<A extends Type>(iterable: Iterable<A>) => LazyList<A>)
    * Create a LazyList from multiple values
    */
   from: <A extends Type>(...values: A[]) => LazyList<A>;
+  /**
+   * Reconstruct a LazyList from a JSON envelope emitted by `serialize().toJSON()`
+   * or instance `toJSON()`. Verifies `@functype === "LazyList"` when the marker
+   * is present (canonical from 1.2.0). The materialized array becomes the new
+   * LazyList's backing — laziness can't survive JSON serialization.
+   */
+  fromJSON: <A extends Type>(json: string) => LazyList<A>;
   /**
    * Create an infinite LazyList by repeatedly applying a function
    * @example
@@ -244,6 +251,190 @@ declare const LazyList: (<A extends Type>(iterable: Iterable<A>) => LazyList<A>)
   cycle: <A extends Type>(iterable: Iterable<A>) => LazyList<A>;
 };
 //#endregion
+//#region src/serialization/error-envelope.d.ts
+/**
+ * Canonical projection of `Error` to JSON, shared by every Serializable type
+ * that carries an `Error` in its failure branch (`Try.Failure`, `Task.Err`,
+ * `Lazy` with a thrown thunk).
+ *
+ * Round-trip guarantees:
+ *  - `err.name` survives (preserves discriminator: `e.name === "TypeError"` works)
+ *  - `err.message` survives
+ *  - `err.stack` survives if present at serialize time
+ *  - `err.cause` survives recursively (arbitrary nesting depth)
+ *
+ * What does NOT survive:
+ *  - `instanceof TypeError` and other subclass identity checks (JSON cannot
+ *    reconstruct user-defined classes without arbitrary code execution).
+ *  - Custom Error-subclass fields (e.g. `HttpError.status`). The generic
+ *    projection doesn't know about them; a future registry mechanism may
+ *    address this.
+ *
+ * Use `e.name` for discriminator checks across the serialization boundary,
+ * not `e instanceof SomeError`.
+ */
+type SerializedError = {
+  readonly name: string;
+  readonly message: string;
+  readonly stack?: string;
+  readonly cause?: SerializedError | string;
+};
+/**
+ * Project an arbitrary thrown value to the canonical SerializedError shape.
+ * Accepts both `Error` instances and non-Error throwables (strings, plain
+ * objects, etc.). Non-Error throwables get `name: "NonErrorThrowable"` and
+ * the best textual representation we can produce.
+ */
+declare const serializeError: (err: unknown) => SerializedError;
+/**
+ * Reconstruct an Error from a SerializedError. The reconstructed Error has
+ * the same `name`, `message`, `stack`, and `cause` chain as the original,
+ * but its prototype is always `Error.prototype` — subclass identity does
+ * not round-trip.
+ *
+ * A `string` is accepted as a shorthand for `{name: "Error", message: <string>}`,
+ * matching what `serializeCause` emits when a `cause` was a bare string.
+ */
+declare const deserializeError: (s: SerializedError | string) => Error;
+//#endregion
+//#region src/serialization/SerializationCompanion.d.ts
+/**
+ * Serialization result containing methods for different formats
+ */
+interface SerializationResult {
+  /** Serializes to JSON string */
+  toJSON: () => string;
+  /** Serializes to YAML string */
+  toYAML: () => string;
+  /** Serializes to base64-encoded binary string */
+  toBinary: () => string;
+}
+/**
+ * The namespaced marker stamped on every functype envelope. Defends against
+ * `_tag` collisions with Effect/fp-ts (which use identical strings like
+ * `"Some"`, `"Left"`, `"Success"`). A value WITHOUT this marker is treated
+ * as "not ours" by `Serialization.deserialize`.
+ *
+ * See `docs/proposals/universal-deserialize-changes.md` Change 0 for the
+ * full rationale.
+ */
+declare const FUNCTYPE_MARKER: "@functype";
+/**
+ * Shape of every functype JSON envelope. The marker identifies the type,
+ * `_tag` (when present) discriminates variants within that type, and the
+ * remaining payload fields are type-specific (`value` for canonical cases,
+ * `error` for failure branches, etc.).
+ */
+type FunctypeEnvelope = {
+  readonly [FUNCTYPE_MARKER]: string;
+  readonly _tag?: string;
+  readonly [key: string]: unknown;
+};
+/**
+ * Build the canonical `{@functype, _tag, value}` envelope OBJECT used by both
+ * the instance `toJSON()` (which returns it directly so native JSON.stringify
+ * can recurse) and the `serialize().toJSON()` method (which stringifies it).
+ *
+ * `_tag` is always emitted — variant-less types pass the same string for
+ * marker and tag (default behavior when tag is omitted). Keeping `_tag`
+ * across the board preserves back-compat for readers that did
+ * `if (parsed._tag === "List")` against 1.1.0 envelopes.
+ *
+ * @param marker - The `@functype` type marker, e.g. `"Either"`, `"Option"`.
+ * @param tag - The variant discriminator, e.g. `"Right"`, `"Some"`. Defaults
+ *              to `marker` for types without variants (List, Map, etc.).
+ * @param value - The payload.
+ */
+declare const envelope: (marker: string, tag: string | undefined, value: unknown) => FunctypeEnvelope;
+/**
+ * Build a non-canonical envelope where the payload doesn't fit the standard
+ * `{value}` shape — e.g. `Try.Failure` carries `{error: SerializedError}`,
+ * `Lazy`-with-thrown-thunk carries the same.
+ *
+ * @param marker - The `@functype` type marker.
+ * @param tag - The variant discriminator (may be the same as marker for
+ *              variant-less types).
+ * @param fields - Additional payload fields merged into the envelope.
+ */
+declare const taggedEnvelope: (marker: string, tag: string, fields: Record<string, unknown>) => FunctypeEnvelope;
+/**
+ * Creates a serializer for the canonical envelope shape, with the `@functype`
+ * marker stamped at the top level (Change 0 of the 1.2.0 universal-deserialize
+ * work). Two forms:
+ *
+ *   createSerializer(marker, value)          // variant-less types (List, Map, …)
+ *   createSerializer(marker, tag, value)     // variants (Either, Option, …)
+ *
+ * Variant-less envelopes are `{"@functype": marker, value}`. Variant envelopes
+ * are `{"@functype": marker, _tag: tag, value}`.
+ */
+declare function createSerializer(marker: string, value: unknown): SerializationResult;
+declare function createSerializer(marker: string, tag: string, value: unknown): SerializationResult;
+/**
+ * Creates a serializer for non-canonical envelopes whose payload doesn't
+ * fit the `{value}` shape — e.g. failure branches that carry a structured
+ * `SerializedError`. The envelope still carries the `@functype` marker
+ * and `_tag` discriminator.
+ *
+ * @param marker - The `@functype` type marker.
+ * @param tag - The variant discriminator.
+ * @param fields - The payload fields (merged after marker + tag).
+ */
+declare const createTaggedSerializer: (marker: string, tag: string, fields: Record<string, unknown>) => SerializationResult;
+/**
+ * @deprecated Use `createTaggedSerializer` instead. Retained for backwards
+ *             compatibility with any external callers; will be removed in a
+ *             future major. The single internal caller (`Try.Failure`) has
+ *             been migrated to `createTaggedSerializer`.
+ *
+ * Creates a serializer for complex objects with custom serialization logic.
+ * Note: this variant does NOT stamp the `@functype` marker — callers must
+ * include it in `data` themselves if they want envelope dispatch to work.
+ */
+declare const createCustomSerializer: (data: Record<string, unknown>) => SerializationResult;
+/**
+ * Generic deserializer from JSON. The `reconstructor` receives the full
+ * parsed envelope including any `@functype` marker; per-type companions
+ * verify the marker matches their expected value.
+ */
+declare const fromJSON: <T>(json: string, reconstructor: (parsed: {
+  _tag?: string;
+  [key: string]: unknown;
+}) => T) => T;
+/**
+ * Generic deserializer from YAML (simple format)
+ * @param yaml - The YAML string to parse
+ * @param reconstructor - Function to reconstruct the type from parsed data
+ * @returns Reconstructed instance
+ */
+declare const fromYAML: <T>(yaml: string, reconstructor: (parsed: {
+  _tag?: string;
+  [key: string]: unknown;
+}) => T) => T;
+/**
+ * Generic deserializer from binary (base64-encoded JSON)
+ * @param binary - The base64-encoded binary string
+ * @param reconstructor - Function to reconstruct the type from parsed data
+ * @returns Reconstructed instance
+ */
+declare const fromBinary: <T>(binary: string, reconstructor: (parsed: {
+  _tag?: string;
+  [key: string]: unknown;
+}) => T) => T;
+/**
+ * Creates companion serialization methods for a type
+ * @param reconstructor - Function to reconstruct the type from parsed data
+ * @returns Companion methods object with fromJSON, fromYAML, and fromBinary
+ */
+declare const createSerializationCompanion: <T>(reconstructor: (parsed: {
+  _tag?: string;
+  [key: string]: unknown;
+}) => T) => {
+  fromJSON: (json: string) => T;
+  fromYAML: (yaml: string) => T;
+  fromBinary: (binary: string) => T;
+};
+//#endregion
 //#region src/typeclass/ContainerOps.d.ts
 /**
  * Universal operations that work on any container (single-value or collection).
@@ -570,6 +761,21 @@ interface Try<out T> extends FunctypeSum<T, TypeNames>, Extractable<T>, Pipe<T>,
     _tag: TypeNames;
     value: T | Error;
   };
+  /**
+   * Custom JSON serialization. Success emits `{"@functype":"Try","_tag":"Success","value":T}`.
+   * Failure emits `{"@functype":"Try","_tag":"Failure","error":SerializedError}` where
+   * SerializedError captures `name`, `message`, `stack`, and the full `cause` chain —
+   * `e.name` survives round-trip but `instanceof SomeError` does not.
+   */
+  toJSON(): {
+    "@functype": "Try";
+    _tag: "Success";
+    value: T;
+  } | {
+    "@functype": "Try";
+    _tag: "Failure";
+    error: SerializedError;
+  };
 }
 declare const Try: (<T>(f: () => T) => Try<T>) & {
   /**
@@ -1422,6 +1628,21 @@ interface TaskOutcome<out T> extends FunctypeBase<T, "Ok" | "Err">, Extractable<
     Ok: (value: T) => U;
     Err: (error: Throwable) => U;
   }) => U;
+  /**
+   * Custom JSON serialization. Ok emits `{"@functype":"Task","_tag":"Ok","value":T}`.
+   * Err emits `{"@functype":"Task","_tag":"Err","error":SerializedError}` capturing the
+   * Throwable's name, message, stack, and cause chain. See error-envelope.ts —
+   * `instanceof` does NOT survive round-trip but `error.name` does.
+   */
+  toJSON(): {
+    "@functype": "Task";
+    _tag: "Ok";
+    value: T;
+  } | {
+    "@functype": "Task";
+    _tag: "Err";
+    error: SerializedError;
+  };
 }
 interface Ok<out T> extends TaskOutcome<T> {
   readonly _tag: "Ok";
@@ -1527,6 +1748,15 @@ declare const Task$1: (<T = unknown>(params?: TaskParams) => {
    * Preferred for new code
    */
   err: <T>(error: unknown, data?: unknown, params?: TaskParams) => Err<T>;
+  /**
+   * Reconstruct a TaskOutcome from a JSON envelope emitted by `serialize().toJSON()`
+   * or instance `toJSON()`. Verifies `@functype === "Task"` and dispatches on `_tag`.
+   *
+   * Err reconstruction goes through `deserializeError` so `name`/`message`/`stack`/`cause`
+   * survive; the resulting Throwable carries the deserialized Error as its underlying
+   * error (subclass identity does NOT round-trip — see error-envelope.ts).
+   */
+  fromJSON: <T>(json: string) => TaskOutcome<T>;
   /**
    * Create TaskOutcome from Either
    * @param either - Either to convert
@@ -3926,13 +4156,39 @@ interface Lazy<out T extends Type> extends FunctypeBase<T, "Lazy">, Extractable<
    */
   toString(): string;
   /**
-   * Converts the Lazy to a value object
-   * @returns Object representation of the Lazy with evaluation state
+   * Converts the Lazy to a value object.
+   *
+   * **Forces the thunk** as a side effect — Lazy serialization (and projection
+   * to a plain value object) cannot represent an unevaluated thunk in JSON;
+   * forcing is the only way to produce a complete projection. If the thunk
+   * threw, the failure is captured in the `error` field (real Error, with
+   * full prototype intact for in-memory inspection — `toJSON` projects to
+   * `SerializedError` for the wire).
+   *
+   * Changed in 1.2.0 — pre-1.2.0 Lazy emitted `{_tag, evaluated, value?}`
+   * without forcing. See `docs/proposals/serializable-audit-q1-q2.md`.
    */
   toValue(): {
     _tag: "Lazy";
-    evaluated: boolean;
-    value?: T;
+    value: T;
+  } | {
+    _tag: "Lazy";
+    error: Error;
+  };
+  /**
+   * Custom JSON serialization. Forces the thunk (see `toValue` for the
+   * side-effect contract). Emits `{"@functype":"Lazy","_tag":"Lazy","value":T}`
+   * on success, or `{"@functype":"Lazy","_tag":"Lazy","error":SerializedError}`
+   * if the thunk threw — see error-envelope.ts for round-trip semantics.
+   */
+  toJSON(): {
+    "@functype": "Lazy";
+    _tag: "Lazy";
+    value: T;
+  } | {
+    "@functype": "Lazy";
+    _tag: "Lazy";
+    error: SerializedError;
   };
 }
 /**
@@ -4018,6 +4274,24 @@ declare const Lazy: (<T extends Type>(thunk: () => T) => Lazy<T>) & {
    * @returns A new Lazy instance that throws the error
    */
   fail: <T extends Type>(error: unknown) => Lazy<T>;
+  /**
+   * Creates an already-evaluated Lazy. Used by `fromJSON` to reconstruct a
+   * Lazy whose thunk was forced at serialize time — there is no original
+   * thunk to defer because a closure cannot be JSON-serialized.
+   *
+   * Functionally equivalent to `Lazy.fromValue` but reads with intent at
+   * the call site.
+   */
+  evaluated: <T extends Type>(value: T) => Lazy<T>;
+  /**
+   * Reconstruct a Lazy from a JSON envelope emitted by `serialize().toJSON()`
+   * or instance `toJSON()`. Verifies `@functype === "Lazy"`. Success envelopes
+   * become already-evaluated Lazies via `Lazy.evaluated`; failure envelopes
+   * become Lazies whose forcing rethrows the deserialized Error (see
+   * error-envelope.ts — `instanceof SomeError` does NOT survive but `name`
+   * does).
+   */
+  fromJSON: <T extends Type>(json: string) => Lazy<T>;
 };
 //#endregion
 //#region src/traversable/Traversable.d.ts
@@ -4422,75 +4696,43 @@ declare const Ref: (<A extends Type>(initial: A) => Ref<A>) & {
    */
   of: <A extends Type>(initial: A) => Ref<A>;
 };
-//#endregion
-//#region src/serialization/SerializationCompanion.d.ts
-/**
- * Serialization result containing methods for different formats
- */
-interface SerializationResult {
-  /** Serializes to JSON string */
-  toJSON: () => string;
-  /** Serializes to YAML string */
-  toYAML: () => string;
-  /** Serializes to base64-encoded binary string */
-  toBinary: () => string;
+declare namespace Serialization_d_exports {
+  export { deserialize, isFunctypeValue, serialize };
 }
 /**
- * Creates a serializer for a simple tagged value
- * @param tag - The type tag (e.g., "Some", "List", "Success")
- * @param value - The value to serialize
- * @returns Serialization methods
- */
-declare const createSerializer: (tag: string, value: unknown) => SerializationResult;
-/**
- * Creates a serializer for complex objects with custom serialization logic
- * @param data - The data object to serialize (should include _tag)
- * @returns Serialization methods
- */
-declare const createCustomSerializer: (data: Record<string, unknown>) => SerializationResult;
-/**
- * Generic deserializer from JSON
- * @param json - The JSON string to parse
- * @param reconstructor - Function to reconstruct the type from parsed data
- * @returns Reconstructed instance
- */
-declare const fromJSON: <T>(json: string, reconstructor: (parsed: {
-  _tag: string;
-  [key: string]: unknown;
-}) => T) => T;
-/**
- * Generic deserializer from YAML (simple format)
- * @param yaml - The YAML string to parse
- * @param reconstructor - Function to reconstruct the type from parsed data
- * @returns Reconstructed instance
+ * Reconstruct any value from a JSON string. Walks the parsed structure and
+ * rebuilds functype envelopes via the dispatch table. Returns a `Try` so
+ * malformed JSON or unknown markers are expressible values rather than
+ * thrown — matches the functype convention for expected-failure paths.
+ *
+ * @example
+ *   const result = Serialization.deserialize('{"@functype":"Either","_tag":"Right","value":5}')
+ *   result.fold(e => console.error(e), v => console.log(v))  // → Right(5)
+ *
+ *   // Plain (non-functype) values pass through:
+ *   Serialization.deserialize('{"name":"alice","age":30}')  // → Success({name, age})
  */
-declare const fromYAML: <T>(yaml: string, reconstructor: (parsed: {
-  _tag: string;
-  [key: string]: unknown;
-}) => T) => T;
+declare const deserialize: (json: string) => Try<unknown>;
 /**
- * Generic deserializer from binary (base64-encoded JSON)
- * @param binary - The base64-encoded binary string
- * @param reconstructor - Function to reconstruct the type from parsed data
- * @returns Reconstructed instance
+ * Serialize any value to a JSON string. Thin convenience over `JSON.stringify`
+ * — functype instances self-stringify via their instance `toJSON()` method,
+ * which emits the `@functype`-marked envelope. Nested functype values
+ * embedded in plain objects/arrays serialize correctly via the standard
+ * JSON.stringify protocol with no walker needed.
+ *
+ * `undefined` is converted to `null` (matching the convention DBOS and
+ * SuperJSON use; `JSON.stringify(undefined)` returns the string `undefined`
+ * which is not valid JSON).
  */
-declare const fromBinary: <T>(binary: string, reconstructor: (parsed: {
-  _tag: string;
-  [key: string]: unknown;
-}) => T) => T;
+declare const serialize: (value: unknown) => string;
 /**
- * Creates companion serialization methods for a type
- * @param reconstructor - Function to reconstruct the type from parsed data
- * @returns Companion methods object with fromJSON, fromYAML, and fromBinary
+ * Runtime guard: is this a live functype Serializable? Checks for the
+ * `serialize()` method plus the `_tag` field that every Serializable instance
+ * carries. Use this when wrapping `serialize`/`deserialize` in a host
+ * serializer that needs to distinguish functype values from foreign data
+ * (e.g. `isApplicable` in a DBOS recipe).
  */
-declare const createSerializationCompanion: <T>(reconstructor: (parsed: {
-  _tag: string;
-  [key: string]: unknown;
-}) => T) => {
-  fromJSON: (json: string) => T;
-  fromYAML: (yaml: string) => T;
-  fromBinary: (binary: string) => T;
-};
+declare const isFunctypeValue: (v: unknown) => v is Serializable<unknown>;
 //#endregion
 //#region src/set/Set.d.ts
 /**
@@ -4841,6 +5083,16 @@ interface Option<out T extends Type> extends Functype<T, "Some" | "None">, Promi
     _tag: "Some" | "None";
     value: T;
   };
+  /**
+   * Custom JSON serialization producing the canonical `@functype`-marked
+   * envelope so native `JSON.stringify` recursion (e.g. inside a plain
+   * object) emits a round-trip-able shape.
+   */
+  toJSON(): {
+    "@functype": "Option";
+    _tag: "Some" | "None";
+    value: T | null;
+  };
   /**
    * Pattern matches over the Option, applying a handler function based on the variant
    * @param patterns - Object with handler functions for Some and None variants
@@ -5205,9 +5457,14 @@ interface EitherBase<out L extends Type, out R extends Type> extends FunctypeSum
     value: L | R;
   };
   /**
-   * Custom JSON serialization that excludes getter properties
+   * Custom JSON serialization that excludes getter properties.
+   * Emits the canonical functype envelope with `@functype: "Either"` so
+   * native `JSON.stringify` recursion (e.g. inside a plain object body)
+   * produces a marker-bearing envelope that survives a round-trip through
+   * `Serialization.deserialize`.
    */
   toJSON(): {
+    "@functype": "Either";
     _tag: "Left" | "Right";
     value: L | R;
   };
@@ -5512,4 +5769,4 @@ interface FailureErrorType extends Error {
 }
 declare const FailureError: (cause: Error, message?: string) => FailureErrorType;
 //#endregion
-export { Map$1 as $, ValidatedBrand as $n, ErrorStatus as $t, Collection as A, NAME as An, InterruptedError as At, SerializationResult as B, Companion as Bn, ExitTag as Bt, isRight as C, TaskMetadata as Cn, HttpStatusError as Ct, Functype as D, TaskSuccess as Dn, TestClockTag as Dt, FunctypeSum as E, TaskResult as En, TestClock as Et, Some as F, UntypedMatch as Fn, Layer as Ft, fromJSON as G, IntegerNumber as Gn, TagService as Gt, createSerializationCompanion as H, BoundedString as Hn, ContextServices as Ht, Stack as I, Cond as In, LayerError as It, Obj as J, PatternString as Jn, Validation as Jt, fromYAML as K, NonEmptyString as Kn, FieldValidation as Kt, Valuable as L, CompanionMethods as Ln, LayerInput as Lt, None as M, ThrowableType as Mn, Task as Mt, Option as N, Base as Nn, TimeoutError as Nt, FunctypeBase as O, createCancellationTokenSource as On, TestContext as Ot, OptionConstructor as P, Match as Pn, UIO as Pt, ESMapType as Q, UrlString as Qn, ErrorMessage as Qt, ValuableParams as R, InstanceType as Rn, LayerOutput as Rt, isLeft as S, TaskFailure as Sn, HttpMethod as St, tryCatchAsync as T, TaskParams as Tn, ResponseDecodeError as Tt, createSerializer as U, EmailAddress as Un, HasService as Ut, createCustomSerializer as V, BoundedNumber as Vn, Context as Vt, fromBinary as W, ISO8601Date as Wn, Tag as Wt, MatchableUtils as X, PositiveNumber as Xn, Validator as Xt, Matchable as Y, PositiveInteger as Yn, ValidationRule as Yt, ESMap as Z, UUID as Zn, ErrorCode as Zt, Right as _, Err as _n, Doable as _r, HttpRequestView as _t, EmptyListError as a, TaskErrorInfo as an, reduceWiden as ar, HKT as at, TypeCheckLeft as b, TaggedThrowable as bn, DecodeError as bt, LeftError as c, formatStackTrace as cn, AsyncMonad as cr, OptionKind as ct, isDoCapable as d, DecoderError as dn, CollectionOps as dr, FoldableUtils as dt, TypedError as en, ValidatedBrandCompanion as er, KVTraversable as et, unwrap as f, DecoderErrorComposite as fn, ContainerOps as fr, Http as ft, LeftOf as g, CancellationTokenSource as gn, DoResult as gr, HttpRequestOptions as gt, Left as h, CancellationToken as hn, isExtractable as hr, HttpMethodOptions as ht, DoGenerator as i, ErrorWithTaskInfo as in, reduceRightWiden as ir, EitherKind as it, List as j, Throwable as jn, RIO as jt, FunctypeCollection as k, isTaggedThrowable as kn, IO as kt, LeftErrorType as l, safeStringify as ln, Functor as lr, TryKind as lt, EitherBase as m, Async as mn, Extractable as mr, HttpClientConfig as mt, Do as n, ErrorChainElement as nn, TypeNames as nr, Lazy as nt, FailureError as o, createErrorSerializer as on, Promisable as or, Kind as ot, Either as p, DecoderErrorLeaf as pn, LazyList as pr, HttpClient as pt, Ref as q, NonNegativeNumber as qn, FormValidation as qt, DoAsync as r, ErrorFormatterOptions as rn, Widen as rr, Identity as rt, FailureErrorType as s, formatError as sn, Applicative as sr, ListKind as st, $ as t, TypedErrorContext as tn, Try as tr, Traversable as tt, NoneError as u, Decoder as un, Monad as ur, UniversalContainer as ut, RightOf as v, Ok as vn, ParseError as vr, HttpResponse as vt, tryCatch as w, TaskOutcome as wn, NetworkError as wt, TypeCheckRight as x, Task$1 as xn, HttpError as xt, TestEither as y, Sync as yn, ParseMode as yt, Set as z, isCompanion as zn, Exit as zt };
+export { HKT as $, reduceWiden as $n, TaskErrorInfo as $t, Collection as A, Cond as An, LayerError as At, Serialization_d_exports as B, NonEmptyString as Bn, FieldValidation as Bt, isRight as C, isTaggedThrowable as Cn, Extractable as Cr, IO as Ct, Functype as D, Base as Dn, ParseError as Dr, TimeoutError as Dt, FunctypeSum as E, ThrowableType as En, Doable as Er, Task as Et, Some as F, BoundedNumber as Fn, Context as Ft, ESMap as G, UUID as Gn, ErrorCode as Gt, Obj as H, PatternString as Hn, Validation as Ht, Stack as I, BoundedString as In, ContextServices as It, KVTraversable as J, ValidatedBrandCompanion as Jn, TypedError as Jt, ESMapType as K, UrlString as Kn, ErrorMessage as Kt, Valuable as L, EmailAddress as Ln, HasService as Lt, None as M, InstanceType as Mn, LayerOutput as Mt, Option as N, isCompanion as Nn, Exit as Nt, FunctypeBase as O, Match as On, UIO as Ot, OptionConstructor as P, Companion as Pn, ExitTag as Pt, EitherKind as Q, reduceRightWiden as Qn, ErrorWithTaskInfo as Qt, ValuableParams as R, ISO8601Date as Rn, Tag as Rt, isLeft as S, createCancellationTokenSource as Sn, LazyList as Sr, TestContext as St, tryCatchAsync as T, Throwable as Tn, DoResult as Tr, RIO as Tt, Matchable as U, PositiveInteger as Un, ValidationRule as Ut, Ref as V, NonNegativeNumber as Vn, FormValidation as Vt, MatchableUtils as W, PositiveNumber as Wn, Validator as Wt, Lazy as X, TypeNames as Xn, ErrorChainElement as Xt, Traversable as Y, Try as Yn, TypedErrorContext as Yt, Identity as Z, Widen as Zn, ErrorFormatterOptions as Zt, Right as _, TaskMetadata as _n, fromYAML as _r, HttpStatusError as _t, EmptyListError as a, DecoderError as an, CollectionOps as ar, FoldableUtils as at, TypeCheckLeft as b, TaskResult as bn, deserializeError as br, TestClock as bt, LeftError as c, Async as cn, FunctypeEnvelope as cr, HttpClientConfig as ct, isDoCapable as d, Err as dn, createSerializationCompanion as dr, HttpRequestView as dt, createErrorSerializer as en, Promisable as er, Kind as et, unwrap as f, Ok as fn, createSerializer as fr, HttpResponse as ft, LeftOf as g, TaskFailure as gn, fromJSON as gr, HttpMethod as gt, Left as h, Task$1 as hn, fromBinary as hr, HttpError as ht, DoGenerator as i, Decoder as in, Monad as ir, UniversalContainer as it, List as j, CompanionMethods as jn, LayerInput as jt, FunctypeCollection as k, UntypedMatch as kn, Layer as kt, LeftErrorType as l, CancellationToken as ln, SerializationResult as lr, HttpMethodOptions as lt, EitherBase as m, TaggedThrowable as mn, envelope as mr, DecodeError as mt, Do as n, formatStackTrace as nn, AsyncMonad as nr, OptionKind as nt, FailureError as o, DecoderErrorComposite as on, ContainerOps as or, Http as ot, Either as p, Sync as pn, createTaggedSerializer as pr, ParseMode as pt, Map$1 as q, ValidatedBrand as qn, ErrorStatus as qt, DoAsync as r, safeStringify as rn, Functor as rr, TryKind as rt, FailureErrorType as s, DecoderErrorLeaf as sn, FUNCTYPE_MARKER as sr, HttpClient as st, $ as t, formatError as tn, Applicative as tr, ListKind as tt, NoneError as u, CancellationTokenSource as un, createCustomSerializer as ur, HttpRequestOptions as ut, RightOf as v, TaskOutcome as vn, taggedEnvelope as vr, NetworkError as vt, tryCatch as w, NAME as wn, isExtractable as wr, InterruptedError as wt, TypeCheckRight as x, TaskSuccess as xn, serializeError as xr, TestClockTag as xt, TestEither as y, TaskParams as yn, SerializedError as yr, ResponseDecodeError as yt, Set as z, IntegerNumber as zn, TagService as zt };

package/dist/index.d.ts

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

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

package/dist/list/index.d.ts

@@ -1,2 +1,2 @@
-import { j as List } from "../index-pSswBNzx.js";
+import { j as List } from "../index-DAKubqXO.js";
 export { List };

package/dist/list/index.js

@@ -1 +1 @@
-import{xt as e}from"../src-VwDCJTjC.js";export{e as List};
+import{St as e}from"../src-CONOwKkM.js";export{e as List};

package/dist/map/index.d.ts

@@ -1,2 +1,2 @@
-import { $ as Map } from "../index-pSswBNzx.js";
+import { q as Map } from "../index-DAKubqXO.js";
 export { Map };

package/dist/map/index.js

@@ -1 +1 @@
-import{B as e}from"../src-VwDCJTjC.js";export{e as Map};
+import{V as e}from"../src-CONOwKkM.js";export{e as Map};

package/dist/option/index.d.ts

@@ -1,2 +1,2 @@
-import { F as Some, M as None, N as Option, P as OptionConstructor } from "../index-pSswBNzx.js";
+import { F as Some, M as None, N as Option, P as OptionConstructor } from "../index-DAKubqXO.js";
 export { None, Option, OptionConstructor, Some };

package/dist/option/index.js

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

package/dist/set/index.d.ts

@@ -1,2 +1,2 @@
-import { z as Set } from "../index-pSswBNzx.js";
+import { z as Set } from "../index-DAKubqXO.js";
 export { Set };

package/dist/set/index.js

@@ -1 +1 @@
-import{Dt as e}from"../src-VwDCJTjC.js";export{e as Set};
+import{Ot as e}from"../src-CONOwKkM.js";export{e as Set};