@nicolastoulemont/std 0.8.2 → 0.10.0

package/dist/{index-C4DOLLaU.d.mts → index-B3xia3Jl.d.mts}

@@ -1,61 +1,15 @@
-import { a as FxError, c as FxTypeId, d as FxYieldable, f as RunnableFx, h as isServiceRequest, i as Fx, l as FxValue, m as SyncFx, n as AsyncFxGenerator, o as FxGenerator, p as ServiceRequest, r as AsyncFxYieldable, s as FxRequirements, t as AsyncFx, u as FxYield } from "./fx.types-BdN1EWxr.mjs";
-import { a as ResultFromTry, m as Ok, p as Err, t as Result } from "./result.types-BKzChyWY.mjs";
-import { r as Option } from "./option.types-D9hrKcfa.mjs";
+import { a as FxError, c as FxTypeId, d as FxYieldable, f as RunnableFx, h as isServiceRequest, i as Fx, l as FxValue, m as SyncFx, n as AsyncFxGenerator, o as FxGenerator, p as ServiceRequest, r as AsyncFxYieldable, s as FxRequirements, t as AsyncFx, u as FxYield } from "./fx.types-CpFKa-Jj.mjs";
+import { a as ResultFromTry, t as Result } from "./result.types-CnhiVFEV.mjs";
+import { r as Option } from "./option.types-DLp3QpFE.mjs";
+import { t as Exit } from "./exit-DOdhmr81.mjs";
+import { n as RuntimeFiber, r as runFork$1 } from "./fx.runtime-BuIElLpZ.mjs";
 import { t as Concurrency } from "./queue.types-B-l5XYbU.mjs";
-import { n as SyncRetrySchedule, t as RetrySchedule } from "./schedule-D2651VJY.mjs";
+import { n as SyncRetrySchedule, t as RetrySchedule } from "./schedule-DiidMLcl.mjs";
+import { t as FxGenOptions } from "./trace-D_7sjH22.mjs";
 
-//#region src/fx/exit.d.ts
-/**
- * Represents an unexpected thrown exception (defect) caught during Fx execution.
- */
-type Defect = {
-  readonly _tag: "Defect";
-  readonly defect: unknown;
-};
-/**
- * Exit represents the outcome of an Fx computation.
- * A flat 3-variant discriminated union that cleanly separates:
- * - `Ok<A>`: successful result with value of type A
- * - `Err<E>`: typed failure with error of type E
- * - `Defect`: unexpected thrown exception (defect)
- *
- * @example
- * ```ts
- * const exit = Fx.run(computation)
- * switch (exit._tag) {
- *   case "Ok":      exit.value    // A
- *   case "Err":     exit.error    // E (clean!)
- *   case "Defect":  exit.defect   // unknown
- * }
- * ```
- */
-type Exit<A$1, E$1> = Ok<A$1> | Err<E$1> | Defect;
-/**
- * Handler functions for Exit.match.
- */
-type ExitMatch<A$1, E$1, R$1> = {
-  readonly Ok: (value: A$1) => R$1;
-  readonly Err: (error: E$1) => R$1;
-  readonly Defect: (defect: unknown) => R$1;
-};
-/**
- * Exit namespace containing all Exit utilities.
- */
-declare const Exit: {
-  readonly ok: <A$1>(value: A$1) => Ok<A$1>;
-  readonly err: <E$1>(error: E$1) => Err<E$1>;
-  readonly defect: (thrown: unknown) => Defect;
-  readonly isOk: <A$1, E$1>(exit: Exit<A$1, E$1>) => exit is Ok<A$1>;
-  readonly isErr: <A$1, E$1>(exit: Exit<A$1, E$1>) => exit is Err<E$1>;
-  readonly isDefect: <A$1, E$1>(exit: Exit<A$1, E$1>) => exit is Defect;
-  readonly match: {
-    <A$1, E$1, R$1>(exit: Exit<A$1, E$1>, handlers: ExitMatch<A$1, E$1, R$1>): R$1;
-    <A$1, E$1, R$1>(handlers: ExitMatch<A$1, E$1, R$1>): (exit: Exit<A$1, E$1>) => R$1;
-  };
-  readonly getOrThrow: <A$1, E$1>(exit: Exit<A$1, E$1>) => A$1;
-};
+//#region src/fx/fx.d.ts
 declare namespace fx_d_exports {
-  export { AsyncFx, AsyncFxGenerator, AsyncFxYieldable, Exit, Fx, FxError, FxGenerator, FxRequirements, FxTypeId, FxValue, FxYield, FxYieldable, RunnableFx, ServiceRequest, SyncFx, TaggedMatch, err, fn, forEach, gen, isServiceRequest, match, ok, option, retry, run, try_ as try };
+  export { AsyncFx, AsyncFxGenerator, AsyncFxYieldable, Exit, Fx, FxError, FxGenerator, FxRequirements, FxTypeId, FxValue, FxYield, FxYieldable, RunnableFx, ServiceRequest, SyncFx, TaggedMatch, err, fn, forEach, forkChild, forkDetach, gen, isServiceRequest, match, ok, option, retry, run, runFork, try_ as try, yieldNow };
 }
 /**
  * Execute a sync Fx computation and return the Exit.
@@ -111,6 +65,8 @@ type FxGenRequirements<Yielded> = Yielded extends Fx<unknown, unknown, infer R>
  * ```
  */
 declare function fxGen<Yielded, A$1>(generatorFn: () => Generator<Yielded, A$1, unknown>): SyncFx<A$1, FxGenError<Yielded>, FxGenRequirements<Yielded>>;
+declare function fxGen<Yielded, A$1>(spanName: string, generatorFn: () => Generator<Yielded, A$1, unknown>): SyncFx<A$1, FxGenError<Yielded>, FxGenRequirements<Yielded>>;
+declare function fxGen<Yielded, A$1>(options: FxGenOptions, generatorFn: () => Generator<Yielded, A$1, unknown>): SyncFx<A$1, FxGenError<Yielded>, FxGenRequirements<Yielded>>;
 /**
  * Create a composable computation from an async generator function.
  * Returns an AsyncFx that can be stored, passed around, and executed later.
@@ -135,6 +91,8 @@ declare function fxGen<Yielded, A$1>(generatorFn: () => Generator<Yielded, A$1,
  * ```
  */
 declare function fxGen<Yielded, A$1>(generatorFn: () => AsyncGenerator<Yielded, A$1, unknown>): AsyncFx<A$1, FxGenError<Yielded>, FxGenRequirements<Yielded>>;
+declare function fxGen<Yielded, A$1>(spanName: string, generatorFn: () => AsyncGenerator<Yielded, A$1, unknown>): AsyncFx<A$1, FxGenError<Yielded>, FxGenRequirements<Yielded>>;
+declare function fxGen<Yielded, A$1>(options: FxGenOptions, generatorFn: () => AsyncGenerator<Yielded, A$1, unknown>): AsyncFx<A$1, FxGenError<Yielded>, FxGenRequirements<Yielded>>;
 /**
  * Create a composable computation from a sync generator function that takes parameters.
  * Returns a factory function that, when called with parameters, produces a SyncFx.
@@ -159,6 +117,8 @@ declare function fxGen<Yielded, A$1>(generatorFn: () => AsyncGenerator<Yielded,
  * ```
  */
 declare function fxGen<P extends [unknown, ...unknown[]], Yielded, A$1>(generatorFn: (...params: P) => Generator<Yielded, A$1, unknown>): (...params: P) => SyncFx<A$1, FxGenError<Yielded>, FxGenRequirements<Yielded>>;
+declare function fxGen<P extends [unknown, ...unknown[]], Yielded, A$1>(spanName: string, generatorFn: (...params: P) => Generator<Yielded, A$1, unknown>): (...params: P) => SyncFx<A$1, FxGenError<Yielded>, FxGenRequirements<Yielded>>;
+declare function fxGen<P extends [unknown, ...unknown[]], Yielded, A$1>(options: FxGenOptions<P>, generatorFn: (...params: P) => Generator<Yielded, A$1, unknown>): (...params: P) => SyncFx<A$1, FxGenError<Yielded>, FxGenRequirements<Yielded>>;
 /**
  * Create a composable computation from an async generator function that takes parameters.
  * Returns a factory function that, when called with parameters, produces an AsyncFx.
@@ -184,6 +144,8 @@ declare function fxGen<P extends [unknown, ...unknown[]], Yielded, A$1>(generato
  * ```
  */
 declare function fxGen<P extends [unknown, ...unknown[]], Yielded, A$1>(generatorFn: (...params: P) => AsyncGenerator<Yielded, A$1, unknown>): (...params: P) => AsyncFx<A$1, FxGenError<Yielded>, FxGenRequirements<Yielded>>;
+declare function fxGen<P extends [unknown, ...unknown[]], Yielded, A$1>(spanName: string, generatorFn: (...params: P) => AsyncGenerator<Yielded, A$1, unknown>): (...params: P) => AsyncFx<A$1, FxGenError<Yielded>, FxGenRequirements<Yielded>>;
+declare function fxGen<P extends [unknown, ...unknown[]], Yielded, A$1>(options: FxGenOptions<P>, generatorFn: (...params: P) => AsyncGenerator<Yielded, A$1, unknown>): (...params: P) => AsyncFx<A$1, FxGenError<Yielded>, FxGenRequirements<Yielded>>;
 type FxRunResult<F extends RunnableFx<unknown, unknown, unknown>> = F extends AsyncFx<infer A, infer E, unknown> ? Promise<Exit<A, E>> : F extends SyncFx<infer A, infer E, unknown> ? Exit<A, E> : never;
 /**
  * Execute a sync computation immediately and return the Exit.
@@ -208,6 +170,8 @@ type FxRunResult<F extends RunnableFx<unknown, unknown, unknown>> = F extends As
  * ```
  */
 declare function fxFn<A$1, E$1>(generatorFn: () => FxGenerator<A$1, E$1, never>): Exit<A$1, E$1>;
+declare function fxFn<A$1, E$1>(spanName: string, generatorFn: () => FxGenerator<A$1, E$1, never>): Exit<A$1, E$1>;
+declare function fxFn<A$1, E$1>(options: FxGenOptions, generatorFn: () => FxGenerator<A$1, E$1, never>): Exit<A$1, E$1>;
 /**
  * Execute an async computation immediately and return a Promise of the Exit.
  * Catches unexpected thrown exceptions and wraps them as Defect.
@@ -230,6 +194,8 @@ declare function fxFn<A$1, E$1>(generatorFn: () => FxGenerator<A$1, E$1, never>)
  * ```
  */
 declare function fxFn<A$1, E$1>(generatorFn: () => AsyncFxGenerator<A$1, E$1, never>): Promise<Exit<A$1, E$1>>;
+declare function fxFn<A$1, E$1>(spanName: string, generatorFn: () => AsyncFxGenerator<A$1, E$1, never>): Promise<Exit<A$1, E$1>>;
+declare function fxFn<A$1, E$1>(options: FxGenOptions, generatorFn: () => AsyncFxGenerator<A$1, E$1, never>): Promise<Exit<A$1, E$1>>;
 /**
  * Execute a sync computation with service dependencies immediately.
  * Catches unexpected thrown exceptions and wraps them as Defect.
@@ -256,6 +222,8 @@ declare function fxFn<A$1, E$1>(generatorFn: () => AsyncFxGenerator<A$1, E$1, ne
  * ```
  */
 declare function fxFn<A$1, E$1, R$1, ProvidedFx extends RunnableFx<unknown, unknown, unknown>>(generatorFn: () => FxGenerator<A$1, E$1, R$1>, provider: (fx: SyncFx<A$1, E$1, R$1>) => ProvidedFx): FxRunResult<ProvidedFx>;
+declare function fxFn<A$1, E$1, R$1, ProvidedFx extends RunnableFx<unknown, unknown, unknown>>(spanName: string, generatorFn: () => FxGenerator<A$1, E$1, R$1>, provider: (fx: SyncFx<A$1, E$1, R$1>) => ProvidedFx): FxRunResult<ProvidedFx>;
+declare function fxFn<A$1, E$1, R$1, ProvidedFx extends RunnableFx<unknown, unknown, unknown>>(options: FxGenOptions, generatorFn: () => FxGenerator<A$1, E$1, R$1>, provider: (fx: SyncFx<A$1, E$1, R$1>) => ProvidedFx): FxRunResult<ProvidedFx>;
 /**
  * Execute an async computation with service dependencies immediately.
  * Catches unexpected thrown exceptions and wraps them as Defect.
@@ -283,6 +251,8 @@ declare function fxFn<A$1, E$1, R$1, ProvidedFx extends RunnableFx<unknown, unkn
  * ```
  */
 declare function fxFn<A$1, E$1, R$1, ProvidedFx extends RunnableFx<unknown, unknown, unknown>>(generatorFn: () => AsyncFxGenerator<A$1, E$1, R$1>, provider: (fx: AsyncFx<A$1, E$1, R$1>) => ProvidedFx): FxRunResult<ProvidedFx>;
+declare function fxFn<A$1, E$1, R$1, ProvidedFx extends RunnableFx<unknown, unknown, unknown>>(spanName: string, generatorFn: () => AsyncFxGenerator<A$1, E$1, R$1>, provider: (fx: AsyncFx<A$1, E$1, R$1>) => ProvidedFx): FxRunResult<ProvidedFx>;
+declare function fxFn<A$1, E$1, R$1, ProvidedFx extends RunnableFx<unknown, unknown, unknown>>(options: FxGenOptions, generatorFn: () => AsyncFxGenerator<A$1, E$1, R$1>, provider: (fx: AsyncFx<A$1, E$1, R$1>) => ProvidedFx): FxRunResult<ProvidedFx>;
 /**
  * Handler functions for matching on a tagged union by `_tag` discriminator.
  * Each handler receives the narrowed variant corresponding to its tag key.
@@ -296,9 +266,13 @@ declare function fxFn<A$1, E$1, R$1, ProvidedFx extends RunnableFx<unknown, unkn
  */
 type TaggedMatch<T extends {
   readonly _tag: string;
-}, R$1> = { readonly [K in T["_tag"]]: (variant: Extract<T, {
+}, R$1> = { readonly [K in Exclude<T["_tag"], "Interrupted">]: (variant: Extract<T, {
   readonly _tag: K;
-}>) => R$1 };
+}>) => R$1 } & {
+  readonly Interrupted?: (variant: Extract<T, {
+    readonly _tag: "Interrupted";
+  }>) => R$1;
+};
 /**
  * Build typed computations from generator functions.
  *
@@ -343,6 +317,56 @@ declare const fn: typeof fxFn;
  * ```
  */
 declare const run: typeof fxRun;
+/**
+ * Start an Fx on a new root fiber and return its handle immediately.
+ *
+ * @example
+ * ```ts
+ * const fiber = Fx.runFork(Fx.gen(async function* () {
+ *   yield* Fx.yieldNow()
+ *   return 1
+ * }))
+ * const exit = await fiber.await()
+ * // => { _tag: "Ok", value: 1 }
+ * ```
+ */
+declare const runFork: typeof runFork$1;
+/**
+ * Fork a child fiber owned by the current fiber.
+ *
+ * @example
+ * ```ts
+ * const child = yield* Fx.forkChild(Fx.gen(async function* () {
+ *   yield* Fx.yieldNow()
+ *   return 1
+ * }))
+ * // => Fiber.Fiber<number, never>
+ * ```
+ */
+declare const forkChild: <A$1, E$1, R$1>(fx: RunnableFx<A$1, E$1, R$1>) => AsyncFx<RuntimeFiber<A$1, E$1>>;
+/**
+ * Fork a detached fiber that snapshots the current runtime state.
+ *
+ * @example
+ * ```ts
+ * const fiber = yield* Fx.forkDetach(Fx.gen(async function* () {
+ *   yield* Fx.yieldNow()
+ *   return 1
+ * }))
+ * // => Fiber.Fiber<number, never>
+ * ```
+ */
+declare const forkDetach: <A$1, E$1, R$1>(fx: RunnableFx<A$1, E$1, R$1>) => AsyncFx<RuntimeFiber<A$1, E$1>>;
+/**
+ * Cooperatively yield to the runtime and observe pending interruption.
+ *
+ * @example
+ * ```ts
+ * yield* Fx.yieldNow()
+ * // => AsyncFx<void>
+ * ```
+ */
+declare const yieldNow: () => AsyncFx<void>;
 /**
  * Retry failed computations according to a schedule.
  *
@@ -455,4 +479,4 @@ declare const match: {
 };
 //#endregion
 export { fx_d_exports as t };
-//# sourceMappingURL=index-C4DOLLaU.d.mts.map
+//# sourceMappingURL=index-B3xia3Jl.d.mts.map

package/dist/index-B3xia3Jl.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-B3xia3Jl.d.mts","names":[],"sources":["../src/fx/fx.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/{index-CIvNgjsx.d.mts → index-B4rHoUK4.d.mts}

@@ -1,4 +1,4 @@
-import { a as ResultFromTry, c as ResultMatch, d as ResultUnwrapOr, f as ResultUnwrapOrElse, i as ResultFlatMap, l as ResultOrElse, n as ResultAll, o as ResultMap, r as ResultFilter, s as ResultMapErr, t as Result$1, u as ResultTap } from "./result.types-BKzChyWY.mjs";
+import { a as ResultFromTry, c as ResultMatch, d as ResultUnwrapOr, f as ResultUnwrapOrElse, i as ResultFlatMap, l as ResultOrElse, n as ResultAll, o as ResultMap, r as ResultFilter, s as ResultMapErr, t as Result$1, u as ResultTap } from "./result.types-CnhiVFEV.mjs";
 
 //#region src/result/result.d.ts
 declare namespace result_d_exports {
@@ -370,4 +370,4 @@ declare const fromTry: ResultFromTry;
 declare const try_: ResultFromTry;
 //#endregion
 export { result_d_exports as n, Result as t };
-//# sourceMappingURL=index-CIvNgjsx.d.mts.map
+//# sourceMappingURL=index-B4rHoUK4.d.mts.map

package/dist/{index-CIvNgjsx.d.mts.map → index-B4rHoUK4.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-CIvNgjsx.d.mts","names":[],"sources":["../src/result/result.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;KA0DY,eAAe,SAAW,GAAG;;;;;;;;;;;;AAAzC;;;AAA2B,cAsBd,EAtBc,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EAsBE,CAtBF,EAAA,GAsBM,QAtBN,CAsBiB,CAtBjB,EAAA,KAAA,CAAA;;AAsB3B;;;;;AAgCA;;;;;AAoCA;;;AAAmC,cApCtB,GAoCsB,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EApCL,CAoCK,EAAA,GApCD,QAoCC,CAAA,KAAA,EApCiB,CAoCjB,CAAA;;;;;;AAiBnC;;;;;;;;;AAmCa,cApDA,IAoDK,EAAA,CAAA,CAAA,EAAA,CAOhB,CAAA,CAAA,MAAA,EA3DiC,QA2DjC,CA3D4C,CA2D5C,EA3D+C,CA2D/C,CAAA,EAAA,GAAA,MAAA,IA3D8D,OA2D9D,CA3DsE,QA2DtE,CA3DiF,CA2DjF,EA3DoF,CA2DpF,CAAA,EAAA;EA+BW,IAAA,EAAA,IAOX;AA+BF,CAAA,CAAA;AAsCA;AAsCA;AA6BA;AAmCA;AAgDA;AA2BA;AAiCA;AA8BA;AA0BC;;;;;;cA/ZY,sBAAuB,SAAW,GAAG,iBAAe,QAAQ,SAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmC1E,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCR,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCT,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BR,QAAQ;;;;;;;;;;;;;;;;;;;cAmCR,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;cAgDL,UAAU;;;;;;;;;;;;;;;;;;;;;;;cA2BV,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiCd,OAAO;;;;;;;;;;;;;;;;;;;;cA8BP,SAAS;cA6BhB,MAAI"}
+{"version":3,"file":"index-B4rHoUK4.d.mts","names":[],"sources":["../src/result/result.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;KA0DY,eAAe,SAAW,GAAG;;;;;;;;;;;;AAAzC;;;AAA2B,cAsBd,EAtBc,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EAsBE,CAtBF,EAAA,GAsBM,QAtBN,CAsBiB,CAtBjB,EAAA,KAAA,CAAA;;AAsB3B;;;;;AAgCA;;;;;AAoCA;;;AAAmC,cApCtB,GAoCsB,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EApCL,CAoCK,EAAA,GApCD,QAoCC,CAAA,KAAA,EApCiB,CAoCjB,CAAA;;;;;;AAiBnC;;;;;;;;;AAmCa,cApDA,IAoDK,EAAA,CAAA,CAAA,EAAA,CAOhB,CAAA,CAAA,MAAA,EA3DiC,QA2DjC,CA3D4C,CA2D5C,EA3D+C,CA2D/C,CAAA,EAAA,GAAA,MAAA,IA3D8D,OA2D9D,CA3DsE,QA2DtE,CA3DiF,CA2DjF,EA3DoF,CA2DpF,CAAA,EAAA;EA+BW,IAAA,EAAA,IAOX;AA+BF,CAAA,CAAA;AAsCA;AAsCA;AA6BA;AAmCA;AAgDA;AA2BA;AAiCA;AA8BA;AA0BC;;;;;;cA/ZY,sBAAuB,SAAW,GAAG,iBAAe,QAAQ,SAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmC1E,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCR,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCT,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BR,QAAQ;;;;;;;;;;;;;;;;;;;cAmCR,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;cAgDL,UAAU;;;;;;;;;;;;;;;;;;;;;;;cA2BV,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiCd,OAAO;;;;;;;;;;;;;;;;;;;;cA8BP,SAAS;cA6BhB,MAAI"}

package/dist/{index-BA0EsFxS.d.mts → index-BDUhDs4D.d.mts}

@@ -1,5 +1,5 @@
-import { t as Result } from "./result.types-BKzChyWY.mjs";
-import { i as Validator, n as Branded$1, r as Unbrand, t as BrandError$1 } from "./brand.types-B3NDX1vo.mjs";
+import { t as Result } from "./result.types-CnhiVFEV.mjs";
+import { i as Validator, n as Branded$1, r as Unbrand, t as BrandError$1 } from "./brand.types-C_7QgCA4.mjs";
 
 //#region src/brand/brand.d.ts
 declare namespace brand_d_exports {
@@ -112,4 +112,4 @@ declare const is: <T, K extends string>(validator: Validator<T>) => ((value: T)
 declare const refine: <B extends Branded<unknown, string>>(validator: Validator<Unbrand<B>>, errorMessage?: string | ((value: Unbrand<B>) => string)) => ((value: Unbrand<B>) => Result<B, BrandError<Unbrand<B>>>);
 //#endregion
 export { brand_d_exports as t };
-//# sourceMappingURL=index-BA0EsFxS.d.mts.map
+//# sourceMappingURL=index-BDUhDs4D.d.mts.map

package/dist/{index-BA0EsFxS.d.mts.map → index-BDUhDs4D.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-BA0EsFxS.d.mts","names":[],"sources":["../src/brand/brand.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;KA4CY,+BAA+B,UAAY,GAAG;AAA1D;;;;;AAYA;AAyBA;;;;AAA6E,KAzBjE,UAyBiE,CAAA,CAAA,CAAA,GAzBjD,YAyBiD,CAzBlC,CAyBkC,CAAA;;AAsB7E;;;;;;AAuBA;;;;;;;;AAyBA;;;;;;AAEmC,cAxEtB,IAwEsB,EAAA,CAAA,UAxEJ,OAwEI,CAAA,OAAA,EAAA,MAAA,CAAA,CAAA,CAAA,KAAA,EAxE6B,OAwE7B,CAxEqC,CAwErC,CAAA,EAAA,GAxE0C,CAwE1C;;;;;;;;;;;;;;;;;;;cAlDtB,uBAAwB,iCAAiC,QAAQ,OAAK;;;;;;;;;;;;;;;;;;;;cAuBtE,qCAAsC,UAAU,gBAAc,eAAe,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;cAyBxF,mBAAoB,qCACpB,UAAU,QAAQ,sCACI,QAAQ,4BAC/B,QAAQ,OAAO,OAAW,GAAG,WAAW,QAAQ"}
+{"version":3,"file":"index-BDUhDs4D.d.mts","names":[],"sources":["../src/brand/brand.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;KA4CY,+BAA+B,UAAY,GAAG;AAA1D;;;;;AAYA;AAyBA;;;;AAA6E,KAzBjE,UAyBiE,CAAA,CAAA,CAAA,GAzBjD,YAyBiD,CAzBlC,CAyBkC,CAAA;;AAsB7E;;;;;;AAuBA;;;;;;;;AAyBA;;;;;;AAEmC,cAxEtB,IAwEsB,EAAA,CAAA,UAxEJ,OAwEI,CAAA,OAAA,EAAA,MAAA,CAAA,CAAA,CAAA,KAAA,EAxE6B,OAwE7B,CAxEqC,CAwErC,CAAA,EAAA,GAxE0C,CAwE1C;;;;;;;;;;;;;;;;;;;cAlDtB,uBAAwB,iCAAiC,QAAQ,OAAK;;;;;;;;;;;;;;;;;;;;cAuBtE,qCAAsC,UAAU,gBAAc,eAAe,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;cAyBxF,mBAAoB,qCACpB,UAAU,QAAQ,sCACI,QAAQ,4BAC/B,QAAQ,OAAO,OAAW,GAAG,WAAW,QAAQ"}

package/dist/{index-CNTYbcY9.d.mts → index-BZ1-IrU_.d.mts}

@@ -218,4 +218,4 @@ declare const constant: <T>(value: boolean) => Predicate<T>;
 declare const equals: <T>(expected: T) => Predicate<T>;
 //#endregion
 export { predicate_d_exports as t };
-//# sourceMappingURL=index-CNTYbcY9.d.mts.map
+//# sourceMappingURL=index-BZ1-IrU_.d.mts.map

package/dist/{index-CNTYbcY9.d.mts.map → index-BZ1-IrU_.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-CNTYbcY9.d.mts","names":[],"sources":["../src/predicate/predicate.types.ts","../src/predicate/predicate.ts"],"sourcesContent":[],"mappings":";;;;AAKA;AAqBA;AAA2C,KArB/B,SAqB+B,CAAA,IAAA,CAAA,GAAA,CAAA,KAAA,EArBL,CAqBK,EAAA,GAAA,OAAA;;;;;;;;;;;;;;;;;;;ACP3C;AAAgD,KDOpC,UCPoC,CAAA,IAAA,EAAA,cDOL,CCPK,CAAA,GAAA,CAAA,KAAA,EDOQ,CCPR,EAAA,GAAA,KAAA,IDOuB,CCPvB;AAAA;;;;;ADdhD;AAqBA;;;;;;;;;;;;;;cCPa,oBAAqB,UAAc,OAAK,UAAc;;;;;;AAAnE;;;;;;AAsBA;;;;;;AA2BA;AAA4D,cA3B/C,GA2B+C,EAAA,CAAA,CAAA,CAAA,CAAA,GAAA,UAAA,EAAA,SA3Bb,SA2Ba,CA3BC,CA2BD,CAAA,EAAA,EAAA,GA3BQ,SA2BR,CA3BsB,CA2BtB,CAAA;;;;;AA0B5D;;;;;;AAqBA;;;;;;AAsBA;;AAAmC,cArEtB,EAqEsB,EAAA,CAAA,CAAA,CAAA,CAAA,GAAA,UAAA,EAAA,SArEW,SAqEX,CArEyB,CAqEzB,CAAA,EAAA,EAAA,GArEgC,SAqEhC,CArE8C,CAqE9C,CAAA;;;;AAwBnC;;;;;;;;;AA6BA;;;;;AAAsG,cAhGzF,GAgGyF,EAAA,CAAA,CAAA,CAAA,CAAA,SAAA,EAhGpE,SAgGoE,CAhGtD,CAgGsD,CAAA,EAAA,GAhGjD,SAgGiD,CAAA,SAhG1B,CAgG0B,EAAA,CAAA;;;;AA0BtG;AAoBA;;;;;;;;;;;;;cAzHa,qBAAsB,UAAc,OAAK,mBAAuB;;;;;;;;;;;;;;;;;;;cAsBhE,qBAAsB,UAAc,OAAK,mBAAuB;;;;;;;;;;;;;;;;;;;;;cAwBhE,6BAA8B,4BAA4B,WAAW,GAAG,SAAO,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;cA6B7F,4BAA6B,4BAA4B,WAAW,GAAG,SAAO,WAAW,GAAG;;;;;;;;;;;;;;;;;;cA0B5F,iCAAgC,UAAc;;;;;;;;;;;;;;;;;cAoB9C,sBAAuB,MAAI,UAAc"}
+{"version":3,"file":"index-BZ1-IrU_.d.mts","names":[],"sources":["../src/predicate/predicate.types.ts","../src/predicate/predicate.ts"],"sourcesContent":[],"mappings":";;;;AAKA;AAqBA;AAA2C,KArB/B,SAqB+B,CAAA,IAAA,CAAA,GAAA,CAAA,KAAA,EArBL,CAqBK,EAAA,GAAA,OAAA;;;;;;;;;;;;;;;;;;;ACP3C;AAAgD,KDOpC,UCPoC,CAAA,IAAA,EAAA,cDOL,CCPK,CAAA,GAAA,CAAA,KAAA,EDOQ,CCPR,EAAA,GAAA,KAAA,IDOuB,CCPvB;AAAA;;;;;ADdhD;AAqBA;;;;;;;;;;;;;;cCPa,oBAAqB,UAAc,OAAK,UAAc;;;;;;AAAnE;;;;;;AAsBA;;;;;;AA2BA;AAA4D,cA3B/C,GA2B+C,EAAA,CAAA,CAAA,CAAA,CAAA,GAAA,UAAA,EAAA,SA3Bb,SA2Ba,CA3BC,CA2BD,CAAA,EAAA,EAAA,GA3BQ,SA2BR,CA3BsB,CA2BtB,CAAA;;;;;AA0B5D;;;;;;AAqBA;;;;;;AAsBA;;AAAmC,cArEtB,EAqEsB,EAAA,CAAA,CAAA,CAAA,CAAA,GAAA,UAAA,EAAA,SArEW,SAqEX,CArEyB,CAqEzB,CAAA,EAAA,EAAA,GArEgC,SAqEhC,CArE8C,CAqE9C,CAAA;;;;AAwBnC;;;;;;;;;AA6BA;;;;;AAAsG,cAhGzF,GAgGyF,EAAA,CAAA,CAAA,CAAA,CAAA,SAAA,EAhGpE,SAgGoE,CAhGtD,CAgGsD,CAAA,EAAA,GAhGjD,SAgGiD,CAAA,SAhG1B,CAgG0B,EAAA,CAAA;;;;AA0BtG;AAoBA;;;;;;;;;;;;;cAzHa,qBAAsB,UAAc,OAAK,mBAAuB;;;;;;;;;;;;;;;;;;;cAsBhE,qBAAsB,UAAc,OAAK,mBAAuB;;;;;;;;;;;;;;;;;;;;;cAwBhE,6BAA8B,4BAA4B,WAAW,GAAG,SAAO,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;cA6B7F,4BAA6B,4BAA4B,WAAW,GAAG,SAAO,WAAW,GAAG;;;;;;;;;;;;;;;;;;cA0B5F,iCAAgC,UAAc;;;;;;;;;;;;;;;;;cAoB9C,sBAAuB,MAAI,UAAc"}

package/dist/{index-uE3S3Krx.d.mts → index-BZP6t2h9.d.mts}

@@ -1,7 +1,7 @@
-import { f as RunnableFx, m as SyncFx, t as AsyncFx } from "./fx.types-BdN1EWxr.mjs";
-import { t as ServiceClass } from "./service-D8mr0wwg.mjs";
-import { n as ScopeService, t as ExcludeScope } from "./scope-CuM3CzwG.mjs";
-import { a as UnprovidedDeps, i as MergeROut, n as Layer, r as MergeError, t as AllSync } from "./layer.types-BB0MrvLg.mjs";
+import { f as RunnableFx, m as SyncFx, t as AsyncFx } from "./fx.types-CpFKa-Jj.mjs";
+import { t as ServiceClass } from "./service-C4xUfS_M.mjs";
+import { n as ScopeService, t as ExcludeScope } from "./scope-7bLTmdRX.mjs";
+import { a as UnprovidedDeps, i as MergeROut, n as Layer, r as MergeError, t as AllSync } from "./layer.types-DsCTjICW.mjs";
 
 //#region src/layer/layer.d.ts
 declare namespace layer_d_exports {
@@ -242,4 +242,4 @@ declare const provide: typeof layerProvide;
 declare const merge: typeof layerMerge;
 //#endregion
 export { layer_d_exports as t };
-//# sourceMappingURL=index-uE3S3Krx.d.mts.map
+//# sourceMappingURL=index-BZP6t2h9.d.mts.map

package/dist/{index-uE3S3Krx.d.mts.map → index-BZP6t2h9.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-uE3S3Krx.d.mts","names":[],"sources":["../src/layer/layer.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index-BZP6t2h9.d.mts","names":[],"sources":["../src/layer/layer.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAwCuG;;;;;;;;;;iBAuE9F,OACsB,CAAA,CAAA,CAAA,CAAA,OAAA,EADF,YACE,CADW,CACX,CAAA,CAAA,EAAA;EACV,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EADR,MACQ,CADD,CACC,EADE,CACF,EADK,CACL,CAAA,CAAA,EADU,KACV,CADoB,CACpB,EADuB,CACvB,EAD0B,CAC1B,EAAA,IAAA,CAAA;EAAG,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAX,OAAW,CAAH,CAAG,EAAA,CAAA,EAAG,CAAH,CAAA,CAAA,EAAQ,KAAR,CAAkB,CAAlB,EAAqB,CAArB,EAAwB,CAAxB,EAAA,KAAA,CAAA;EAAG,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EACd,UADc,CACH,CADG,EACA,CADA,EACG,CADH,CAAA,CAAA,EACQ,KADR,CACkB,CADlB,EACqB,CADrB,EACwB,CADxB,CAAA;CAAd;;;;;;;;;;;;;;AAC+B;;;;;;;;;;;;;;;iBAgFnC,WAEkB,CAAA,CAAA,CAAA,CAAA,OAAA,EAFM,YAEN,CAFmB,CAEnB,CAAA,CAAA,EAAA;EAAI,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EADlB,MACkB,CADX,CACW,EADR,CACQ,EADL,CACK,GADD,YACC,CAAA,CAAA,EADe,KACf,CADyB,CACzB,EAD4B,CAC5B,EAD+B,YAC/B,CAD4C,CAC5C,CAAA,EAAA,IAAA,CAAA;EAAlB,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,OAAA,CAAQ,CAAR,EAAW,CAAX,EAAc,CAAd,GAAkB,YAAlB,CAAA,CAAA,EAAkC,KAAlC,CAA4C,CAA5C,EAA+C,CAA/C,EAAkD,YAAlD,CAA+D,CAA/D,CAAA,EAAA,KAAA,CAAA;EAA4C,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAC5C,UAD4C,CACjC,CADiC,EAC9B,CAD8B,EAC3B,CAD2B,GACvB,YADuB,CAAA,CAAA,EACP,KADO,CACG,CADH,EACM,CADN,EACS,YADT,CACsB,CADtB,CAAA,CAAA;CAAG;;;;;;;;;;;;;;;AACD;;;;;;;;;iBA4FlD,YAIqB,CAAA,QAAA,EAAA,KAAA,EAAA,OAAA,EAAA,iBAAA,OAAA,CAAA,CAAA,IAAA,EAHtB,KAGsB,CAHZ,QAGY,EAHF,KAGE,EAHK,OAGL,EAHc,QAGd,CAAA,CAAA,EAAA;EAAK,CAAA,IAAA,EAAA,CAAA,EAAA,YADX,QACW,EAAA,kBAAA,OAAA,CAAA,CAAA,KAAA,EAAxB,KAAwB,CAAd,IAAc,EAAR,CAAQ,EAAL,GAAK,EAAA,SAAA,CAAA,CAAA,EAC9B,KAD8B,CACpB,IADoB,GACb,QADa,EACH,CADG,GACC,KADD,EACQ,OADR,EACiB,SADjB,SAAA,IAAA,GAC0C,QAD1C,GAAA,KAAA,CAAA;CAAxB;;;;;;;;;;AACG;;;;;;;;;;;;;AA4Ld;iBAtFS,UA7ViC,CAAA,UA6VZ,KA7VY,CAAA,OAAA,EAAA,OAAA,EAAA,OAAA,CAAA,EAAA,CAAA,CAAA,GAAA,MAAA,EA8V7B,CA9V6B,CAAA,EA+VvC,KA/VuC,CA+V7B,SA/V6B,CA+VnB,CA/VmB,CAAA,EA+Vf,UA/Ve,CA+VJ,CA/VI,CAAA,EA+VA,cA/VA,CA+Ve,CA/Vf,CAAA,EA+VmB,OA/VnB,CA+V2B,CA/V3B,CAAA,CAAA;;;;;;AAmc1C;;;;;AAoBA;AA6BA;AAwBA;AAwBA;;cAjHa,iBAnbgB,aAAa,UAAU,MAAI,MAAU;;;;;;;;;;;;;;;cAmcrD,gBA5ae,MAAI,aAAiB;;;;;;;;;;;;;;;;;;;cAgcpC,WAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BF,eAAM;;;;;;;;;;;;;;;;;;;;;;;cAwBN,gBAAO;;;;;;;;;;;;;;;;;;;;;;;cAwBP,cAAK"}

package/dist/{index-D8rDE60Y.d.mts → index-Bu-z5Xoq.d.mts}

@@ -456,4 +456,4 @@ declare const sortWith: {
 declare const sortBy: <A>(...orders: readonly Order$1<A>[]) => (input: Iterable<A>) => A[];
 //#endregion
 export { order_d_exports as t };
-//# sourceMappingURL=index-D8rDE60Y.d.mts.map
+//# sourceMappingURL=index-Bu-z5Xoq.d.mts.map

package/dist/index-Bu-z5Xoq.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Bu-z5Xoq.d.mts","names":[],"sources":["../src/order/order.types.ts","../src/order/order.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index-C8KMi_I9.d.mts

@@ -0,0 +1,226 @@
+import { f as RunnableFx, m as SyncFx } from "./fx.types-CpFKa-Jj.mjs";
+import { n as Layer } from "./layer.types-DsCTjICW.mjs";
+
+//#region src/log/log.d.ts
+declare namespace log_d_exports {
+  export { ContextualLogger, Event, Fields, Level, Logger, console, context, emit, json, layer, withFields, withSpan };
+}
+/**
+ * Supported log event levels.
+ *
+ * @example
+ * ```ts
+ * import type { Log } from "@nicolastoulemont/std"
+ *
+ * const level: Log.Level = "info"
+ * ```
+ */
+type Level = "debug" | "info" | "warn" | "error";
+/**
+ * Structured fields attached to log events.
+ *
+ * @example
+ * ```ts
+ * import type { Log } from "@nicolastoulemont/std"
+ *
+ * const fields: Log.Fields = { requestId: "req_1" }
+ * ```
+ */
+type Fields = Record<string, unknown>;
+/**
+ * Concrete event delivered to installed logger backends.
+ *
+ * Events include merged contextual fields, active log spans, trace correlation
+ * when a current span exists, and the current fiber id.
+ *
+ * @example
+ * ```ts
+ * import type { Log } from "@nicolastoulemont/std"
+ *
+ * const logger: Log.Logger = {
+ *   log: (event) => {
+ *     globalThis.console.log(event.level, event.message, event.fields)
+ *   },
+ * }
+ * ```
+ */
+type Event = {
+  readonly timestamp: Date;
+  readonly level: Level;
+  readonly message: string;
+  readonly fields: Fields;
+  readonly logSpans: ReadonlyArray<{
+    readonly label: string;
+    readonly elapsedMs: number;
+  }>;
+  readonly trace: {
+    readonly traceId: string;
+    readonly spanId: string;
+    readonly spanName: string;
+  } | undefined;
+  readonly fiberId: number | undefined;
+};
+/**
+ * Logger backend installed through `Log.layer`.
+ *
+ * @example
+ * ```ts
+ * import type { Log } from "@nicolastoulemont/std"
+ *
+ * const events: Log.Event[] = []
+ * const logger: Log.Logger = { log: (event) => events.push(event) }
+ * ```
+ */
+type Logger = {
+  readonly log: (event: Event) => void;
+};
+/**
+ * Logger returned by `Log.context`.
+ *
+ * @example
+ * ```ts
+ * import { Fx, Log } from "@nicolastoulemont/std"
+ *
+ * const program = Fx.gen(function* () {
+ *   const log = yield* Log.context({ requestId: "req_1" })
+ *   yield* log.info("request received")
+ * })
+ * ```
+ */
+type ContextualLogger = {
+  readonly debug: (message: string, fields?: Fields) => SyncFx<void>;
+  readonly info: (message: string, fields?: Fields) => SyncFx<void>;
+  readonly warn: (message: string, fields?: Fields) => SyncFx<void>;
+  readonly error: (message: string, fields?: Fields) => SyncFx<void>;
+};
+type LogContextOptions = {
+  readonly logSpan?: string;
+};
+/**
+ * Emit one log event at the given level.
+ *
+ * The event is delivered to every logger installed in the current runtime state.
+ * Logger failures are swallowed so logging cannot fail the user program.
+ *
+ * @example
+ * ```ts
+ * import { Fx, Log, Provide } from "@nicolastoulemont/std"
+ *
+ * const program = Provide.layer(Log.layer(Log.console()))(
+ *   Fx.gen(function* () {
+ *     yield* Log.emit("info", "request received", { route: "/orders" })
+ *     return "ok"
+ *   }),
+ * )
+ *
+ * const exit = Fx.run(program)
+ * // => { _tag: "Ok", value: "ok" }
+ * ```
+ */
+declare const emit: (level: Level, message: string, fields?: Fields) => SyncFx<void>;
+/**
+ * Add log fields to the current runtime state and return a contextual logger.
+ *
+ * Fields are inherited by nested effects and merged into later log events.
+ * Passing `logSpan` also adds elapsed-time decoration to later log events.
+ *
+ * @example
+ * ```ts
+ * import { Fx, Log } from "@nicolastoulemont/std"
+ *
+ * const program = Fx.gen(function* () {
+ *   const log = yield* Log.context({ requestId: "req_1" }, { logSpan: "request" })
+ *   yield* log.info("loaded user", { userId: "user_1" })
+ *   return "ok"
+ * })
+ * ```
+ */
+declare const context: (fields: Fields, options?: LogContextOptions) => SyncFx<ContextualLogger>;
+/**
+ * Run an effect with additional log fields.
+ *
+ * @example
+ * ```ts
+ * import { Fx, Log } from "@nicolastoulemont/std"
+ *
+ * const program = Log.withFields({ service: "checkout" })(
+ *   Fx.gen(function* () {
+ *     yield* Log.emit("info", "started")
+ *     return "ok"
+ *   }),
+ * )
+ * ```
+ */
+declare const withFields: (fields: Fields) => <A, E, R>(fx: RunnableFx<A, E, R>) => RunnableFx<A, E, R>;
+/**
+ * Run an effect with an active log span.
+ *
+ * Log spans decorate log events with elapsed time. Use `Trace.span` when you
+ * need a real tracing span.
+ *
+ * @example
+ * ```ts
+ * import { Fx, Log } from "@nicolastoulemont/std"
+ *
+ * const program = Log.withSpan("load-user")(
+ *   Fx.gen(function* () {
+ *     yield* Log.emit("info", "loaded user")
+ *     return "user_1"
+ *   }),
+ * )
+ * ```
+ */
+declare const withSpan: (label: string) => <A, E, R>(fx: RunnableFx<A, E, R>) => RunnableFx<A, E, R>;
+/**
+ * Create a logger backend that writes events to `globalThis.console`.
+ *
+ * @example
+ * ```ts
+ * import { Fx, Log, Provide } from "@nicolastoulemont/std"
+ *
+ * const program = Provide.layer(Log.layer(Log.console()))(
+ *   Fx.gen(function* () {
+ *     yield* Log.emit("info", "hello")
+ *   }),
+ * )
+ * ```
+ */
+declare const console: () => Logger;
+/**
+ * Create a logger backend that writes JSON events to `globalThis.console.log`.
+ *
+ * @example
+ * ```ts
+ * import { Fx, Log, Provide } from "@nicolastoulemont/std"
+ *
+ * const program = Provide.layer(Log.layer(Log.json()))(
+ *   Fx.gen(function* () {
+ *     yield* Log.emit("info", "hello")
+ *   }),
+ * )
+ * ```
+ */
+declare const json: () => Logger;
+/**
+ * Install one or more logger backends in the current Fx runtime.
+ *
+ * @example
+ * ```ts
+ * import { Fx, Log, Provide } from "@nicolastoulemont/std"
+ *
+ * const events: Log.Event[] = []
+ * const program = Provide.layer(Log.layer({ log: (event) => events.push(event) }))(
+ *   Fx.gen(function* () {
+ *     yield* Log.emit("info", "stored")
+ *     return events.length
+ *   }),
+ * )
+ *
+ * const exit = Fx.run(program)
+ * // => { _tag: "Ok", value: 1 }
+ * ```
+ */
+declare const layer: (loggers: Logger | ReadonlyArray<Logger>) => Layer<never, never, never, true>;
+//#endregion
+export { log_d_exports as t };
+//# sourceMappingURL=index-C8KMi_I9.d.mts.map

package/dist/index-C8KMi_I9.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-C8KMi_I9.d.mts","names":[],"sources":["../src/log/log.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;KA6CY,KAAA;;;;;;;AAAZ;AAYA;AAmBA;;AAEkB,KArBN,MAAA,GAAS,MAqBH,CAAA,MAAA,EAAA,OAAA,CAAA;;;;AA4BlB;AAiBA;;;;;;;;;;AAKC;AA+CD;;AAA6D,KAnGjD,KAAA,GAmGiD;EAAS,SAAA,SAAA,EAlGhD,IAkGgD;EAAM,SAAA,KAAA,EAjG1D,KAiG0D;EAmE/D,SAAA,OA4BX,EAAA,MAAA;EA5B8B,SAAA,MAAA,EAlKb,MAkKa;EAAkB,SAAA,QAAA,EAjK7B,aAiK6B,CAAA;IAA2B,SAAA,KAAA,EAAA,MAAA;IAAP,SAAA,SAAA,EAAA,MAAA;EAAM,CAAA,CAAA;EA6C/D,SAAA,KASiB,EAAA;IARnB,SAAA,OAAA,EAAA,MAAA;IACgB,SAAA,MAAA,EAAA,MAAA;IAAG,SAAA,QAAA,EAAA,MAAA;EAAG,CAAA,GAAA,SAAA;EAAjB,SAAA,OAAA,EAAA,MAAA,GAAA,SAAA;CAAiC;;;;;AA2BjD;;;;;;;AAEuD,KApN3C,MAAA,GAoN2C;EAAjB,SAAA,GAAA,EAAA,CAAA,KAAA,EAnNd,KAmNc,EAAA,GAAA,IAAA;CAAU;AA0BhD;AAoBA;AAyBA;;;;;;;;;;;KA1QY,gBAAA;6CACiC,WAAW;4CACZ,WAAW;4CACX,WAAW;6CACV,WAAW;;KAGnD,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;cA6CQ,cAAe,iCAAiC,WAAS;;;;;;;;;;;;;;;;;;cAmEzD,kBAAmB,kBAAkB,sBAAoB,OAAO;;;;;;;;;;;;;;;;cA6ChE,qBACF,yBACK,WAAW,GAAG,GAAG,OAAK,WAAW,GAAG,GAAG;;;;;;;;;;;;;;;;;;;cA2B1C,2CAEG,WAAW,GAAG,GAAG,OAAK,WAAW,GAAG,GAAG;;;;;;;;;;;;;;;cA0B1C,eAAc;;;;;;;;;;;;;;;cAoBd,YAAW;;;;;;;;;;;;;;;;;;;;cAyBX,iBAAkB,SAAS,cAAc,YAAU"}

package/dist/{index-dCRymj_g.d.mts → index-CfXGmPMY.d.mts}

@@ -1,7 +1,7 @@
-import { i as Fx } from "./fx.types-BdN1EWxr.mjs";
-import { t as Pipeable } from "./pipeable-BIrevC0D.mjs";
-import { t as Result } from "./result.types-BKzChyWY.mjs";
-import { r as Option } from "./option.types-D9hrKcfa.mjs";
+import { i as Fx } from "./fx.types-CpFKa-Jj.mjs";
+import { t as Pipeable } from "./pipeable-BY9yPsNK.mjs";
+import { t as Result } from "./result.types-CnhiVFEV.mjs";
+import { r as Option } from "./option.types-DLp3QpFE.mjs";
 
 //#region src/either/either.types.d.ts
 /**
@@ -726,4 +726,4 @@ declare const fromNullable: <R, L>(value: R | null | undefined, onNull: () => L)
 declare const fromPredicate: <R, L>(value: R, predicate: (value: R) => boolean, onFail: (value: R) => L) => Either$1<L, R>;
 //#endregion
 export { either_d_exports as t };
-//# sourceMappingURL=index-dCRymj_g.d.mts.map
+//# sourceMappingURL=index-CfXGmPMY.d.mts.map