functype 1.2.2 → 1.3.0

package/dist/{index-D6Zlkrnf.d.ts → index-DBYBJg-D.d.ts}

@@ -315,7 +315,7 @@ interface SerializationResult {
  * `"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
+ * See `docs/archive/proposals/universal-deserialize-changes.md` Change 0 for the
  * full rationale.
  */
 declare const FUNCTYPE_MARKER: "@functype";
@@ -434,6 +434,128 @@ declare const createSerializationCompanion: <T>(reconstructor: (parsed: {
   fromYAML: (yaml: string) => T;
   fromBinary: (binary: string) => T;
 };
+declare namespace Serialization_d_exports {
+  export { JSONValue, deserialize, deserializeStrict, fromEnvelope, isFunctypeValue, serialize, toEnvelope };
+}
+/**
+ * The canonical JSON value type — anything `JSON.parse` can return and
+ * anything `JSON.stringify` can accept as input. Used by `toEnvelope` /
+ * `fromEnvelope` to express the contract precisely: the envelope is a
+ * structured JSON shape, not opaque `unknown`. Lets consumers wiring this
+ * API into another structured serializer (SuperJSON, DBOS custom
+ * transformers) slot it in without a cast at the boundary.
+ *
+ * Added in 1.2.2 — `toEnvelope`/`fromEnvelope` previously typed input/output
+ * as `unknown`, which forced a cast at the consumer side.
+ */
+type JSONValue = string | number | boolean | null | JSONValue[] | {
+  [key: string]: JSONValue;
+};
+/**
+ * Reconstruct any value from a JSON string. Lenient codec: walks the parsed
+ * structure and rebuilds any value carrying an `@functype` marker via the
+ * dispatch table; plain JSON without the marker walks through unchanged.
+ * Returns `Try` so malformed JSON or unknown markers are expressible values
+ * rather than thrown — matches the functype convention for expected-failure
+ * paths.
+ *
+ * **Pass-through policy:** valid JSON without an `@functype` marker is
+ * returned verbatim as `Success(value)`; only marker-carrying values are
+ * reconstructed. Only malformed JSON (or an unknown marker) yields `Failure`.
+ * For a strict variant that rejects unmarked input, see `deserializeStrict`.
+ *
+ * @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})
+ *
+ *   // Embedding in another structured serializer (SuperJSON, DBOS)? See
+ *   // `fromEnvelope` — taking a string here forces the consumer through a
+ *   // JSON.stringify shim and SuperJSON re-walks strings character-by-character.
+ */
+declare const deserialize: (json: string) => Try<unknown>;
+/**
+ * Strict variant of `deserialize`: returns `Failure` when the parsed JSON
+ * doesn't carry an `@functype` marker at the top level. Use this at API,
+ * queue, or RPC boundaries where the wire format MUST be a functype value
+ * and pass-through silence would be a bug.
+ *
+ * Implementation note: only the top-level value is checked for the marker.
+ * Nested values inside it follow the same lenient pass-through rules as
+ * `deserialize` — a `Right` containing a plain object still reconstructs
+ * fine, you just can't START with a plain object.
+ *
+ * @example
+ *   Serialization.deserializeStrict('{"@functype":"Option","_tag":"Some","value":1}')  // → Success(Some(1))
+ *   Serialization.deserializeStrict('{"_tag":"Some","value":1}')                       // → Failure
+ *   Serialization.deserializeStrict('42')                                              // → Failure
+ */
+declare const deserializeStrict: (json: string) => Try<unknown>;
+/**
+ * Serialize any value to a JSON string. Lenient codec: thin convenience over
+ * `JSON.stringify` — functype instances self-stringify via their instance
+ * `toJSON()` method (which emits the `@functype`-marked envelope), and
+ * non-functype values pass through as plain JSON. 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 serialize: (value: unknown) => string;
+/**
+ * Serialize a value to a parsed JSON envelope (object/array/primitive) rather
+ * than a string. Use this when nesting functype values inside another
+ * **structured** serializer (SuperJSON / DBOS custom transformers / similar)
+ * whose custom-transformer hook expects JSON values, not strings — passing a
+ * string to such a hook causes the host to re-walk it character-by-character,
+ * destroying the round-trip.
+ *
+ * Equivalent to `JSON.parse(serialize(value))` but exposed as a named entry
+ * point so consumers don't carry the parse/stringify shim.
+ *
+ * Returns `JSONValue` (tightened from `unknown` in 1.2.2) so consumers can
+ * drop the result straight into a host serializer's `serialize` hook without
+ * a boundary cast.
+ *
+ * @example
+ *   // Inside a DBOS custom serialization recipe — zero casts:
+ *   DBOS.registerSerialization({
+ *     name: "functype",
+ *     isApplicable: Serialization.isFunctypeValue,
+ *     serialize:   Serialization.toEnvelope,
+ *     deserialize: (o) => Serialization.fromEnvelope(o).orThrow(),
+ *   })
+ */
+declare const toEnvelope: (value: unknown) => JSONValue;
+/**
+ * Inverse of `toEnvelope`: reconstruct any value from a parsed JSON envelope
+ * (object/array/primitive). Equivalent to `deserialize(JSON.stringify(envelope))`
+ * but skips the stringify/parse roundtrip — the same `revive` walker is
+ * applied directly. Returns `Try` for the same reasons as `deserialize`.
+ *
+ * Pass-through policy matches `deserialize`: a parsed value without an
+ * `@functype` marker is returned verbatim as `Success(value)`.
+ *
+ * Input is `unknown` (intentionally permissive — Postel's law). Host
+ * serializers typically hand the deserialize callback a JSON-shaped value
+ * that they parsed themselves, but their callback typing varies (some are
+ * `JSONValue`, some are `unknown`, some are `any`). Accepting `unknown`
+ * here means the function slots into any host shape without forcing a
+ * cast at the consumer site.
+ */
+declare const fromEnvelope: (envelope: unknown) => Try<unknown>;
+/**
+ * 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 isFunctypeValue: (v: unknown) => v is Serializable<unknown>;
 //#endregion
 //#region src/typeclass/ContainerOps.d.ts
 /**
@@ -2989,6 +3111,67 @@ interface IO<in out R extends Type, out E extends Type, out A extends Type> {
    * @param delayMs - Delay between retries in milliseconds
    */
   retryWithDelay(n: number, delayMs: number): IO<R, E, A>;
+  /**
+   * Retries the effect only while a predicate over the error holds.
+   *
+   * Useful for selective retry policies — e.g. retry HTTP 5xx but not 4xx,
+   * retry network errors but not validation errors. The predicate is evaluated
+   * BEFORE each retry; returning `false` short-circuits and re-fails with the
+   * original error.
+   *
+   * @param opts.n - Maximum number of retry attempts.
+   * @param opts.while - Predicate `(error, attempt) => boolean` (attempt is 1-indexed
+   *   for the first retry; if the predicate returns false, the retry is skipped).
+   * @param opts.delayMs - Optional fixed delay between attempts.
+   *
+   * @example
+   * ```ts
+   * Http.get("/api/users", { decode })
+   *   .retryWhile({
+   *     n: 3,
+   *     while: (e) => e._tag === "HttpStatusError" && e.status >= 500,
+   *     delayMs: 250,
+   *   })
+   * ```
+   */
+  retryWhile(opts: {
+    readonly n: number;
+    readonly while: (error: E, attempt: number) => boolean;
+    readonly delayMs?: number;
+  }): IO<R, E, A>;
+  /**
+   * Retries the effect with exponential backoff and optional full jitter.
+   *
+   * Delay schedule: `min(maxMs, baseMs * factor^(attempt-1))`. With jitter
+   * enabled, the actual delay is `computed * (0.5 + Math.random() * 0.5)`
+   * (full jitter, 50–100% of the computed value) — prevents thundering herd.
+   *
+   * @param opts.n - Maximum number of retry attempts.
+   * @param opts.baseMs - Initial delay before the first retry.
+   * @param opts.maxMs - Cap on per-attempt delay. Defaults to 30_000.
+   * @param opts.factor - Backoff multiplier per attempt. Defaults to 2.
+   * @param opts.jitter - Apply full jitter (50–100% of computed delay). Defaults to true.
+   * @param opts.while - Optional predicate `(error, attempt) => boolean` gating each retry.
+   *
+   * @example
+   * ```ts
+   * const isRetryable = (e: HttpError): boolean =>
+   *   e._tag === "NetworkError" ||
+   *   (e._tag === "HttpStatusError" && (e.status >= 500 || e.status === 429))
+   *
+   * Http.get("/api/users", { decode })
+   *   .retryWithBackoff({ n: 3, baseMs: 250, while: isRetryable })
+   *   .timeout(10_000)
+   * ```
+   */
+  retryWithBackoff(opts: {
+    readonly n: number;
+    readonly baseMs: number;
+    readonly maxMs?: number;
+    readonly factor?: number;
+    readonly jitter?: boolean;
+    readonly while?: (error: E, attempt: number) => boolean;
+  }): IO<R, E, A>;
   /**
    * Sequences two IOs, keeping the second value.
    */
@@ -3712,6 +3895,16 @@ declare const HttpError: {
 //#endregion
 //#region src/fetch/HttpRequest.d.ts
 type ParseMode = "json" | "text" | "blob" | "arrayBuffer" | "raw";
+/**
+ * Typed query-parameter record. Scalar values (string | number | boolean) are
+ * `String()`-coerced; arrays repeat the key (`{ tag: ["a", "b"] }` → `tag=a&tag=b`);
+ * `undefined` and `null` values are dropped (so callers can write
+ * `{ foo: maybe.toNullable() }` without conditionals); special characters are
+ * percent-encoded via `URLSearchParams`.
+ *
+ * Nested objects are not supported (the type prevents them at compile time).
+ */
+type HttpQueryParams = Readonly<Record<string, string | number | boolean | readonly (string | number | boolean)[] | undefined | null>>;
 interface HttpRequestOptions<T = unknown> {
   readonly url: string;
   readonly method: HttpMethod;
@@ -3719,6 +3912,11 @@ interface HttpRequestOptions<T = unknown> {
   readonly body?: unknown;
   readonly signal?: AbortSignal;
   readonly parseAs?: ParseMode;
+  /**
+   * Query-string parameters appended to the URL. Merges with any query string
+   * already present in `url`. See {@link HttpQueryParams} for encoding rules.
+   */
+  readonly params?: HttpQueryParams;
   /**
    * Either-returning response decoder. Returns `Left(DecoderError)` on
    * failure; the framework maps that to `HttpError.DecodeError(cause: DecoderError)`.
@@ -3760,6 +3958,10 @@ interface HttpMethodOptions<T = unknown> {
   /** @deprecated Use `decode` (Either-returning) or an adapter package for throw-pattern validators. */
   readonly validate?: (data: unknown) => T;
   readonly flatten?: boolean;
+  /**
+   * Query-string parameters appended to the URL. See {@link HttpQueryParams}.
+   */
+  readonly params?: HttpQueryParams;
 }
 interface HttpResponse<T> {
   readonly data: T;
@@ -3827,6 +4029,40 @@ interface HttpClientConfig {
    * ```
    */
   readonly beforeRequest?: (request: HttpRequestView) => IO<never, HttpError, HttpRequestView>;
+  /**
+   * Effectful transformer that runs after the response is parsed (and the
+   * decoder, if any, succeeds) but before the IO resolves to the caller.
+   * Returning a failed IO surfaces the error in place of the response.
+   *
+   * **Only runs on the success path.** `HttpStatusError` (non-2xx),
+   * `DecodeError` (validation failure), and `NetworkError` (fetch / abort)
+   * skip this hook and surface directly. For *error*-side observability and
+   * recovery (refresh-on-401, error logging), use `.catchTag(...)` /
+   * `.tapError(...)` at the call site.
+   *
+   * The hook receives `HttpResponse<unknown>` — body shape is opaque here
+   * because hooks are response-shape-agnostic. The per-call decoder narrows
+   * `data` to the typed value before the response reaches the caller, but
+   * the hook itself sees `unknown`.
+   *
+   * @example
+   * ```ts
+   * const api = Http.client({
+   *   baseUrl: "https://api.example.com",
+   *   afterResponse: (response) =>
+   *     IO.succeed(response)
+   *       .tap((r) => logger.info("response", { status: r.status }))
+   *       .map((r) => ({ ...r, headers: redactSensitiveHeaders(r.headers) })),
+   * })
+   *
+   * // Refresh-on-401 is a .catchTag pattern, NOT an afterResponse pattern:
+   * api.get("/me", { decode })
+   *   .catchTag("HttpStatusError", (e) =>
+   *     e.status === 401 ? refreshToken().flatMap(() => api.get("/me", { decode })) : IO.fail(e),
+   *   )
+   * ```
+   */
+  readonly afterResponse?: (response: HttpResponse<unknown>) => IO<never, HttpError, HttpResponse<unknown>>;
 }
 declare const HttpClient: Tag<HttpClientConfig>;
 //#endregion
@@ -4166,7 +4402,7 @@ interface Lazy<out T extends Type> extends FunctypeBase<T, "Lazy">, Extractable<
    * `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`.
+   * without forcing. See `docs/archive/proposals/serializable-audit-q1-q2.md`.
    */
   toValue(): {
     _tag: "Lazy";
@@ -4696,128 +4932,6 @@ declare const Ref: (<A extends Type>(initial: A) => Ref<A>) & {
    */
   of: <A extends Type>(initial: A) => Ref<A>;
 };
-declare namespace Serialization_d_exports {
-  export { JSONValue, deserialize, deserializeStrict, fromEnvelope, isFunctypeValue, serialize, toEnvelope };
-}
-/**
- * The canonical JSON value type — anything `JSON.parse` can return and
- * anything `JSON.stringify` can accept as input. Used by `toEnvelope` /
- * `fromEnvelope` to express the contract precisely: the envelope is a
- * structured JSON shape, not opaque `unknown`. Lets consumers wiring this
- * API into another structured serializer (SuperJSON, DBOS custom
- * transformers) slot it in without a cast at the boundary.
- *
- * Added in 1.2.2 — `toEnvelope`/`fromEnvelope` previously typed input/output
- * as `unknown`, which forced a cast at the consumer side.
- */
-type JSONValue = string | number | boolean | null | JSONValue[] | {
-  [key: string]: JSONValue;
-};
-/**
- * Reconstruct any value from a JSON string. Lenient codec: walks the parsed
- * structure and rebuilds any value carrying an `@functype` marker via the
- * dispatch table; plain JSON without the marker walks through unchanged.
- * Returns `Try` so malformed JSON or unknown markers are expressible values
- * rather than thrown — matches the functype convention for expected-failure
- * paths.
- *
- * **Pass-through policy:** valid JSON without an `@functype` marker is
- * returned verbatim as `Success(value)`; only marker-carrying values are
- * reconstructed. Only malformed JSON (or an unknown marker) yields `Failure`.
- * For a strict variant that rejects unmarked input, see `deserializeStrict`.
- *
- * @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})
- *
- *   // Embedding in another structured serializer (SuperJSON, DBOS)? See
- *   // `fromEnvelope` — taking a string here forces the consumer through a
- *   // JSON.stringify shim and SuperJSON re-walks strings character-by-character.
- */
-declare const deserialize: (json: string) => Try<unknown>;
-/**
- * Strict variant of `deserialize`: returns `Failure` when the parsed JSON
- * doesn't carry an `@functype` marker at the top level. Use this at API,
- * queue, or RPC boundaries where the wire format MUST be a functype value
- * and pass-through silence would be a bug.
- *
- * Implementation note: only the top-level value is checked for the marker.
- * Nested values inside it follow the same lenient pass-through rules as
- * `deserialize` — a `Right` containing a plain object still reconstructs
- * fine, you just can't START with a plain object.
- *
- * @example
- *   Serialization.deserializeStrict('{"@functype":"Option","_tag":"Some","value":1}')  // → Success(Some(1))
- *   Serialization.deserializeStrict('{"_tag":"Some","value":1}')                       // → Failure
- *   Serialization.deserializeStrict('42')                                              // → Failure
- */
-declare const deserializeStrict: (json: string) => Try<unknown>;
-/**
- * Serialize any value to a JSON string. Lenient codec: thin convenience over
- * `JSON.stringify` — functype instances self-stringify via their instance
- * `toJSON()` method (which emits the `@functype`-marked envelope), and
- * non-functype values pass through as plain JSON. 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 serialize: (value: unknown) => string;
-/**
- * Serialize a value to a parsed JSON envelope (object/array/primitive) rather
- * than a string. Use this when nesting functype values inside another
- * **structured** serializer (SuperJSON / DBOS custom transformers / similar)
- * whose custom-transformer hook expects JSON values, not strings — passing a
- * string to such a hook causes the host to re-walk it character-by-character,
- * destroying the round-trip.
- *
- * Equivalent to `JSON.parse(serialize(value))` but exposed as a named entry
- * point so consumers don't carry the parse/stringify shim.
- *
- * Returns `JSONValue` (tightened from `unknown` in 1.2.2) so consumers can
- * drop the result straight into a host serializer's `serialize` hook without
- * a boundary cast.
- *
- * @example
- *   // Inside a DBOS custom serialization recipe — zero casts:
- *   DBOS.registerSerialization({
- *     name: "functype",
- *     isApplicable: Serialization.isFunctypeValue,
- *     serialize:   Serialization.toEnvelope,
- *     deserialize: (o) => Serialization.fromEnvelope(o).orThrow(),
- *   })
- */
-declare const toEnvelope: (value: unknown) => JSONValue;
-/**
- * Inverse of `toEnvelope`: reconstruct any value from a parsed JSON envelope
- * (object/array/primitive). Equivalent to `deserialize(JSON.stringify(envelope))`
- * but skips the stringify/parse roundtrip — the same `revive` walker is
- * applied directly. Returns `Try` for the same reasons as `deserialize`.
- *
- * Pass-through policy matches `deserialize`: a parsed value without an
- * `@functype` marker is returned verbatim as `Success(value)`.
- *
- * Input is `unknown` (intentionally permissive — Postel's law). Host
- * serializers typically hand the deserialize callback a JSON-shaped value
- * that they parsed themselves, but their callback typing varies (some are
- * `JSONValue`, some are `unknown`, some are `any`). Accepting `unknown`
- * here means the function slots into any host shape without forcing a
- * cast at the consumer site.
- */
-declare const fromEnvelope: (envelope: unknown) => Try<unknown>;
-/**
- * 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 isFunctypeValue: (v: unknown) => v is Serializable<unknown>;
 //#endregion
 //#region src/set/Set.d.ts
 /**
@@ -5854,4 +5968,4 @@ interface FailureErrorType extends Error {
 }
 declare const FailureError: (cause: Error, message?: string) => FailureErrorType;
 //#endregion
-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 };
+export { Kind as $, reduceWiden as $n, TaskErrorInfo as $t, Collection as A, Cond as An, LayerError as At, Ref as B, NonEmptyString as Bn, FieldValidation as Bt, isRight as C, isTaggedThrowable as Cn, serializeError as Cr, IO as Ct, Functype as D, Base as Dn, DoResult as Dr, TimeoutError as Dt, FunctypeSum as E, ThrowableType as En, isExtractable as Er, Task as Et, Some as F, BoundedNumber as Fn, Context as Ft, ESMapType as G, UUID as Gn, ErrorCode as Gt, Matchable as H, PatternString as Hn, Validation as Ht, Stack as I, BoundedString as In, ContextServices as It, Traversable as J, ValidatedBrandCompanion as Jn, TypedError as Jt, Map$1 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, Doable as Or, UIO as Ot, OptionConstructor as P, Companion as Pn, ExitTag as Pt, HKT as Q, reduceRightWiden as Qn, ErrorWithTaskInfo as Qt, ValuableParams as R, ISO8601Date as Rn, Tag as Rt, isLeft as S, createCancellationTokenSource as Sn, deserializeError as Sr, TestContext as St, tryCatchAsync as T, Throwable as Tn, Extractable as Tr, RIO as Tt, MatchableUtils as U, PositiveInteger as Un, ValidationRule as Ut, Obj as V, NonNegativeNumber as Vn, FormValidation as Vt, ESMap as W, PositiveNumber as Wn, Validator as Wt, Identity as X, TypeNames as Xn, ErrorChainElement as Xt, Lazy as Y, Try as Yn, TypedErrorContext as Yt, EitherKind as Z, Widen as Zn, ErrorFormatterOptions as Zt, Right as _, TaskMetadata as _n, fromBinary as _r, HttpStatusError as _t, EmptyListError as a, DecoderError as an, CollectionOps as ar, Http as at, TypeCheckLeft as b, TaskResult as bn, taggedEnvelope as br, TestClock as bt, LeftError as c, Async as cn, Serialization_d_exports as cr, HttpMethodOptions as ct, isDoCapable as d, Err as dn, SerializationResult as dr, HttpRequestView as dt, createErrorSerializer as en, Promisable as er, ListKind as et, unwrap as f, Ok as fn, createCustomSerializer as fr, HttpResponse as ft, LeftOf as g, TaskFailure as gn, envelope as gr, HttpMethod as gt, Left as h, Task$1 as hn, createTaggedSerializer as hr, HttpError as ht, DoGenerator as i, Decoder as in, Monad as ir, FoldableUtils as it, List as j, CompanionMethods as jn, LayerInput as jt, FunctypeCollection as k, UntypedMatch as kn, ParseError as kr, Layer as kt, LeftErrorType as l, CancellationToken as ln, FUNCTYPE_MARKER as lr, HttpQueryParams as lt, EitherBase as m, TaggedThrowable as mn, createSerializer as mr, DecodeError as mt, Do as n, formatStackTrace as nn, AsyncMonad as nr, TryKind as nt, FailureError as o, DecoderErrorComposite as on, ContainerOps as or, HttpClient as ot, Either as p, Sync as pn, createSerializationCompanion as pr, ParseMode as pt, KVTraversable as q, ValidatedBrand as qn, ErrorStatus as qt, DoAsync as r, safeStringify as rn, Functor as rr, UniversalContainer as rt, FailureErrorType as s, DecoderErrorLeaf as sn, JSONValue as sr, HttpClientConfig as st, $ as t, formatError as tn, Applicative as tr, OptionKind as tt, NoneError as u, CancellationTokenSource as un, FunctypeEnvelope as ur, HttpRequestOptions as ut, RightOf as v, TaskOutcome as vn, fromJSON as vr, NetworkError as vt, tryCatch as w, NAME as wn, LazyList as wr, InterruptedError as wt, TypeCheckRight as x, TaskSuccess as xn, SerializedError as xr, TestClockTag as xt, TestEither as y, TaskParams as yn, fromYAML as yr, ResponseDecodeError as yt, Set as z, IntegerNumber as zn, TagService as zt };

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 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 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-D6Zlkrnf.js";
+import { $ as Kind, $n as reduceWiden, $t as TaskErrorInfo, A as Collection, An as Cond, At as LayerError, B as Ref, Bn as NonEmptyString, Bt as FieldValidation, C as isRight, Cn as isTaggedThrowable, Cr as serializeError, Ct as IO, D as Functype, Dn as Base, Dr as DoResult, Dt as TimeoutError, E as FunctypeSum, En as ThrowableType, Er as isExtractable, Et as Task, F as Some, Fn as BoundedNumber, Ft as Context, G as ESMapType, Gn as UUID, Gt as ErrorCode, H as Matchable, Hn as PatternString, Ht as Validation, I as Stack, In as BoundedString, It as ContextServices, J as Traversable, Jn as ValidatedBrandCompanion, Jt as TypedError, K as Map, 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, Or as Doable, Ot as UIO, P as OptionConstructor, Pn as Companion, Pt as ExitTag, Q as HKT, Qn as reduceRightWiden, Qt as ErrorWithTaskInfo, R as ValuableParams, Rn as ISO8601Date, Rt as Tag, S as isLeft, Sn as createCancellationTokenSource, Sr as deserializeError, St as TestContext, T as tryCatchAsync, Tn as Throwable, Tr as Extractable, Tt as RIO, U as MatchableUtils, Un as PositiveInteger, Ut as ValidationRule, V as Obj, Vn as NonNegativeNumber, Vt as FormValidation, W as ESMap, Wn as PositiveNumber, Wt as Validator, X as Identity, Xn as TypeNames, Xt as ErrorChainElement, Y as Lazy, Yn as Try, Yt as TypedErrorContext, Z as EitherKind, Zn as Widen, Zt as ErrorFormatterOptions, _ as Right, _n as TaskMetadata, _r as fromBinary, _t as HttpStatusError, a as EmptyListError, an as DecoderError, ar as CollectionOps, at as Http, b as TypeCheckLeft, bn as TaskResult, br as taggedEnvelope, bt as TestClock, c as LeftError, cn as Async, cr as Serialization_d_exports, ct as HttpMethodOptions, d as isDoCapable, dn as Err, dr as SerializationResult, dt as HttpRequestView, en as createErrorSerializer, er as Promisable, et as ListKind, f as unwrap, fn as Ok, fr as createCustomSerializer, ft as HttpResponse, g as LeftOf, gn as TaskFailure, gr as envelope, gt as HttpMethod, h as Left, hn as Task$1, hr as createTaggedSerializer, ht as HttpError, i as DoGenerator, in as Decoder, ir as Monad, it as FoldableUtils, j as List, jn as CompanionMethods, jt as LayerInput, k as FunctypeCollection, kn as UntypedMatch, kr as ParseError, kt as Layer, l as LeftErrorType, ln as CancellationToken, lr as FUNCTYPE_MARKER, lt as HttpQueryParams, m as EitherBase, mn as TaggedThrowable, mr as createSerializer, mt as DecodeError, n as Do, nn as formatStackTrace, nr as AsyncMonad, nt as TryKind, o as FailureError, on as DecoderErrorComposite, or as ContainerOps, ot as HttpClient, p as Either, pn as Sync, pr as createSerializationCompanion, pt as ParseMode, q as KVTraversable, qn as ValidatedBrand, qt as ErrorStatus, r as DoAsync, rn as safeStringify, rr as Functor, rt as UniversalContainer, s as FailureErrorType, sn as DecoderErrorLeaf, sr as JSONValue, st as HttpClientConfig, t as $, tn as formatError, tr as Applicative, tt as OptionKind, u as NoneError, un as CancellationTokenSource, ur as FunctypeEnvelope, ut as HttpRequestOptions, v as RightOf, vn as TaskOutcome, vr as fromJSON, vt as NetworkError, w as tryCatch, wn as NAME, wr as LazyList, wt as InterruptedError, x as TypeCheckRight, xn as TaskSuccess, xr as SerializedError, xt as TestClockTag, y as TestEither, yn as TaskParams, yr as fromYAML, yt as ResponseDecodeError, z as Set, zn as IntegerNumber, zt as TagService } from "./index-DBYBJg-D.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 };
+import { t as Logger } from "./Logger-75yEf2wp.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, 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, 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,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-D3v1n1vv.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};
+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{a as s,c,d as l,i as u,l as d,n as f,o as p,p as m,r as h,s as g,t as _,u as v}from"./Tuple-knEoDiKZ.js";import{$ as y,A as b,At as x,B as S,C,Ct as w,D as T,Dt as E,E as D,Et as O,F as k,Ft as A,G as j,H as M,I as N,It as P,J as F,K as I,L,Lt as R,M as z,Mt as B,N as V,Nt as H,O as U,Ot as W,P as G,Pt as K,Q as q,R as J,S as Y,St as X,T as Z,Tt as Q,U as $,V as ee,W as te,X as ne,Y as re,Z as ie,_ as ae,_t as oe,a as se,at as ce,b as le,bt as ue,c as de,ct as fe,d as pe,dt as me,et as he,f as ge,ft as _e,g as ve,gt as ye,h as be,ht as xe,i as Se,it as Ce,j as we,jt as Te,k as Ee,kt as De,l as Oe,lt as ke,m as Ae,mt as je,n as Me,nt as Ne,o as Pe,ot as Fe,p as Ie,pt as Le,q as Re,r as ze,rt as Be,s as Ve,st as He,t as Ue,tt as We,u as Ge,ut as Ke,v as qe,vt as Je,w as Ye,wt as Xe,x as Ze,xt as Qe,y as $e,yt as et,z as tt}from"./src-P2lgP6cJ.js";export{we as $,ie as Base,We as BoundedNumber,Ne as BoundedString,e as Brand,t as BrandedBoolean,n as BrandedNumber,r as BrandedString,m as Companion,y as Cond,Y as Context,S as Decoder,ee as DecoderError,z as Do,V as DoAsync,$ as ESMap,je as Either,Be as EmailAddress,G as EmptyListError,te as Err,Ze as Exit,f as FUNCTYPE_MARKER,k as FailureError,Oe as FoldableUtils,de as HKT,Ge as Http,ge as HttpClient,pe as HttpErrors,qe as IO,Ce as ISO8601Date,Ve as Identity,ce as IntegerNumber,$e as InterruptedError,ae as Layer,Pe as Lazy,E as LazyList,xe as Left,N as LeftError,w as List,M as Map,q as Match,se as MatchableUtils,re as NAME,Fe as NonEmptyString,He as NonNegativeNumber,B as None,L as NoneError,Se as Obj,j as Ok,H as Option,K as OptionConstructor,D as ParseError,fe as PatternString,ke as PositiveInteger,Ke as PositiveNumber,W as Ref,ye as Right,Me as Serialization,De as Set,A as Some,ze as Stack,ve as Tag,I as Task,Ie as TestClock,Ae as TestClockTag,be as TestContext,ne as Throwable,le as TimeoutError,O as Try,_ as Tuple,oe as TypeCheckLeft,Je as TypeCheckRight,Xe as Typeable,Z as TypedError,me as UUID,_e as UrlString,Le as ValidatedBrand,Ye as Validation,Ue as Valuable,i as createBrander,Re as createCancellationTokenSource,h as createCustomSerializer,T as createErrorSerializer,u as createSerializationCompanion,s as createSerializer,p as createTaggedSerializer,P as deserializeError,g as envelope,U as formatError,Ee as formatStackTrace,c as fromBinary,d as fromJSON,v as fromYAML,a as hasBrand,he as isCompanion,J as isDoCapable,C as isExtractable,et as isLeft,ue as isRight,F as isTaggedThrowable,Q as isTypeable,x as reduceRightWiden,Te as reduceWiden,b as safeStringify,R as serializeError,l as taggedEnvelope,Qe as tryCatch,X as tryCatchAsync,tt as unwrap,o as unwrapBrand};

package/dist/list/index.d.ts

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

package/dist/list/index.js

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

package/dist/logger/index.d.ts

@@ -0,0 +1,2 @@
+import { t as Logger } from "../Logger-75yEf2wp.js";
+export { Logger };

package/dist/map/index.d.ts

@@ -1,2 +1,2 @@
-import { q as Map } from "../index-D6Zlkrnf.js";
+import { K as Map } from "../index-DBYBJg-D.js";
 export { Map };

package/dist/map/index.js

@@ -1 +1 @@
-import{V as e}from"../src-D3v1n1vv.js";export{e as Map};
+import{H as e}from"../src-P2lgP6cJ.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-D6Zlkrnf.js";
+import { F as Some, M as None, N as Option, P as OptionConstructor } from "../index-DBYBJg-D.js";
 export { None, Option, OptionConstructor, Some };

package/dist/option/index.js

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

package/dist/set/index.d.ts

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

package/dist/set/index.js

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