functype 0.20.2 → 0.40.0

package/dist/{index-Bnjlo4cT.d.ts → index-Bn_yRBx8.d.ts}

@@ -1,5 +1,5 @@
-import { t as Brand } from "./Brand-B-0nKo7I.js";
-import { c as Pipe, l as Foldable, o as Serializable, r as Typeable, t as Tuple, u as Type } from "./Tuple-CKxIyX7l.js";
+import { t as Brand } from "./Brand-BPeggBaO.js";
+import { c as Pipe, l as Foldable, o as Serializable, r as Typeable, t as Tuple, u as Type } from "./Tuple-C4maYbiO.js";
 
 //#region src/do/protocol.d.ts
 
@@ -11,9 +11,9 @@ import { c as Pipe, l as Foldable, o as Serializable, r as Typeable, t as Tuple,
  * Result type for Do-notation unwrapping
  * Indicates whether unwrapping succeeded and provides the value or error
  */
-type DoResult<T$1> = {
+type DoResult<T> = {
   ok: true;
-  value: T$1;
+  value: T;
 } | {
   ok: false;
   empty: true;
@@ -29,8 +29,8 @@ type DoResult<T$1> = {
  * The doUnwrap method should return a DoResult indicating success/failure
  * and the contained value or error information
  */
-interface Doable<T$1> {
-  doUnwrap(): DoResult<T$1>;
+interface Doable<T> {
+  doUnwrap(): DoResult<T>;
 }
 //#endregion
 //#region src/extractable/Extractable.d.ts
@@ -41,14 +41,14 @@ interface Doable<T$1> {
  * @interface Unsafe
  * @template T The type of value that can be extracted
  */
-interface Unsafe<T$1 extends Type> {
+interface Unsafe<T extends Type> {
   /**
    * Extract the value or throw an error
    * @param error Optional custom error to throw. If not provided, uses type-appropriate default error
    * @throws {Error} The specified error, container's error, or a sensible default
    * @returns The contained value
    */
-  orThrow(error?: Error): T$1;
+  orThrow(error?: Error): T;
 }
 /**
  * Extractable type class for data structures that can extract their values
@@ -59,34 +59,34 @@ interface Unsafe<T$1 extends Type> {
  *
  * Extends Unsafe to provide exception-throwing operations alongside safe alternatives.
  */
-interface Extractable<T$1 extends Type> extends Unsafe<T$1> {
+interface Extractable<T extends Type> extends Unsafe<T> {
   /**
    * Returns the contained value or a default value
    * @param defaultValue - The value to return if extraction fails
    * @returns The contained value or defaultValue
    */
-  orElse(defaultValue: T$1): T$1;
+  orElse(defaultValue: T): T;
   /**
    * Returns this container if it has a value, otherwise returns the alternative container
    * @param alternative - The alternative container
    * @returns This container or the alternative
    */
-  or(alternative: Extractable<T$1>): Extractable<T$1>;
+  or(alternative: Extractable<T>): Extractable<T>;
   /**
    * Returns the contained value or null
    * @returns The contained value or null
    */
-  orNull(): T$1 | null;
+  orNull(): T | null;
   /**
    * Returns the contained value or undefined
    * @returns The contained value or undefined
    */
-  orUndefined(): T$1 | undefined;
+  orUndefined(): T | undefined;
 }
 /**
  * Type guard to check if a value implements Extractable
  */
-declare function isExtractable<T$1 extends Type>(value: unknown): value is Extractable<T$1>;
+declare function isExtractable<T extends Type>(value: unknown): value is Extractable<T>;
 //#endregion
 //#region src/list/LazyList.d.ts
 /**
@@ -372,37 +372,37 @@ interface Promisable<A extends Type> {
  * Possible types of Try instances
  */
 type TypeNames = "Success" | "Failure";
-interface Try<T$1> extends FunctypeBase<T$1, TypeNames>, Extractable<T$1>, Pipe<T$1>, Promisable<T$1>, Doable<T$1>, Reshapeable<T$1> {
+interface Try<T> extends FunctypeBase<T, TypeNames>, Extractable<T>, Pipe<T>, Promisable<T>, Doable<T>, Reshapeable<T> {
   readonly _tag: TypeNames;
   readonly error: Error | undefined;
-  isSuccess(): this is Try<T$1> & {
+  isSuccess(): this is Try<T> & {
     readonly _tag: "Success";
     error: undefined;
   };
-  isFailure(): this is Try<T$1> & {
+  isFailure(): this is Try<T> & {
     readonly _tag: "Failure";
     error: Error;
   };
-  orElse: (defaultValue: T$1) => T$1;
-  orThrow: (error?: Error) => T$1;
-  or: (alternative: Try<T$1>) => Try<T$1>;
-  orNull: () => T$1 | null;
-  orUndefined: () => T$1 | undefined;
-  toOption: () => Option<T$1>;
-  toEither: <E extends Type>(leftValue: E) => Either<E, T$1>;
-  toList: () => List<T$1>;
-  toTry: () => Try<T$1>;
-  map: <U>(f: (value: T$1) => U) => Try<U>;
-  ap: <U>(ff: Try<(value: T$1) => U>) => Try<U>;
-  flatMap: <U>(f: (value: T$1) => Try<U>) => Try<U>;
-  flatMapAsync: <U>(f: (value: T$1) => Promise<Try<U>>) => Promise<Try<U>>;
+  orElse: (defaultValue: T) => T;
+  orThrow: (error?: Error) => T;
+  or: (alternative: Try<T>) => Try<T>;
+  orNull: () => T | null;
+  orUndefined: () => T | undefined;
+  toOption: () => Option<T>;
+  toEither: <E extends Type>(leftValue: E) => Either<E, T>;
+  toList: () => List<T>;
+  toTry: () => Try<T>;
+  map: <U>(f: (value: T) => U) => Try<U>;
+  ap: <U>(ff: Try<(value: T) => U>) => Try<U>;
+  flatMap: <U>(f: (value: T) => Try<U>) => Try<U>;
+  flatMapAsync: <U>(f: (value: T) => Promise<Try<U>>) => Promise<Try<U>>;
   /**
    * Pattern matches over the Try, applying onFailure if Failure and onSuccess if Success
    * @param onFailure - Function to apply if the Try is Failure
    * @param onSuccess - Function to apply if the Try is Success
    * @returns The result of applying the appropriate function
    */
-  fold: <U extends Type>(onFailure: (error: Error) => U, onSuccess: (value: T$1) => U) => U;
+  fold: <U extends Type>(onFailure: (error: Error) => U, onSuccess: (value: T) => U) => U;
   toString: () => string;
   /**
    * Pattern matches over the Try, applying a handler function based on the variant
@@ -410,21 +410,21 @@ interface Try<T$1> extends FunctypeBase<T$1, TypeNames>, Extractable<T$1>, Pipe<
    * @returns The result of applying the matching handler function
    */
   match<R$1>(patterns: {
-    Success: (value: T$1) => R$1;
+    Success: (value: T) => R$1;
     Failure: (error: Error) => R$1;
   }): R$1;
   toValue(): {
     _tag: TypeNames;
-    value: T$1 | Error;
+    value: T | Error;
   };
 }
-declare const Try: (<T$1>(f: () => T$1) => Try<T$1>) & {
+declare const Try: (<T>(f: () => T) => Try<T>) & {
   /**
    * Type guard to check if a Try is Success
    * @param tryValue - The Try to check
    * @returns True if Try is Success
    */
-  isSuccess: <T$1>(tryValue: Try<T$1>) => tryValue is Try<T$1> & {
+  isSuccess: <T>(tryValue: Try<T>) => tryValue is Try<T> & {
     readonly _tag: "Success";
     error: undefined;
   };
@@ -433,7 +433,7 @@ declare const Try: (<T$1>(f: () => T$1) => Try<T$1>) & {
    * @param tryValue - The Try to check
    * @returns True if Try is Failure
    */
-  isFailure: <T$1>(tryValue: Try<T$1>) => tryValue is Try<T$1> & {
+  isFailure: <T>(tryValue: Try<T>) => tryValue is Try<T> & {
     readonly _tag: "Failure";
     error: Error;
   };
@@ -442,19 +442,19 @@ declare const Try: (<T$1>(f: () => T$1) => Try<T$1>) & {
    * @param json - The JSON string
    * @returns Try instance
    */
-  fromJSON: <T$1>(json: string) => Try<T$1>;
+  fromJSON: <T>(json: string) => Try<T>;
   /**
    * Creates a Try from YAML string
    * @param yaml - The YAML string
    * @returns Try instance
    */
-  fromYAML: <T$1>(yaml: string) => Try<T$1>;
+  fromYAML: <T>(yaml: string) => Try<T>;
   /**
    * Creates a Try from binary string
    * @param binary - The binary string
    * @returns Try instance
    */
-  fromBinary: <T$1>(binary: string) => Try<T$1>;
+  fromBinary: <T>(binary: string) => Try<T>;
 };
 //#endregion
 //#region src/reshapeable/Reshapeable.d.ts
@@ -491,7 +491,7 @@ declare const Try: (<T$1>(f: () => T$1) => Try<T$1>) & {
  * const asOption = result.toOption()
  * asOption.map(x => x * 2).orElse(0)
  */
-interface Reshapeable<T$1 extends Type> {
+interface Reshapeable<T extends Type> {
   /**
    * Converts this monad to an Option.
    *
@@ -503,7 +503,7 @@ interface Reshapeable<T$1 extends Type> {
    *
    * @returns An Option containing the value if present, None otherwise
    */
-  toOption(): Option<T$1>;
+  toOption(): Option<T>;
   /**
    * Converts this monad to an Either.
    *
@@ -516,7 +516,7 @@ interface Reshapeable<T$1 extends Type> {
    * @param leftValue - The value to use for the Left case when the source is empty/none/failure
    * @returns An Either with the value as Right or the provided leftValue as Left
    */
-  toEither<E extends Type>(leftValue: E): Either<E, T$1>;
+  toEither<E extends Type>(leftValue: E): Either<E, T>;
   /**
    * Converts this monad to a List.
    *
@@ -528,7 +528,7 @@ interface Reshapeable<T$1 extends Type> {
    *
    * @returns A List containing the value(s) if present, empty List otherwise
    */
-  toList(): List<T$1>;
+  toList(): List<T>;
   /**
    * Converts this monad to a Try.
    *
@@ -540,22 +540,22 @@ interface Reshapeable<T$1 extends Type> {
    *
    * @returns A Try containing Success with the value or Failure with an appropriate error
    */
-  toTry(): Try<T$1>;
+  toTry(): Try<T>;
 }
 //#endregion
 //#region src/branded/ValidatedBrand.d.ts
-type ValidatedBrand<K$1 extends string, T$1> = Brand<K$1, T$1> & {
+type ValidatedBrand<K$1 extends string, T> = Brand<K$1, T> & {
   readonly __validated: true;
 };
-interface ValidatedBrandCompanion<K$1 extends string, T$1> {
+interface ValidatedBrandCompanion<K$1 extends string, T> {
   readonly brand: K$1;
-  readonly validate: (value: T$1) => boolean;
-  readonly of: (value: T$1) => Option<ValidatedBrand<K$1, T$1>>;
-  readonly from: (value: T$1) => Either<string, ValidatedBrand<K$1, T$1>>;
-  readonly unsafeOf: (value: T$1) => ValidatedBrand<K$1, T$1>;
-  readonly is: (value: unknown) => value is ValidatedBrand<K$1, T$1>;
-  readonly unwrap: (branded: Brand<K$1, T$1>) => T$1;
-  readonly refine: <K2 extends string>(brand: K2, validate: (value: Brand<K$1, T$1>) => boolean) => ValidatedBrandCompanion<K2, Brand<K$1, T$1>>;
+  readonly validate: (value: T) => boolean;
+  readonly of: (value: T) => Option<ValidatedBrand<K$1, T>>;
+  readonly from: (value: T) => Either<string, ValidatedBrand<K$1, T>>;
+  readonly unsafeOf: (value: T) => ValidatedBrand<K$1, T>;
+  readonly is: (value: unknown) => value is ValidatedBrand<K$1, T>;
+  readonly unwrap: (branded: Brand<K$1, T>) => T;
+  readonly refine: <K2 extends string>(brand: K2, validate: (value: Brand<K$1, T>) => boolean) => ValidatedBrandCompanion<K2, Brand<K$1, T>>;
 }
 /**
  * Create a validated brand with runtime validation
@@ -590,7 +590,7 @@ interface ValidatedBrandCompanion<K$1 extends string, T$1> {
  * // ❌ ValidatedBrand("ValidatedUserId", ...) + Brand<"UserId", string>
  * // ✅ ValidatedBrand("UserId", ...) + Brand<"UserId", string>
  */
-declare function ValidatedBrand<K$1 extends string, T$1>(brand: K$1, validate: (value: T$1) => boolean): ValidatedBrandCompanion<K$1, T$1>;
+declare function ValidatedBrand<K$1 extends string, T>(brand: K$1, validate: (value: T) => boolean): ValidatedBrandCompanion<K$1, T>;
 /**
  * Positive number brand (> 0)
  * @example
@@ -703,7 +703,7 @@ declare function Companion<ObjectF extends object, CompanionF extends object>(ob
  * // { from: ..., none: ..., fromJSON: ..., etc. }
  * ```
  */
-type CompanionMethods<T$1> = T$1 extends ((...args: never[]) => unknown) & infer C ? C : never;
+type CompanionMethods<T> = T extends ((...args: never[]) => unknown) & infer C ? C : never;
 /**
  * Extracts the instance type from a constructor function
  * @typeParam T - The constructor function type
@@ -713,7 +713,7 @@ type CompanionMethods<T$1> = T$1 extends ((...args: never[]) => unknown) & infer
  * // Option<T>
  * ```
  */
-type InstanceType<T$1> = T$1 extends ((...args: infer Args) => infer R) ? R extends ((...args: unknown[]) => unknown) ? ReturnType<R> : R : never;
+type InstanceType<T> = T extends ((...args: infer Args) => infer R) ? R extends ((...args: unknown[]) => unknown) ? ReturnType<R> : R : never;
 /**
  * Type guard to check if a value is a Companion object (has both constructor and companion methods)
  * @param value - The value to check
@@ -740,29 +740,29 @@ declare const isCompanion: (value: unknown) => value is ((...args: never[]) => u
  *   .elseWhen(response.status >= 200, "Success")
  *   .else("Unknown")
  */
-type Cond<T$1 extends Type> = {
+type Cond<T extends Type> = {
   /**
    * Add an if condition
    */
-  when: (condition: boolean, value: T$1 | (() => T$1)) => Cond<T$1>;
+  when: (condition: boolean, value: T | (() => T)) => Cond<T>;
   /**
    * Add an else-if condition
    */
-  elseWhen: (condition: boolean, value: T$1 | (() => T$1)) => Cond<T$1>;
+  elseWhen: (condition: boolean, value: T | (() => T)) => Cond<T>;
   /**
    * Terminal else clause - required to get the result
    */
-  else: (value: T$1 | (() => T$1)) => T$1;
+  else: (value: T | (() => T)) => T;
   /**
    * Get the result if a condition was met, throws if no condition met
    */
-  orThrow: () => T$1;
+  orThrow: () => T;
 };
 /** @internal */
-type LazyCondChain<T$1> = {
-  when: (condition: () => boolean, value: () => T$1) => LazyCondChain<T$1>;
-  elseWhen: (condition: () => boolean, value: () => T$1) => LazyCondChain<T$1>;
-  else: (value: () => T$1) => T$1;
+type LazyCondChain<T> = {
+  when: (condition: () => boolean, value: () => T) => LazyCondChain<T>;
+  elseWhen: (condition: () => boolean, value: () => T) => LazyCondChain<T>;
+  else: (value: () => T) => T;
 };
 /**
  * Conditional expression builder for functional if/else chains
@@ -788,7 +788,7 @@ type LazyCondChain<T$1> = {
  *   .when(() => checkCondition2(), () => "Result 2")
  *   .else(() => "Default")
  */
-declare const Cond: (<T$1 extends Type>() => Cond<T$1>) & {
+declare const Cond: (<T extends Type>() => Cond<T>) & {
   /**
    * Create a conditional expression that must end with else
    * @example
@@ -806,7 +806,7 @@ declare const Cond: (<T$1 extends Type>() => Cond<T$1>) & {
    *   .when(isLoyal, () => calculateLoyaltyDiscount())
    *   .else(0)
    */
-  of: <T$1 extends Type>() => Cond<T$1>;
+  of: <T extends Type>() => Cond<T>;
   /**
    * Pattern matching helper that ensures exhaustiveness
    * @example
@@ -828,7 +828,7 @@ declare const Cond: (<T$1 extends Type>() => Cond<T$1>) & {
    *   "skip": () => defaultValue
    * })
    */
-  match: <T$1 extends string | number | symbol>(value: T$1) => <R$1 extends Type>(cases: Record<T$1, R$1 | (() => R$1)>) => R$1;
+  match: <T extends string | number | symbol>(value: T) => <R$1 extends Type>(cases: Record<T, R$1 | (() => R$1)>) => R$1;
   /**
    * Create a lazy conditional that defers evaluation
    * @example
@@ -851,7 +851,7 @@ declare const Cond: (<T$1 extends Type>() => Cond<T$1>) & {
    *   )
    *   .else(() => ({ type: "guest", permissions: [] }))
    */
-  lazy: <T$1 extends Type>() => LazyCondChain<T$1>;
+  lazy: <T extends Type>() => LazyCondChain<T>;
 };
 //#endregion
 //#region src/conditional/Match.d.ts
@@ -861,21 +861,21 @@ declare const Cond: (<T$1 extends Type>() => Cond<T$1>) & {
  */
 type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 /** @internal */
-type IsUnion<T$1> = [T$1] extends [UnionToIntersection<T$1>] ? false : true;
+type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
 /** @internal */
-type RequireExhaustive<T$1, Cases> = IsUnion<T$1> extends true ? (keyof Cases extends T$1 ? (T$1 extends keyof Cases ? Cases : never) : never) : Cases;
+type RequireExhaustive<T, Cases> = IsUnion<T> extends true ? (keyof Cases extends T ? (T extends keyof Cases ? Cases : never) : never) : Cases;
 /**
  * Pattern types for nested matching
  * @internal
  */
-type Pattern<T$1> = T$1 | { [K in keyof T$1]?: Pattern<T$1[K]> } | ((value: T$1) => boolean) | {
-  _: (value: T$1) => boolean;
+type Pattern<T> = T | { [K in keyof T]?: Pattern<T[K]> } | ((value: T) => boolean) | {
+  _: (value: T) => boolean;
 };
 /**
  * Extract result from pattern
  * @internal
  */
-type PatternResult<T$1, R$1> = R$1 | ((matched: T$1) => R$1);
+type PatternResult<T, R$1> = R$1 | ((matched: T) => R$1);
 /**
  * Pattern matching construct similar to Scala's match expressions.
  * Supports exhaustive matching, nested patterns, and guards.
@@ -903,31 +903,31 @@ type PatternResult<T$1, R$1> = R$1 | ((matched: T$1) => R$1);
  *   .case({ role: "user" }, u => `User: ${u.name}`)
  *   .default("Guest")
  */
-type Match<T$1 extends Type, R$1 extends Type> = {
+type Match<T extends Type, R$1 extends Type> = {
   /**
    * Match against a pattern (value, nested object, or predicate)
    */
-  case: (pattern: Pattern<T$1>, result: PatternResult<T$1, R$1>) => Match<T$1, R$1>;
+  case: (pattern: Pattern<T>, result: PatternResult<T, R$1>) => Match<T, R$1>;
   /**
    * Add a case that matches a specific value (backward compatibility)
    */
-  caseValue: (match: T$1, result: R$1 | (() => R$1)) => Match<T$1, R$1>;
+  caseValue: (match: T, result: R$1 | (() => R$1)) => Match<T, R$1>;
   /**
    * Add a case that matches multiple values (backward compatibility)
    */
-  caseValues: (matches: T$1[], result: R$1 | (() => R$1)) => Match<T$1, R$1>;
+  caseValues: (matches: T[], result: R$1 | (() => R$1)) => Match<T, R$1>;
   /**
    * Match with a guard function (alias for readability)
    */
-  when: (guard: (value: T$1) => boolean, result: PatternResult<T$1, R$1>) => Match<T$1, R$1>;
+  when: (guard: (value: T) => boolean, result: PatternResult<T, R$1>) => Match<T, R$1>;
   /**
    * Match multiple patterns (OR operation)
    */
-  caseAny: (patterns: Pattern<T$1>[], result: PatternResult<T$1, R$1>) => Match<T$1, R$1>;
+  caseAny: (patterns: Pattern<T>[], result: PatternResult<T, R$1>) => Match<T, R$1>;
   /**
    * Default case - makes match non-exhaustive
    */
-  default: (result: PatternResult<T$1, R$1>) => R$1;
+  default: (result: PatternResult<T, R$1>) => R$1;
   /**
    * Force exhaustive matching (compile-time check for union types)
    */
@@ -981,7 +981,7 @@ type Match<T$1 extends Type, R$1 extends Type> = {
  *   .case("error", "Failed!")
  *   .exhaustive()
  */
-declare const Match: (<T$1 extends Type, R$1 extends Type>(value: T$1) => Match<T$1, R$1>) & {
+declare const Match: (<T extends Type, R$1 extends Type>(value: T) => Match<T, R$1>) & {
   /**
    * Create a type-safe exhaustive match for union types
    * @example
@@ -1005,7 +1005,7 @@ declare const Match: (<T$1 extends Type, R$1 extends Type>(value: T$1) => Match<
    * const compute = ops("multiply").fn
    * const result = compute(4, 5) // 20
    */
-  exhaustive: <T$1 extends string | number | symbol, R$1 extends Type>(cases: RequireExhaustive<T$1, Record<T$1, R$1>>) => (value: T$1) => R$1;
+  exhaustive: <T extends string | number | symbol, R$1 extends Type>(cases: RequireExhaustive<T, Record<T, R$1>>) => (value: T) => R$1;
   /**
    * Create a partial match that requires a default
    * @example
@@ -1027,8 +1027,8 @@ declare const Match: (<T$1 extends Type, R$1 extends Type>(value: T$1) => Match<
    * }).withDefault((n) => `Number: ${n}`)
    * getMessage(5) // "Number: 5"
    */
-  partial: <T$1 extends string | number | symbol, R$1 extends Type>(cases: Partial<Record<T$1, R$1 | ((value: T$1) => R$1)>>) => {
-    withDefault: (defaultValue: R$1 | ((value: T$1) => R$1)) => (value: T$1) => R$1;
+  partial: <T extends string | number | symbol, R$1 extends Type>(cases: Partial<Record<T, R$1 | ((value: T) => R$1)>>) => {
+    withDefault: (defaultValue: R$1 | ((value: T) => R$1)) => (value: T) => R$1;
   };
   /**
    * Pattern match with guards
@@ -1053,8 +1053,8 @@ declare const Match: (<T$1 extends Type, R$1 extends Type>(value: T$1) => Match<
    * ]).withDefault("Unknown")(age)
    * // category = "Adult (25 years)"
    */
-  withGuards: <T$1 extends Type, R$1 extends Type>(guards: Array<[(value: T$1) => boolean, R$1 | ((value: T$1) => R$1)]>) => {
-    withDefault: (defaultValue: R$1 | ((value: T$1) => R$1)) => (value: T$1) => R$1;
+  withGuards: <T extends Type, R$1 extends Type>(guards: Array<[(value: T) => boolean, R$1 | ((value: T) => R$1)]>) => {
+    withDefault: (defaultValue: R$1 | ((value: T) => R$1)) => (value: T) => R$1;
   };
   /**
    * Pattern matching for objects with specific structure
@@ -1070,9 +1070,9 @@ declare const Match: (<T$1 extends Type, R$1 extends Type>(value: T$1) => Match<
    *   .case({ type: "hover" }, (e) => console.log(`Hovering over ${e.element}`))
    *   .build()
    */
-  struct: <T$1 extends Type, R$1 extends Type>() => {
-    case: (pattern: Pattern<T$1>, handler: (value: T$1) => R$1) => /*elided*/any;
-    build: () => (value: T$1) => R$1;
+  struct: <T extends Type, R$1 extends Type>() => {
+    case: (pattern: Pattern<T>, handler: (value: T) => R$1) => /*elided*/any;
+    build: () => (value: T) => R$1;
   };
   /**
    * Create a pattern matcher with guards and nested patterns
@@ -1089,11 +1089,11 @@ declare const Match: (<T$1 extends Type, R$1 extends Type>(value: T$1) => Match<
    *   .default(false)
    *   .build()
    */
-  builder: <T$1 extends Type, R$1 extends Type>() => {
-    case: (pattern: Pattern<T$1>, result: PatternResult<T$1, R$1>) => /*elided*/any;
-    when: (guard: (value: T$1) => boolean, result: PatternResult<T$1, R$1>) => /*elided*/any;
-    default: (result: PatternResult<T$1, R$1>) => {
-      build: () => (value: T$1) => R$1;
+  builder: <T extends Type, R$1 extends Type>() => {
+    case: (pattern: Pattern<T>, result: PatternResult<T, R$1>) => /*elided*/any;
+    when: (guard: (value: T) => boolean, result: PatternResult<T, R$1>) => /*elided*/any;
+    default: (result: PatternResult<T, R$1>) => {
+      build: () => (value: T) => R$1;
     };
   };
 };
@@ -1105,7 +1105,7 @@ declare const Match: (<T$1 extends Type, R$1 extends Type>(value: T$1) => Match<
  * @param type - The type name for the object
  * @param body - The implementation body
  */
-declare function Base<T$1 extends Record<string, unknown>>(type: string, body: T$1): T$1 & {
+declare function Base<T extends Record<string, unknown>>(type: string, body: T): T & {
   toString(): string;
   doUnwrap(): DoResult<unknown>;
   _tag: string;
@@ -1184,22 +1184,22 @@ type ErrorContext = {
 /**
  * FPromise type that defines the function signature and methods
  */
-type FPromise<T$1 extends Type, E extends Type = unknown> = PromiseLike<T$1> & {
+type FPromise<T extends Type, E extends Type = unknown> = PromiseLike<T> & {
   readonly _tag: "FPromise";
-  tap: (f: (value: T$1) => void) => FPromise<T$1, E>;
-  mapError: <E2>(f: (error: E, context: ErrorContext) => E2) => FPromise<T$1, E2>;
-  tapError: (f: (error: E) => void) => FPromise<T$1, E>;
-  recover: (fallback: T$1) => FPromise<T$1, never>;
-  recoverWith: (f: (error: E) => T$1) => FPromise<T$1, never>;
-  recoverWithF: <E2>(f: (error: E) => FPromise<T$1, E2>) => FPromise<T$1, E2>;
-  filterError: <E2 extends E>(predicate: (error: E) => boolean, handler: (error: E) => FPromise<T$1, E2>) => FPromise<T$1, E>;
-  logError: (logger: (error: E, context: ErrorContext) => void) => FPromise<T$1, E>;
-  toPromise: () => Promise<T$1>;
-  toEither: () => Promise<Either<E, T$1>>;
-  fold: <R$1 extends Type>(onError: (error: E) => R$1, onSuccess: (value: T$1) => R$1) => FPromise<R$1, never>;
-  map: <U extends Type>(f: (value: T$1) => U) => FPromise<U, E>;
-  flatMap: <U extends Type>(f: (value: T$1) => FPromise<U, E> | PromiseLike<U>) => FPromise<U, E>;
-  flatMapAsync: <U extends Type>(f: (value: T$1) => PromiseLike<U>) => Promise<U>;
+  tap: (f: (value: T) => void) => FPromise<T, E>;
+  mapError: <E2>(f: (error: E, context: ErrorContext) => E2) => FPromise<T, E2>;
+  tapError: (f: (error: E) => void) => FPromise<T, E>;
+  recover: (fallback: T) => FPromise<T, never>;
+  recoverWith: (f: (error: E) => T) => FPromise<T, never>;
+  recoverWithF: <E2>(f: (error: E) => FPromise<T, E2>) => FPromise<T, E2>;
+  filterError: <E2 extends E>(predicate: (error: E) => boolean, handler: (error: E) => FPromise<T, E2>) => FPromise<T, E>;
+  logError: (logger: (error: E, context: ErrorContext) => void) => FPromise<T, E>;
+  toPromise: () => Promise<T>;
+  toEither: () => Promise<Either<E, T>>;
+  fold: <R$1 extends Type>(onError: (error: E) => R$1, onSuccess: (value: T) => R$1) => FPromise<R$1, never>;
+  map: <U extends Type>(f: (value: T) => U) => FPromise<U, E>;
+  flatMap: <U extends Type>(f: (value: T) => FPromise<U, E> | PromiseLike<U>) => FPromise<U, E>;
+  flatMapAsync: <U extends Type>(f: (value: T) => PromiseLike<U>) => Promise<U>;
 };
 /**
  * Static utility methods for FPromise using the Companion pattern.
@@ -1218,7 +1218,7 @@ declare const FPromiseCompanion: {
    * const promise = FPromise.resolve(42)
    * // promise resolves to 42
    */
-  resolve: <T$1, E = never>(value: T$1 | PromiseLike<T$1>) => FPromise<T$1, E>;
+  resolve: <T, E = never>(value: T | PromiseLike<T>) => FPromise<T, E>;
   /**
    * Creates an FPromise that rejects with the provided reason.
    *
@@ -1231,7 +1231,7 @@ declare const FPromiseCompanion: {
    * const promise = FPromise.reject<number, Error>(new Error("Something went wrong"))
    * // promise rejects with Error("Something went wrong")
    */
-  reject: <T$1, E = unknown>(reason: E) => FPromise<T$1, E>;
+  reject: <T, E = unknown>(reason: E) => FPromise<T, E>;
   /**
    * Creates an FPromise from a regular Promise.
    *
@@ -1244,7 +1244,7 @@ declare const FPromiseCompanion: {
    * const promise = FPromise.from(fetch("https://api.example.com/data"))
    * // promise is an FPromise that resolves or rejects based on the fetch result
    */
-  from: <T$1, E = unknown>(promise: Promise<T$1>) => FPromise<T$1, E>;
+  from: <T, E = unknown>(promise: Promise<T>) => FPromise<T, E>;
   /**
    * Creates an FPromise from an Either.
    * If the Either is a Right, the FPromise resolves with the Right value.
@@ -1275,7 +1275,7 @@ declare const FPromiseCompanion: {
    * const result = await FPromise.all(promises).toPromise()
    * // result is [1, 2, 3]
    */
-  all: <T$1, E = unknown>(promises: Array<FPromise<T$1, E> | PromiseLike<T$1> | T$1>) => FPromise<T$1[], E>;
+  all: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T> | T>) => FPromise<T[], E>;
   /**
    * Like Promise.allSettled, returns results of all promises whether they succeed or fail.
    * This will always resolve, never reject.
@@ -1290,7 +1290,7 @@ declare const FPromiseCompanion: {
    * const result = await FPromise.allSettled(promises).toPromise()
    * // result is [Right(1), Left(Error("Failed"))]
    */
-  allSettled: <T$1, E = unknown>(promises: Array<FPromise<T$1, E> | PromiseLike<T$1>>) => FPromise<Array<Either<E, T$1>>, never>;
+  allSettled: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<Array<Either<E, T>>, never>;
   /**
    * Like Promise.race, returns the first promise to settle (either resolve or reject).
    *
@@ -1305,7 +1305,7 @@ declare const FPromiseCompanion: {
    * const result = await FPromise.race([slow, fast]).toPromise()
    * // result is 2
    */
-  race: <T$1, E = unknown>(promises: Array<FPromise<T$1, E> | PromiseLike<T$1>>) => FPromise<T$1, E>;
+  race: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<T, E>;
   /**
    * Like Promise.any, returns the first promise to fulfill.
    * This will only reject if all promises reject.
@@ -1324,7 +1324,7 @@ declare const FPromiseCompanion: {
    * const result = await FPromise.any(promises).toPromise()
    * // result is 2
    */
-  any: <T$1, E = unknown>(promises: Array<FPromise<T$1, E> | PromiseLike<T$1>>) => FPromise<T$1, E>;
+  any: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<T, E>;
   /**
    * Retries an operation with exponential backoff.
    * This is useful for operations that may fail temporarily, such as network requests.
@@ -1352,11 +1352,11 @@ declare const FPromiseCompanion: {
    *   shouldRetry: (error) => error.message === "Temporary failure"
    * }).toPromise()
    */
-  retryWithBackoff: <T$1, E = unknown>(operation: () => FPromise<T$1, E>, options: {
+  retryWithBackoff: <T, E = unknown>(operation: () => FPromise<T, E>, options: {
     maxRetries: number;
     baseDelay?: number;
     shouldRetry?: (error: E, attempt: number) => boolean;
-  }) => FPromise<T$1, E>;
+  }) => FPromise<T, E>;
 };
 /**
  * Creates an FPromise from an executor function.
@@ -1366,7 +1366,7 @@ declare const FPromiseCompanion: {
  * @param executor - A function that receives resolve and reject functions
  * @returns An FPromise instance
  */
-declare const FPromise: (<T$1 extends Type, E = unknown>(executor: (resolve: (value: T$1 | PromiseLike<T$1>) => void, reject: (reason?: E) => void) => void) => FPromise<T$1, E>) & {
+declare const FPromise: (<T extends Type, E = unknown>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: E) => void) => void) => FPromise<T, E>) & {
   /**
    * Creates an FPromise that resolves to the provided value.
    *
@@ -1379,7 +1379,7 @@ declare const FPromise: (<T$1 extends Type, E = unknown>(executor: (resolve: (va
    * const promise = FPromise.resolve(42)
    * // promise resolves to 42
    */
-  resolve: <T$1, E = never>(value: T$1 | PromiseLike<T$1>) => FPromise<T$1, E>;
+  resolve: <T, E = never>(value: T | PromiseLike<T>) => FPromise<T, E>;
   /**
    * Creates an FPromise that rejects with the provided reason.
    *
@@ -1392,7 +1392,7 @@ declare const FPromise: (<T$1 extends Type, E = unknown>(executor: (resolve: (va
    * const promise = FPromise.reject<number, Error>(new Error("Something went wrong"))
    * // promise rejects with Error("Something went wrong")
    */
-  reject: <T$1, E = unknown>(reason: E) => FPromise<T$1, E>;
+  reject: <T, E = unknown>(reason: E) => FPromise<T, E>;
   /**
    * Creates an FPromise from a regular Promise.
    *
@@ -1405,7 +1405,7 @@ declare const FPromise: (<T$1 extends Type, E = unknown>(executor: (resolve: (va
    * const promise = FPromise.from(fetch("https://api.example.com/data"))
    * // promise is an FPromise that resolves or rejects based on the fetch result
    */
-  from: <T$1, E = unknown>(promise: Promise<T$1>) => FPromise<T$1, E>;
+  from: <T, E = unknown>(promise: Promise<T>) => FPromise<T, E>;
   /**
    * Creates an FPromise from an Either.
    * If the Either is a Right, the FPromise resolves with the Right value.
@@ -1436,7 +1436,7 @@ declare const FPromise: (<T$1 extends Type, E = unknown>(executor: (resolve: (va
    * const result = await FPromise.all(promises).toPromise()
    * // result is [1, 2, 3]
    */
-  all: <T$1, E = unknown>(promises: Array<FPromise<T$1, E> | PromiseLike<T$1> | T$1>) => FPromise<T$1[], E>;
+  all: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T> | T>) => FPromise<T[], E>;
   /**
    * Like Promise.allSettled, returns results of all promises whether they succeed or fail.
    * This will always resolve, never reject.
@@ -1451,7 +1451,7 @@ declare const FPromise: (<T$1 extends Type, E = unknown>(executor: (resolve: (va
    * const result = await FPromise.allSettled(promises).toPromise()
    * // result is [Right(1), Left(Error("Failed"))]
    */
-  allSettled: <T$1, E = unknown>(promises: Array<FPromise<T$1, E> | PromiseLike<T$1>>) => FPromise<Array<Either<E, T$1>>, never>;
+  allSettled: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<Array<Either<E, T>>, never>;
   /**
    * Like Promise.race, returns the first promise to settle (either resolve or reject).
    *
@@ -1466,7 +1466,7 @@ declare const FPromise: (<T$1 extends Type, E = unknown>(executor: (resolve: (va
    * const result = await FPromise.race([slow, fast]).toPromise()
    * // result is 2
    */
-  race: <T$1, E = unknown>(promises: Array<FPromise<T$1, E> | PromiseLike<T$1>>) => FPromise<T$1, E>;
+  race: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<T, E>;
   /**
    * Like Promise.any, returns the first promise to fulfill.
    * This will only reject if all promises reject.
@@ -1485,7 +1485,7 @@ declare const FPromise: (<T$1 extends Type, E = unknown>(executor: (resolve: (va
    * const result = await FPromise.any(promises).toPromise()
    * // result is 2
    */
-  any: <T$1, E = unknown>(promises: Array<FPromise<T$1, E> | PromiseLike<T$1>>) => FPromise<T$1, E>;
+  any: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<T, E>;
   /**
    * Retries an operation with exponential backoff.
    * This is useful for operations that may fail temporarily, such as network requests.
@@ -1513,11 +1513,11 @@ declare const FPromise: (<T$1 extends Type, E = unknown>(executor: (resolve: (va
    *   shouldRetry: (error) => error.message === "Temporary failure"
    * }).toPromise()
    */
-  retryWithBackoff: <T$1, E = unknown>(operation: () => FPromise<T$1, E>, options: {
+  retryWithBackoff: <T, E = unknown>(operation: () => FPromise<T, E>, options: {
     maxRetries: number;
     baseDelay?: number;
     shouldRetry?: (error: E, attempt: number) => boolean;
-  }) => FPromise<T$1, E>;
+  }) => FPromise<T, E>;
 };
 //#endregion
 //#region src/core/task/Task.d.ts
@@ -1544,59 +1544,59 @@ interface TaskMetadata {
   readonly name: string;
   readonly description: string;
 }
-interface TaskOutcome<T$1> extends FunctypeBase<T$1, "Ok" | "Err">, Extractable<T$1>, AsyncMonad<T$1>, Promisable<T$1>, Doable<T$1> {
+interface TaskOutcome<T> extends FunctypeBase<T, "Ok" | "Err">, Extractable<T>, AsyncMonad<T>, Promisable<T>, Doable<T> {
   readonly _tag: "Ok" | "Err";
   readonly _meta: TaskMetadata;
-  readonly value?: T$1;
+  readonly value?: T;
   readonly error?: Throwable;
-  readonly map: <U>(f: (value: T$1) => U) => TaskOutcome<U>;
-  readonly flatMap: <U>(f: (value: T$1) => TaskOutcome<U> | Either<Throwable, U>) => TaskOutcome<U>;
-  readonly ap: <U>(ff: TaskOutcome<(value: T$1) => U>) => TaskOutcome<U>;
-  readonly mapAsync: <U>(f: (value: T$1) => Promise<U>) => Promise<TaskOutcome<U>>;
-  readonly flatMapAsync: <U>(f: (value: T$1) => Promise<TaskOutcome<U>>) => Promise<TaskOutcome<U>>;
-  readonly mapError: (f: (error: Throwable) => Throwable) => TaskOutcome<T$1>;
-  readonly recover: (value: T$1) => Ok<T$1>;
-  readonly recoverWith: (f: (error: Throwable) => T$1) => Ok<T$1>;
-  readonly isSuccess: () => this is Ok<T$1>;
-  readonly isFailure: () => this is Err<T$1>;
-  readonly isOk: () => this is Ok<T$1>;
-  readonly isErr: () => this is Err<T$1>;
-  readonly toEither: () => Either<Throwable, T$1>;
-  readonly toTry: () => Try<T$1>;
-  readonly toOption: () => Option<T$1>;
-  readonly toList: () => List<T$1>;
-  readonly fold: <U>(onErr: (error: Throwable) => U, onOk: (value: T$1) => U) => U;
+  readonly map: <U>(f: (value: T) => U) => TaskOutcome<U>;
+  readonly flatMap: <U>(f: (value: T) => TaskOutcome<U> | Either<Throwable, U>) => TaskOutcome<U>;
+  readonly ap: <U>(ff: TaskOutcome<(value: T) => U>) => TaskOutcome<U>;
+  readonly mapAsync: <U>(f: (value: T) => Promise<U>) => Promise<TaskOutcome<U>>;
+  readonly flatMapAsync: <U>(f: (value: T) => Promise<TaskOutcome<U>>) => Promise<TaskOutcome<U>>;
+  readonly mapError: (f: (error: Throwable) => Throwable) => TaskOutcome<T>;
+  readonly recover: (value: T) => Ok<T>;
+  readonly recoverWith: (f: (error: Throwable) => T) => Ok<T>;
+  readonly isSuccess: () => this is Ok<T>;
+  readonly isFailure: () => this is Err<T>;
+  readonly isOk: () => this is Ok<T>;
+  readonly isErr: () => this is Err<T>;
+  readonly toEither: () => Either<Throwable, T>;
+  readonly toTry: () => Try<T>;
+  readonly toOption: () => Option<T>;
+  readonly toList: () => List<T>;
+  readonly fold: <U>(onErr: (error: Throwable) => U, onOk: (value: T) => U) => U;
   readonly match: <U>(patterns: {
-    Ok: (value: T$1) => U;
+    Ok: (value: T) => U;
     Err: (error: Throwable) => U;
   }) => U;
 }
-interface Ok<T$1> extends TaskOutcome<T$1> {
+interface Ok<T> extends TaskOutcome<T> {
   readonly _tag: "Ok";
-  readonly value: T$1;
+  readonly value: T;
   readonly error: undefined;
 }
-interface Err<T$1> extends TaskOutcome<T$1> {
+interface Err<T> extends TaskOutcome<T> {
   readonly _tag: "Err";
   readonly value: undefined;
   readonly error: Throwable;
 }
-type TaskSuccess<T$1> = Ok<T$1>;
-type TaskFailure<T$1> = Err<T$1>;
+type TaskSuccess<T> = Ok<T>;
+type TaskFailure<T> = Err<T>;
 /**
  * Err constructor - Creates a failed TaskOutcome
  * @param error - The error object
  * @param data - Additional data related to the error
  * @param params - Task parameters
  */
-declare const Err: <T$1>(error: unknown, data?: unknown, params?: TaskParams) => Err<T$1>;
+declare const Err: <T>(error: unknown, data?: unknown, params?: TaskParams) => Err<T>;
 /**
  * Ok constructor - Creates a successful TaskOutcome
  * @param data - The successful value
  * @param params - Task parameters
  */
-declare const Ok: <T$1>(data: T$1, params?: TaskParams) => Ok<T$1>;
-type TaskResult<T$1> = Promise<TaskOutcome<T$1>>;
+declare const Ok: <T>(data: T, params?: TaskParams) => Ok<T>;
+type TaskResult<T> = Promise<TaskOutcome<T>>;
 /**
  * The CancellationToken is a control structure that allows long-running tasks to be cancelled
  * Cancellation is cooperative, meaning the task must check the token and respond to cancellation requests
@@ -1624,9 +1624,9 @@ type CancellationTokenSource = {
  * @returns A CancellationTokenSource that can be used to create and control cancellation tokens
  */
 declare const createCancellationTokenSource: () => CancellationTokenSource;
-type Sync<T$1> = TaskOutcome<T$1>;
-type Async<T$1> = TaskResult<T$1>;
-declare const Task: (<T$1 = unknown>(params?: TaskParams) => {
+type Sync<T> = TaskOutcome<T>;
+type Async<T> = TaskResult<T>;
+declare const Task$1: (<T = unknown>(params?: TaskParams) => {
   _type: string;
   /**
    * Run an async operation with explicit try/catch/finally semantics
@@ -1637,7 +1637,7 @@ declare const Task: (<T$1 = unknown>(params?: TaskParams) => {
    * @param f - Optional finally handler function
    * @param cancellationToken - Optional token for cancellation support
    */
-  Async: <U = T$1>(t: () => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>, e?: (error: unknown) => unknown | TaskOutcome<U>, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => FPromise<TaskOutcome<U>>;
+  Async: <U = T>(t: () => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>, e?: (error: unknown) => unknown | TaskOutcome<U>, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => FPromise<TaskOutcome<U>>;
   /**
    * Run a synchronous operation with explicit try/catch/finally semantics
    * Returns a TaskOutcome for functional error handling
@@ -1646,7 +1646,7 @@ declare const Task: (<T$1 = unknown>(params?: TaskParams) => {
    * @param e - Optional error handler function
    * @param f - Optional finally handler function
    */
-  Sync: <U = T$1>(t: () => U, e?: (error: unknown) => unknown, f?: () => void) => TaskOutcome<U>;
+  Sync: <U = T>(t: () => U, e?: (error: unknown) => unknown, f?: () => void) => TaskOutcome<U>;
   /**
    * Run an async operation with progress tracking capabilities
    * Returns a Promise and provides progress updates via callback
@@ -1657,7 +1657,7 @@ declare const Task: (<T$1 = unknown>(params?: TaskParams) => {
    * @param f - Optional finally handler function
    * @param cancellationToken - Optional token for cancellation support
    */
-  AsyncWithProgress: <U = T$1>(t: (updateProgress: (percent: number) => void) => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>, onProgress: (percent: number) => void, e?: (error: unknown) => unknown | TaskOutcome<U>, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => FPromise<TaskOutcome<U>>;
+  AsyncWithProgress: <U = T>(t: (updateProgress: (percent: number) => void) => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>, onProgress: (percent: number) => void, e?: (error: unknown) => unknown | TaskOutcome<U>, f?: () => Promise<void> | void, cancellationToken?: CancellationToken) => FPromise<TaskOutcome<U>>;
   toString(): string;
   doUnwrap(): DoResult<unknown>;
   _tag: string;
@@ -1665,33 +1665,33 @@ declare const Task: (<T$1 = unknown>(params?: TaskParams) => {
   /**
    * Create a successful Task result
    */
-  success: <T$1>(data: T$1, params?: TaskParams) => Ok<T$1>;
+  success: <T>(data: T, params?: TaskParams) => Ok<T>;
   /**
    * Create a failed Task result
    */
-  fail: <T$1>(error: unknown, data?: unknown, params?: TaskParams) => Err<T$1>;
+  fail: <T>(error: unknown, data?: unknown, params?: TaskParams) => Err<T>;
   /**
    * Create a successful Task result (alias for success)
    * Preferred for new code
    */
-  ok: <T$1>(data: T$1, params?: TaskParams) => Ok<T$1>;
+  ok: <T>(data: T, params?: TaskParams) => Ok<T>;
   /**
    * Create a failed Task result (alias for fail)
    * Preferred for new code
    */
-  err: <T$1>(error: unknown, data?: unknown, params?: TaskParams) => Err<T$1>;
+  err: <T>(error: unknown, data?: unknown, params?: TaskParams) => Err<T>;
   /**
    * Create TaskOutcome from Either
    * @param either - Either to convert
    * @param params - Task parameters
    */
-  fromEither: <T$1>(either: Either<Throwable, T$1>, params?: TaskParams) => TaskOutcome<T$1>;
+  fromEither: <T>(either: Either<Throwable, T>, params?: TaskParams) => TaskOutcome<T>;
   /**
    * Create TaskOutcome from Try
    * @param tryValue - Try to convert
    * @param params - Task parameters
    */
-  fromTry: <T$1>(tryValue: Try<T$1>, params?: TaskParams) => TaskOutcome<T$1>;
+  fromTry: <T>(tryValue: Try<T>, params?: TaskParams) => TaskOutcome<T>;
   /**
    * Extract the error chain from a Throwable error
    * Returns an array of errors from outermost to innermost
@@ -1729,7 +1729,7 @@ declare const Task: (<T$1 = unknown>(params?: TaskParams) => {
    * @param params - Task parameters for the race operation
    * @returns A promise that resolves with the first task to complete or rejects if all tasks fail
    */
-  race: <T$1>(tasks: Array<FPromise<T$1> | FPromise<TaskOutcome<T$1>>>, timeoutMs?: number, params?: TaskParams) => FPromise<TaskOutcome<T$1>>;
+  race: <T>(tasks: Array<FPromise<T> | FPromise<TaskOutcome<T>>>, timeoutMs?: number, params?: TaskParams) => FPromise<TaskOutcome<T>>;
   /**
    * Convert a Node.js style callback function to a Task-compatible function
    * Node.js callbacks typically have the signature (error, result) => void
@@ -1738,7 +1738,7 @@ declare const Task: (<T$1 = unknown>(params?: TaskParams) => {
    * @param params - Task parameters
    * @returns A function that returns an FPromise
    */
-  fromNodeCallback: <T$1, Args extends unknown[]>(nodeFn: (...args: [...Args, (error: unknown, result: T$1) => void]) => void, params?: TaskParams) => ((...args: Args) => FPromise<TaskOutcome<T$1>>);
+  fromNodeCallback: <T, Args extends unknown[]>(nodeFn: (...args: [...Args, (error: unknown, result: T) => void]) => void, params?: TaskParams) => ((...args: Args) => FPromise<TaskOutcome<T>>);
   /**
    * Create a cancellation token source
    * @returns A cancellation token source that can be used to control task cancellation
@@ -1751,8 +1751,8 @@ declare const Task: (<T$1 = unknown>(params?: TaskParams) => {
    * @param params - Task parameters
    * @returns An object with the task and a function to cancel it
    */
-  cancellable: <T$1>(task: (token: CancellationToken) => Promise<T$1> | Promise<TaskOutcome<T$1>>, params?: TaskParams) => {
-    task: FPromise<TaskOutcome<T$1>>;
+  cancellable: <T>(task: (token: CancellationToken) => Promise<T> | Promise<TaskOutcome<T>>, params?: TaskParams) => {
+    task: FPromise<TaskOutcome<T>>;
     cancel: () => void;
   };
   /**
@@ -1763,13 +1763,13 @@ declare const Task: (<T$1 = unknown>(params?: TaskParams) => {
    * @param params - Task parameters
    * @returns An object with the task, cancel function, and current progress
    */
-  withProgress: <T$1>(task: (updateProgress: (percent: number) => void, token: CancellationToken) => Promise<T$1> | Promise<TaskOutcome<T$1>>, onProgress?: (percent: number) => void, params?: TaskParams) => {
-    task: FPromise<TaskOutcome<T$1>>;
+  withProgress: <T>(task: (updateProgress: (percent: number) => void, token: CancellationToken) => Promise<T> | Promise<TaskOutcome<T>>, onProgress?: (percent: number) => void, params?: TaskParams) => {
+    task: FPromise<TaskOutcome<T>>;
     cancel: () => void;
     currentProgress: () => number;
   };
 };
-type Task = ReturnType<typeof Task>;
+type Task$1 = ReturnType<typeof Task$1>;
 //#endregion
 //#region src/error/ErrorFormatter.d.ts
 /**
@@ -1856,64 +1856,64 @@ type ErrorCode = "VALIDATION_FAILED" | "NETWORK_ERROR" | "AUTH_REQUIRED" | "NOT_
 /**
  * Template literal type for error messages based on error code
  */
-type ErrorMessage<T$1 extends ErrorCode> = T$1 extends "VALIDATION_FAILED" ? `Validation failed: ${string}` : T$1 extends "NETWORK_ERROR" ? `Network error: ${string}` : T$1 extends "AUTH_REQUIRED" ? `Authentication required: ${string}` : T$1 extends "NOT_FOUND" ? `Not found: ${string}` : T$1 extends "PERMISSION_DENIED" ? `Permission denied: ${string}` : T$1 extends "RATE_LIMITED" ? `Rate limit exceeded: ${string}` : T$1 extends "INTERNAL_ERROR" ? `Internal server error: ${string}` : T$1 extends "BAD_REQUEST" ? `Bad request: ${string}` : T$1 extends "CONFLICT" ? `Conflict: ${string}` : T$1 extends "TIMEOUT" ? `Request timeout: ${string}` : never;
+type ErrorMessage<T extends ErrorCode> = T extends "VALIDATION_FAILED" ? `Validation failed: ${string}` : T extends "NETWORK_ERROR" ? `Network error: ${string}` : T extends "AUTH_REQUIRED" ? `Authentication required: ${string}` : T extends "NOT_FOUND" ? `Not found: ${string}` : T extends "PERMISSION_DENIED" ? `Permission denied: ${string}` : T extends "RATE_LIMITED" ? `Rate limit exceeded: ${string}` : T extends "INTERNAL_ERROR" ? `Internal server error: ${string}` : T extends "BAD_REQUEST" ? `Bad request: ${string}` : T extends "CONFLICT" ? `Conflict: ${string}` : T extends "TIMEOUT" ? `Request timeout: ${string}` : never;
 /**
  * HTTP status codes mapped to error codes
  */
-type ErrorStatus<T$1 extends ErrorCode> = T$1 extends "VALIDATION_FAILED" | "BAD_REQUEST" ? 400 : T$1 extends "AUTH_REQUIRED" ? 401 : T$1 extends "PERMISSION_DENIED" ? 403 : T$1 extends "NOT_FOUND" ? 404 : T$1 extends "CONFLICT" ? 409 : T$1 extends "RATE_LIMITED" ? 429 : T$1 extends "TIMEOUT" ? 408 : T$1 extends "INTERNAL_ERROR" ? 500 : T$1 extends "NETWORK_ERROR" ? 503 : 500;
+type ErrorStatus<T extends ErrorCode> = T extends "VALIDATION_FAILED" | "BAD_REQUEST" ? 400 : T extends "AUTH_REQUIRED" ? 401 : T extends "PERMISSION_DENIED" ? 403 : T extends "NOT_FOUND" ? 404 : T extends "CONFLICT" ? 409 : T extends "RATE_LIMITED" ? 429 : T extends "TIMEOUT" ? 408 : T extends "INTERNAL_ERROR" ? 500 : T extends "NETWORK_ERROR" ? 503 : 500;
 /**
  * Context type for each error code
  */
-type TypedErrorContext<T$1 extends ErrorCode> = T$1 extends "VALIDATION_FAILED" ? {
+type TypedErrorContext<T extends ErrorCode> = T extends "VALIDATION_FAILED" ? {
   field: string;
   value: unknown;
   rule: string;
-} : T$1 extends "NETWORK_ERROR" ? {
+} : T extends "NETWORK_ERROR" ? {
   url: string;
   method: string;
   statusCode?: number;
-} : T$1 extends "AUTH_REQUIRED" ? {
+} : T extends "AUTH_REQUIRED" ? {
   resource: string;
   requiredRole?: string;
-} : T$1 extends "NOT_FOUND" ? {
+} : T extends "NOT_FOUND" ? {
   resource: string;
   id: string | number;
-} : T$1 extends "PERMISSION_DENIED" ? {
+} : T extends "PERMISSION_DENIED" ? {
   action: string;
   resource: string;
   userId?: string;
-} : T$1 extends "RATE_LIMITED" ? {
+} : T extends "RATE_LIMITED" ? {
   limit: number;
   window: string;
   retryAfter?: number;
-} : T$1 extends "INTERNAL_ERROR" ? {
+} : T extends "INTERNAL_ERROR" ? {
   errorId: string;
   timestamp: string;
-} : T$1 extends "BAD_REQUEST" ? {
+} : T extends "BAD_REQUEST" ? {
   reason: string;
   expected?: string;
-} : T$1 extends "CONFLICT" ? {
+} : T extends "CONFLICT" ? {
   resource: string;
   conflictingValue: string;
-} : T$1 extends "TIMEOUT" ? {
+} : T extends "TIMEOUT" ? {
   duration: number;
   operation: string;
 } : Record<string, unknown>;
 /**
  * Type-safe error class with template literal types
  */
-interface TypedError<T$1 extends ErrorCode> extends Throwable {
-  readonly code: T$1;
-  readonly message: ErrorMessage<T$1>;
-  readonly status: ErrorStatus<T$1>;
-  readonly context: TypedErrorContext<T$1>;
+interface TypedError<T extends ErrorCode> extends Throwable {
+  readonly code: T;
+  readonly message: ErrorMessage<T>;
+  readonly status: ErrorStatus<T>;
+  readonly context: TypedErrorContext<T>;
   readonly timestamp: string;
   readonly traceId?: string;
 }
-declare const TypedError: (<T$1 extends ErrorCode>(code: T$1, message: ErrorMessage<T$1>, context: TypedErrorContext<T$1>, options?: {
+declare const TypedError: (<T extends ErrorCode>(code: T, message: ErrorMessage<T>, context: TypedErrorContext<T>, options?: {
   cause?: unknown;
   traceId?: string;
-}) => TypedError<T$1>) & {
+}) => TypedError<T>) & {
   /**
    * Create a validation error
    * @example
@@ -1992,7 +1992,7 @@ declare const TypedError: (<T$1 extends ErrorCode>(code: T$1, message: ErrorMess
   /**
    * Check if a TypedError has a specific code
    */
-  hasCode: <T$1 extends ErrorCode>(error: TypedError<ErrorCode>, code: T$1) => error is TypedError<T$1>;
+  hasCode: <T extends ErrorCode>(error: TypedError<ErrorCode>, code: T) => error is TypedError<T>;
 };
 //#endregion
 //#region src/error/typed/Validation.d.ts
@@ -2003,20 +2003,20 @@ type ValidationRule = `min:${number}` | `max:${number}` | `minLength:${number}`
 /**
  * Validator function type
  */
-type Validator<T$1> = (value: unknown) => Either<TypedError<"VALIDATION_FAILED">, T$1>;
+type Validator<T> = (value: unknown) => Either<TypedError<"VALIDATION_FAILED">, T>;
 /**
  * Field validation result
  */
-type FieldValidation<T$1> = {
+type FieldValidation<T> = {
   field: string;
   value: unknown;
-  result: Either<TypedError<"VALIDATION_FAILED">, T$1>;
+  result: Either<TypedError<"VALIDATION_FAILED">, T>;
 };
 /**
  * Form validation result
  */
-type FormValidation<T$1 extends Record<string, Type>> = Either<List<TypedError<"VALIDATION_FAILED">>, T$1>;
-declare const Validation: (<T$1 extends Type>(rule: ValidationRule) => Validator<T$1>) & {
+type FormValidation<T extends Record<string, Type>> = Either<List<TypedError<"VALIDATION_FAILED">>, T>;
+declare const Validation: (<T extends Type>(rule: ValidationRule) => Validator<T>) & {
   /**
    * Common pre-built validators
    */
@@ -2036,7 +2036,7 @@ declare const Validation: (<T$1 extends Type>(rule: ValidationRule) => Validator
    * const result = validator(25) // Right(25)
    * const error = validator(15) // Left(TypedError)
    */
-  rule: <T$1 extends Type>(rule: ValidationRule) => Validator<T$1>;
+  rule: <T extends Type>(rule: ValidationRule) => Validator<T>;
   /**
    * Combine multiple validators
    * @example
@@ -2046,7 +2046,7 @@ declare const Validation: (<T$1 extends Type>(rule: ValidationRule) => Validator
    *   Validation.rule<string>("maxLength:100")
    * )
    */
-  combine: <T$1 extends Type>(...validators: Validator<T$1>[]) => Validator<T$1>;
+  combine: <T extends Type>(...validators: Validator<T>[]) => Validator<T>;
   /**
    * Create a custom validator
    * @example
@@ -2055,7 +2055,7 @@ declare const Validation: (<T$1 extends Type>(rule: ValidationRule) => Validator
    *   "must be an even number"
    * )
    */
-  custom: <T$1 extends Type>(predicate: (value: unknown) => boolean, errorMessage: string) => Validator<T$1>;
+  custom: <T extends Type>(predicate: (value: unknown) => boolean, errorMessage: string) => Validator<T>;
   /**
    * Validate a form with multiple fields
    * @example
@@ -2066,7 +2066,7 @@ declare const Validation: (<T$1 extends Type>(rule: ValidationRule) => Validator
    * }
    * const result = Validation.form(schema, { name: "John", email: "john@example.com", age: 25 })
    */
-  form: <T$1 extends Record<string, Type>>(schema: { [K in keyof T$1]: Validator<T$1[K]> }, data: Record<string, unknown>) => FormValidation<T$1>;
+  form: <T extends Record<string, Type>>(schema: { [K in keyof T]: Validator<T[K]> }, data: Record<string, unknown>) => FormValidation<T>;
 };
 //#endregion
 //#region src/foldable/index.d.ts
@@ -2128,8 +2128,8 @@ type TryKind = <A>(a: A) => Try<A>;
  * Generic container types for type-safe operations
  * @internal
  */
-type Mappable<T$1> = {
-  map<U>(f: (value: T$1) => U): unknown;
+type Mappable<T> = {
+  map<U>(f: (value: T) => U): unknown;
 };
 /**
  * @internal
@@ -2140,8 +2140,8 @@ type Flattenable = {
 /**
  * @internal
  */
-type FlatMappable<T$1> = {
-  flatMap<U>(f: (value: T$1) => unknown): unknown;
+type FlatMappable<T> = {
+  flatMap<U>(f: (value: T) => unknown): unknown;
 };
 /**
  * Universal type that includes all potential return types from the HKT functions
@@ -2170,30 +2170,1386 @@ declare const HKT: {
   ap<F = unknown, A = unknown, B = unknown>(ff: unknown, fa: unknown): unknown;
   sequence<F = unknown, G = unknown, A = unknown>(fga: unknown): unknown;
   traverse<F = unknown, G = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown;
-  isOption: <T$1 extends Type>(value: unknown) => value is Option<T$1> & Mappable<T$1> & FlatMappable<T$1>;
-  isList: <T$1 extends Type>(value: unknown) => value is List<T$1> & Mappable<T$1> & Flattenable & FlatMappable<T$1>;
+  isOption: <T extends Type>(value: unknown) => value is Option<T> & Mappable<T> & FlatMappable<T>;
+  isList: <T extends Type>(value: unknown) => value is List<T> & Mappable<T> & Flattenable & FlatMappable<T>;
   isEither: <E extends Type, A extends Type>(value: unknown) => value is Either<E, A> & Mappable<A> & FlatMappable<A>;
-  isTry: <T$1 extends Type>(value: unknown) => value is Try<T$1> & Mappable<T$1> & FlatMappable<T$1>;
+  isTry: <T extends Type>(value: unknown) => value is Try<T> & Mappable<T> & FlatMappable<T>;
 };
 //#endregion
 //#region src/identity/Identity.d.ts
-type Identity<T$1> = {
-  id: T$1;
-  isSame?: (other: Identity<T$1>) => boolean;
+type Identity<T> = {
+  id: T;
+  isSame?: (other: Identity<T>) => boolean;
 };
-declare const Identity: (<T$1>(value: T$1) => Identity<T$1>) & {
+declare const Identity: (<T>(value: T) => Identity<T>) & {
   /**
    * Creates an Identity. Alias for Identity constructor.
    * @param value - The value to wrap
    * @returns Identity instance
    */
-  of: <T$1>(value: T$1) => Identity<T$1>;
+  of: <T>(value: T) => Identity<T>;
   /**
    * Creates an Identity. Same as of.
    * @param value - The value to wrap
    * @returns Identity instance
    */
-  pure: <T$1>(value: T$1) => Identity<T$1>;
+  pure: <T>(value: T) => Identity<T>;
+};
+//#endregion
+//#region src/io/Tag.d.ts
+/**
+ * Tag module - service identifiers for dependency injection.
+ * @module Tag
+ * @category IO
+ *
+ * Tags are used to identify services in a type-safe way.
+ * Each Tag has a unique identifier and carries the type of the service.
+ */
+/**
+ * A Tag identifies a service type and provides a unique identifier.
+ * Used for dependency injection with IO effects.
+ *
+ * @typeParam S - The service type this tag identifies
+ *
+ * @example
+ * ```typescript
+ * // Define service interfaces
+ * interface UserService {
+ *   getUser(id: string): IO<never, Error, User>
+ * }
+ *
+ * // Create a tag for the service
+ * const UserService = Tag<UserService>("UserService")
+ *
+ * // Use in effects
+ * const getUser = (id: string) =>
+ *   IO.service(UserService).flatMap(svc => svc.getUser(id))
+ * ```
+ */
+interface Tag<S extends Type> {
+  /**
+   * Unique identifier for this tag
+   */
+  readonly id: string;
+  /**
+   * Phantom type to carry the service type
+   * @internal
+   */
+  readonly _S?: S;
+  /**
+   * Type brand to distinguish tags
+   * @internal
+   */
+  readonly _tag: "Tag";
+  /**
+   * String representation
+   */
+  toString(): string;
+}
+/**
+ * Creates a Tag for identifying a service type.
+ *
+ * @param id - Unique identifier for this tag (usually the service name)
+ * @returns A Tag that can be used to request the service
+ *
+ * @example
+ * ```typescript
+ * interface Logger {
+ *   log(message: string): void
+ * }
+ *
+ * const Logger = Tag<Logger>("Logger")
+ *
+ * // Now Logger can be used to request the Logger service
+ * const program = IO.service(Logger).flatMap(logger =>
+ *   IO.sync(() => logger.log("Hello!"))
+ * )
+ * ```
+ */
+declare const Tag: <S extends Type>(id: string) => Tag<S>;
+/**
+ * Type helper to extract the service type from a Tag
+ */
+type TagService<T> = T extends Tag<infer S> ? S : never;
+//#endregion
+//#region src/io/Context.d.ts
+/**
+ * Context module - service container for dependency injection.
+ * @module Context
+ * @category IO
+ *
+ * Context is an immutable container that holds service implementations
+ * identified by their Tags.
+ */
+/**
+ * Context holds service implementations for dependency injection.
+ * It's an immutable container that maps Tags to their implementations.
+ *
+ * @typeParam R - The services contained in this context (intersection type)
+ *
+ * @example
+ * ```typescript
+ * const ctx = Context.empty()
+ *   .add(Logger, consoleLogger)
+ *   .add(Database, pgDatabase)
+ *
+ * // Access a service
+ * const logger = ctx.get(Logger) // Option<Logger>
+ * const loggerUnsafe = ctx.unsafeGet(Logger) // Logger (throws if missing)
+ * ```
+ */
+interface Context<R$1 extends Type> {
+  /**
+   * Type brand
+   * @internal
+   */
+  readonly _tag: "Context";
+  /**
+   * Phantom type for requirements
+   * @internal
+   */
+  readonly _R?: R$1;
+  /**
+   * Internal service map
+   * @internal
+   */
+  readonly services: ReadonlyMap<string, Type>;
+  /**
+   * Gets a service from the context.
+   * @param tag - The tag identifying the service
+   * @returns Some(service) if found, None otherwise
+   */
+  get<S extends Type>(tag: Tag<S>): Option<S>;
+  /**
+   * Gets a service from the context, throwing if not found.
+   * @param tag - The tag identifying the service
+   * @returns The service
+   * @throws Error if service not found
+   */
+  unsafeGet<S extends Type>(tag: Tag<S>): S;
+  /**
+   * Checks if a service exists in the context.
+   * @param tag - The tag to check
+   * @returns true if the service exists
+   */
+  has<S extends Type>(tag: Tag<S>): boolean;
+  /**
+   * Adds a service to the context, returning a new context.
+   * @param tag - The tag for the service
+   * @param service - The service implementation
+   * @returns A new context with the service added
+   */
+  add<S extends Type>(tag: Tag<S>, service: S): Context<R$1 & S>;
+  /**
+   * Merges another context into this one.
+   * @param other - The context to merge
+   * @returns A new context with all services from both
+   */
+  merge<R2 extends Type>(other: Context<R2>): Context<R$1 & R2>;
+  /**
+   * Returns the number of services in this context.
+   */
+  readonly size: number;
+  /**
+   * String representation
+   */
+  toString(): string;
+}
+/**
+ * Context companion object with utility methods
+ */
+declare const Context: {
+  /**
+   * Creates an empty context with no services.
+   */
+  empty: <R$1 extends Type = never>() => Context<R$1>;
+  /**
+   * Creates a context with a single service.
+   * @param tag - The tag for the service
+   * @param service - The service implementation
+   */
+  make: <S extends Type>(tag: Tag<S>, service: S) => Context<S>;
+  /**
+   * Checks if a value is a Context.
+   */
+  isContext: <R$1 extends Type>(value: unknown) => value is Context<R$1>;
+};
+/**
+ * Type helper to extract requirements from a Context
+ */
+type ContextServices<C> = C extends Context<infer R> ? R : never;
+/**
+ * Type helper to check if a context provides a service
+ */
+type HasService<C, S> = S extends ContextServices<C> ? true : false;
+//#endregion
+//#region src/io/Exit.d.ts
+/**
+ * Exit type module - represents the outcome of running an IO effect.
+ * @module Exit
+ * @category IO
+ */
+/**
+ * Possible outcome types for an Exit
+ */
+type ExitTag = "Success" | "Failure" | "Interrupted";
+/**
+ * Exit represents the outcome of running an IO effect.
+ * - Success: The effect completed successfully with a value
+ * - Failure: The effect failed with a typed error
+ * - Interrupted: The effect was cancelled/interrupted
+ */
+interface Exit<E extends Type, A extends Type> {
+  readonly _tag: ExitTag;
+  /**
+   * Type guard to check if this is a Success
+   */
+  isSuccess(): this is Exit<E, A> & {
+    readonly _tag: "Success";
+    value: A;
+  };
+  /**
+   * Type guard to check if this is a Failure
+   */
+  isFailure(): this is Exit<E, A> & {
+    readonly _tag: "Failure";
+    error: E;
+  };
+  /**
+   * Type guard to check if this is Interrupted
+   */
+  isInterrupted(): this is Exit<E, A> & {
+    readonly _tag: "Interrupted";
+    fiberId: string;
+  };
+  /**
+   * Maps the success value
+   */
+  map<B extends Type>(f: (a: A) => B): Exit<E, B>;
+  /**
+   * Maps the error value
+   */
+  mapError<E2 extends Type>(f: (e: E) => E2): Exit<E2, A>;
+  /**
+   * Maps both error and success values
+   */
+  mapBoth<E2 extends Type, B extends Type>(onError: (e: E) => E2, onSuccess: (a: A) => B): Exit<E2, B>;
+  /**
+   * Flat maps the success value
+   */
+  flatMap<B extends Type>(f: (a: A) => Exit<E, B>): Exit<E, B>;
+  /**
+   * Pattern matches over the Exit
+   */
+  fold<T>(onFailure: (e: E) => T, onSuccess: (a: A) => T, onInterrupted?: (fiberId: string) => T): T;
+  /**
+   * Pattern matches over the Exit with object patterns
+   */
+  match<T>(patterns: {
+    Success: (value: A) => T;
+    Failure: (error: E) => T;
+    Interrupted: (fiberId: string) => T;
+  }): T;
+  /**
+   * Returns the success value or throws
+   */
+  orThrow(): A;
+  /**
+   * Returns the success value or a default
+   */
+  orElse(defaultValue: A): A;
+  /**
+   * Converts to Option (Some for Success, None otherwise)
+   */
+  toOption(): Option<A>;
+  /**
+   * Converts to Either (Right for Success, Left for Failure)
+   * Throws if Interrupted
+   */
+  toEither(): Either<E, A>;
+  /**
+   * Returns the raw value for inspection
+   */
+  toValue(): {
+    _tag: ExitTag;
+    value?: A;
+    error?: E;
+    fiberId?: string;
+  };
+  /**
+   * String representation
+   */
+  toString(): string;
+  /**
+   * JSON serialization
+   */
+  toJSON(): {
+    _tag: ExitTag;
+    value?: A;
+    error?: E;
+    fiberId?: string;
+  };
+}
+/**
+ * Exit type for representing effect outcomes.
+ *
+ * @example
+ * ```typescript
+ * const success = Exit.succeed(42)
+ * const failure = Exit.fail(new Error("oops"))
+ * const interrupted = Exit.interrupt("fiber-123")
+ *
+ * success.fold(
+ *   (err) => console.error(err),
+ *   (value) => console.log(value),
+ *   (fiberId) => console.log("interrupted:", fiberId)
+ * )
+ * ```
+ */
+declare const Exit: (<E extends Type, A extends Type>(value: A) => Exit<E, A>) & {
+  /**
+   * Creates a Success Exit
+   */
+  succeed: <E extends Type, A extends Type>(value: A) => Exit<E, A>;
+  /**
+   * Creates a Failure Exit
+   */
+  fail: <E extends Type, A extends Type>(error: E) => Exit<E, A>;
+  /**
+   * Creates an Interrupted Exit with a fiber ID
+   */
+  interrupt: <E extends Type, A extends Type>(fiberId: string) => Exit<E, A>;
+  /**
+   * Creates an Interrupted Exit with a default fiber ID
+   */
+  interrupted: <E extends Type, A extends Type>() => Exit<E, A>;
+  /**
+   * Type guard for Success
+   */
+  isSuccess: <E extends Type, A extends Type>(exit: Exit<E, A>) => exit is Exit<E, A> & {
+    readonly _tag: "Success";
+    value: A;
+  };
+  /**
+   * Type guard for Failure
+   */
+  isFailure: <E extends Type, A extends Type>(exit: Exit<E, A>) => exit is Exit<E, A> & {
+    readonly _tag: "Failure";
+    error: E;
+  };
+  /**
+   * Type guard for Interrupted
+   */
+  isInterrupted: <E extends Type, A extends Type>(exit: Exit<E, A>) => exit is Exit<E, A> & {
+    readonly _tag: "Interrupted";
+    fiberId: string;
+  };
+  /**
+   * Creates an Exit from an Either
+   */
+  fromEither: <E extends Type, A extends Type>(either: Either<E, A>) => Exit<E, A>;
+  /**
+   * Creates an Exit from an Option
+   */
+  fromOption: <A extends Type>(option: Option<A>, onNone: () => unknown) => Exit<unknown, A>;
+  /**
+   * Combines two Exits, keeping the first failure or combining successes
+   */
+  zip: <E extends Type, A extends Type, B extends Type>(exitA: Exit<E, A>, exitB: Exit<E, B>) => Exit<E, readonly [A, B]>;
+  /**
+   * Collects all Exits into an Exit of array
+   */
+  all: <E extends Type, A extends Type>(exits: readonly Exit<E, A>[]) => Exit<E, readonly A[]>;
+};
+//#endregion
+//#region src/io/Layer.d.ts
+/**
+ * Layer module - service construction recipes.
+ * @module Layer
+ * @category IO
+ *
+ * Layers describe how to construct services, including their dependencies.
+ * They can be composed to build complex service graphs.
+ */
+/**
+ * A Layer describes how to build a service or set of services.
+ *
+ * @typeParam RIn - Required services (dependencies)
+ * @typeParam E - Possible errors during construction
+ * @typeParam ROut - Services provided by this layer
+ *
+ * @example
+ * ```typescript
+ * // A layer that provides a Logger service
+ * const LoggerLive = Layer.succeed(Logger, consoleLogger)
+ *
+ * // A layer that requires Config and provides Database
+ * const DatabaseLive = Layer.fromFunction(Database, (config: Config) =>
+ *   createDatabase(config.connectionString)
+ * )
+ * ```
+ */
+interface Layer<RIn extends Type, E extends Type, ROut extends Type> {
+  /**
+   * Type brand
+   * @internal
+   */
+  readonly _tag: "Layer";
+  /**
+   * Phantom types
+   * @internal
+   */
+  readonly _RIn?: RIn;
+  readonly _E?: E;
+  readonly _ROut?: ROut;
+  /**
+   * The build function that creates the context
+   * @internal
+   */
+  readonly build: (input: Context<RIn>) => Promise<Context<ROut>>;
+  /**
+   * Composes this layer with another, running them in sequence.
+   * The output of this layer becomes available to the next layer.
+   * @param that - Layer to compose with
+   */
+  provideToAndMerge<RIn2 extends Type, E2 extends Type, ROut2 extends Type>(that: Layer<RIn2 | ROut, E2, ROut2>): Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut | ROut2>;
+  /**
+   * Merges two independent layers.
+   * @param that - Layer to merge with
+   */
+  merge<RIn2 extends Type, E2 extends Type, ROut2 extends Type>(that: Layer<RIn2, E2, ROut2>): Layer<RIn | RIn2, E | E2, ROut | ROut2>;
+  /**
+   * Maps the output of this layer.
+   * @param f - Function to transform the output
+   */
+  map<ROut2 extends Type>(f: (ctx: Context<ROut>) => Context<ROut2>): Layer<RIn, E, ROut2>;
+  /**
+   * String representation
+   */
+  toString(): string;
+}
+/**
+ * Layer companion object with construction methods
+ */
+declare const Layer: {
+  /**
+   * Creates a layer that provides a service with a constant value.
+   * @param tag - The service tag
+   * @param service - The service implementation
+   */
+  succeed: <S extends Type>(tag: Tag<S>, service: S) => Layer<never, never, S>;
+  /**
+   * Creates a layer from an async function.
+   * @param tag - The service tag
+   * @param f - Async function to create the service
+   */
+  effect: <S extends Type, E extends Type>(tag: Tag<S>, f: () => Promise<S>) => Layer<never, E, S>;
+  /**
+   * Creates a layer from a sync function.
+   * @param tag - The service tag
+   * @param f - Function to create the service
+   */
+  sync: <S extends Type>(tag: Tag<S>, f: () => S) => Layer<never, never, S>;
+  /**
+   * Creates a layer that depends on another service.
+   * @param tag - The service tag to provide
+   * @param depTag - The dependency tag
+   * @param f - Function to create the service from the dependency
+   */
+  fromService: <Dep extends Type, S extends Type>(tag: Tag<S>, depTag: Tag<Dep>, f: (dep: Dep) => S) => Layer<Dep, never, S>;
+  /**
+   * Creates a layer that depends on another service (async).
+   * @param tag - The service tag to provide
+   * @param depTag - The dependency tag
+   * @param f - Async function to create the service from the dependency
+   */
+  fromServiceEffect: <Dep extends Type, E extends Type, S extends Type>(tag: Tag<S>, depTag: Tag<Dep>, f: (dep: Dep) => Promise<S>) => Layer<Dep, E, S>;
+  /**
+   * Creates a layer from a context.
+   * @param context - The context to use
+   */
+  fromContext: <R$1 extends Type>(context: Context<R$1>) => Layer<never, never, R$1>;
+  /**
+   * Creates an empty layer that provides nothing.
+   */
+  empty: () => Layer<never, never, never>;
+  /**
+   * Merges multiple layers into one.
+   * @param layers - Layers to merge
+   */
+  mergeAll: <Layers extends Layer<Type, Type, Type>[]>(...layers: Layers) => Layer<Layers[number] extends Layer<infer RIn, Type, Type> ? RIn : never, Layers[number] extends Layer<Type, infer E, Type> ? E : never, Layers[number] extends Layer<Type, Type, infer ROut> ? ROut : never>;
+};
+/**
+ * Type helper to extract input requirements from a Layer
+ */
+type LayerInput<L> = L extends Layer<infer RIn, Type, Type> ? RIn : never;
+/**
+ * Type helper to extract error type from a Layer
+ */
+type LayerError<L> = L extends Layer<Type, infer E, Type> ? E : never;
+/**
+ * Type helper to extract output services from a Layer
+ */
+type LayerOutput<L> = L extends Layer<Type, Type, infer ROut> ? ROut : never;
+//#endregion
+//#region src/io/IO.d.ts
+/**
+ * Error thrown when an effect times out.
+ */
+declare class TimeoutError extends Error {
+  readonly duration: number;
+  readonly _tag: "TimeoutError";
+  constructor(duration: number, message?: string);
+}
+/**
+ * Error thrown when an effect is interrupted.
+ */
+declare class InterruptedError extends Error {
+  readonly _tag: "InterruptedError";
+  constructor(message?: string);
+}
+/**
+ * IO Effect type module - a lazy, composable effect type with typed errors.
+ * @module IO
+ * @category IO
+ *
+ * IO<R, E, A> represents an effectful computation that:
+ * - Requires environment R to run
+ * - May fail with error E
+ * - Produces value A on success
+ *
+ * Key features:
+ * - Lazy execution (nothing runs until explicitly executed)
+ * - Unified sync/async API
+ * - Typed errors at compile time
+ * - Composable via map/flatMap
+ */
+/**
+ * Internal effect representation types
+ */
+type IOEffect<R$1, E, A> = {
+  readonly _tag: "Sync";
+  readonly thunk: () => A;
+} | {
+  readonly _tag: "Async";
+  readonly thunk: () => Promise<A>;
+} | {
+  readonly _tag: "Auto";
+  readonly thunk: () => A | Promise<A>;
+} | {
+  readonly _tag: "Succeed";
+  readonly value: A;
+} | {
+  readonly _tag: "Fail";
+  readonly error: E;
+} | {
+  readonly _tag: "Die";
+  readonly defect: unknown;
+} | {
+  readonly _tag: "Interrupt";
+} | {
+  readonly _tag: "FlatMap";
+  readonly effect: IO<R$1, E, unknown>;
+  readonly f: (a: unknown) => IO<R$1, E, A>;
+} | {
+  readonly _tag: "Map";
+  readonly effect: IO<R$1, E, unknown>;
+  readonly f: (a: unknown) => A;
+} | {
+  readonly _tag: "MapError";
+  readonly effect: IO<R$1, unknown, A>;
+  readonly f: (e: unknown) => E;
+} | {
+  readonly _tag: "Recover";
+  readonly effect: IO<R$1, E, A>;
+  readonly fallback: A;
+} | {
+  readonly _tag: "RecoverWith";
+  readonly effect: IO<R$1, E, A>;
+  readonly f: (e: E) => IO<R$1, E, A>;
+} | {
+  readonly _tag: "Fold";
+  readonly effect: IO<R$1, E, unknown>;
+  readonly onFailure: (e: E) => A;
+  readonly onSuccess: (a: unknown) => A;
+} | {
+  readonly _tag: "Bracket";
+  readonly acquire: IO<R$1, E, unknown>;
+  readonly use: (a: unknown) => IO<R$1, E, A>;
+  readonly release: (a: unknown) => IO<R$1, never, void>;
+} | {
+  readonly _tag: "Race";
+  readonly effects: readonly IO<R$1, E, A>[];
+} | {
+  readonly _tag: "Timeout";
+  readonly effect: IO<R$1, E, A>;
+  readonly duration: number;
+} | {
+  readonly _tag: "Service";
+  readonly tag: Tag<A>;
+} | {
+  readonly _tag: "ProvideContext";
+  readonly effect: IO<R$1, E, A>;
+  readonly context: Context<R$1>;
+};
+/**
+ * IO<R, E, A> represents a lazy, composable effect.
+ *
+ * @typeParam R - Requirements (environment/dependencies needed to run)
+ * @typeParam E - Error type (typed failures)
+ * @typeParam A - Success type (value produced on success)
+ */
+interface IO<R$1 extends Type, E extends Type, A extends Type> {
+  /**
+   * Internal effect representation
+   * @internal
+   */
+  readonly _effect: IOEffect<R$1, E, A>;
+  /**
+   * Phantom type for requirements
+   * @internal
+   */
+  readonly _R?: R$1;
+  /**
+   * Phantom type for error
+   * @internal
+   */
+  readonly _E?: E;
+  /**
+   * Phantom type for success
+   * @internal
+   */
+  readonly _A?: A;
+  /**
+   * Transforms the success value.
+   * @param f - Function to apply to the success value
+   * @returns New IO with transformed value
+   */
+  map<B extends Type>(f: (a: A) => B): IO<R$1, E, B>;
+  /**
+   * Chains another IO effect based on the success value.
+   * @param f - Function returning next IO effect
+   * @returns New IO with combined effects
+   */
+  flatMap<R2 extends Type, E2 extends Type, B extends Type>(f: (a: A) => IO<R2, E2, B>): IO<R$1 | R2, E | E2, B>;
+  /**
+   * Applies a side effect without changing the value.
+   * @param f - Side effect function
+   * @returns Same IO for chaining
+   */
+  tap(f: (a: A) => void): IO<R$1, E, A>;
+  /**
+   * Applies an effectful side effect without changing the value.
+   * @param f - Function returning IO for side effect
+   * @returns Same value after running side effect
+   */
+  tapEffect<R2 extends Type, E2 extends Type, B extends Type>(f: (a: A) => IO<R2, E2, B>): IO<R$1 | R2, E | E2, A>;
+  /**
+   * Transforms the error value.
+   * @param f - Function to apply to the error
+   * @returns New IO with transformed error
+   */
+  mapError<E2 extends Type>(f: (e: E) => E2): IO<R$1, E2, A>;
+  /**
+   * Executes a side effect on the error without changing it.
+   * Useful for logging errors while preserving the error chain.
+   *
+   * @param f - Side effect function to run on error
+   * @returns Same IO with the side effect attached
+   *
+   * @example
+   * ```typescript
+   * const io = IO.asyncResult(() => query(), toError)
+   *   .tapError(err => console.error('Query failed:', err))
+   *   .map(data => transform(data))
+   * ```
+   */
+  tapError(f: (e: E) => void): IO<R$1, E, A>;
+  /**
+   * Recovers from any error with a fallback value.
+   * @param fallback - Value to use on error
+   * @returns New IO that never fails
+   */
+  recover<B extends Type>(fallback: B): IO<R$1, never, A | B>;
+  /**
+   * Recovers from error by running another effect.
+   * @param f - Function returning recovery effect
+   * @returns New IO with error handling
+   */
+  recoverWith<R2 extends Type, E2 extends Type, B extends Type>(f: (e: E) => IO<R2, E2, B>): IO<R$1 | R2, E2, A | B>;
+  /**
+   * Pattern matches on success and failure.
+   * @param onFailure - Handler for failures
+   * @param onSuccess - Handler for successes
+   * @returns New IO with handled result
+   */
+  fold<B extends Type>(onFailure: (e: E) => B, onSuccess: (a: A) => B): IO<R$1, never, B>;
+  /**
+   * Pattern matches with object pattern syntax.
+   */
+  match<B extends Type>(patterns: {
+    failure: (e: E) => B;
+    success: (a: A) => B;
+  }): IO<R$1, never, B>;
+  /**
+   * Catches errors with a specific tag and handles them.
+   * @param tag - The error tag to catch
+   * @param handler - Handler for the caught error
+   */
+  catchTag<K$1 extends (E extends {
+    _tag: string;
+  } ? E["_tag"] : never), R2 extends Type, E2 extends Type, B extends Type>(tag: K$1, handler: (e: Extract<E, {
+    _tag: K$1;
+  }>) => IO<R2, E2, B>): IO<R$1 | R2, Exclude<E, {
+    _tag: K$1;
+  }> | E2, A | B>;
+  /**
+   * Catches all errors (alias for recoverWith).
+   */
+  catchAll<R2 extends Type, E2 extends Type, B extends Type>(handler: (e: E) => IO<R2, E2, B>): IO<R$1 | R2, E2, A | B>;
+  /**
+   * Retries the effect up to n times on failure.
+   * @param n - Maximum number of retries
+   */
+  retry(n: number): IO<R$1, E, A>;
+  /**
+   * Retries the effect with a delay between attempts.
+   * @param n - Maximum number of retries
+   * @param delayMs - Delay between retries in milliseconds
+   */
+  retryWithDelay(n: number, delayMs: number): IO<R$1, E, A>;
+  /**
+   * Sequences two IOs, keeping the second value.
+   */
+  zipRight<R2 extends Type, E2 extends Type, B extends Type>(that: IO<R2, E2, B>): IO<R$1 | R2, E | E2, B>;
+  /**
+   * Sequences two IOs, keeping the first value.
+   */
+  zipLeft<R2 extends Type, E2 extends Type, B extends Type>(that: IO<R2, E2, B>): IO<R$1 | R2, E | E2, A>;
+  /**
+   * Zips two IOs into a tuple.
+   */
+  zip<R2 extends Type, E2 extends Type, B extends Type>(that: IO<R2, E2, B>): IO<R$1 | R2, E | E2, readonly [A, B]>;
+  /**
+   * Flattens a nested IO.
+   */
+  flatten<R2 extends Type, E2 extends Type, B extends Type>(this: IO<R$1, E, IO<R2, E2, B>>): IO<R$1 | R2, E | E2, B>;
+  /**
+   * Provides a context to satisfy the requirements of this effect.
+   * @param context - The context containing required services
+   */
+  provideContext<R2 extends R$1>(context: Context<R2>): IO<Exclude<R$1, R2>, E, A>;
+  /**
+   * Provides a single service to satisfy part of the requirements.
+   * @param tag - The service tag
+   * @param service - The service implementation
+   */
+  provideService<S extends Type>(tag: Tag<S>, service: S): IO<Exclude<R$1, S>, E, A>;
+  /**
+   * Provides services using a layer.
+   * @param layer - The layer that provides services
+   */
+  provideLayer<RIn extends Type, E2 extends Type, ROut extends R$1>(layer: Layer<RIn, E2, ROut>): IO<RIn | Exclude<R$1, ROut>, E | E2, A>;
+  /**
+   * Runs the effect and returns a Promise of the value.
+   * Throws on error. Requires R = never.
+   */
+  run(this: IO<never, E, A>): Promise<A>;
+  /**
+   * Runs a sync effect and returns the value.
+   * Throws if the effect is async or has unmet requirements.
+   */
+  runSync(this: IO<never, E, A>): A;
+  /**
+   * Runs the effect and returns an Either.
+   */
+  runEither(this: IO<never, E, A>): Promise<Either<E, A>>;
+  /**
+   * Runs the effect and returns an Exit.
+   */
+  runExit(this: IO<never, E, A>): Promise<Exit<E, A>>;
+  /**
+   * Runs the effect and returns an Option.
+   * Some(value) on success, None on failure.
+   */
+  runOption(this: IO<never, E, A>): Promise<Option<A>>;
+  /**
+   * Runs the effect and returns a Try.
+   * Success(value) on success, Failure(error) on failure.
+   */
+  runTry(this: IO<never, E, A>): Promise<ReturnType<typeof Try<A>>>;
+  /**
+   * Pipes the IO through a function.
+   */
+  pipe<B>(f: (self: IO<R$1, E, A>) => B): B;
+  /**
+   * Delays execution by the specified milliseconds.
+   */
+  delay(ms: number): IO<R$1, E, A>;
+  /**
+   * Fails with TimeoutError if the effect doesn't complete within the specified duration.
+   * @param ms - Maximum time in milliseconds
+   */
+  timeout(ms: number): IO<R$1, E | TimeoutError, A>;
+  /**
+   * Returns a fallback value if the effect doesn't complete within the specified duration.
+   * @param ms - Maximum time in milliseconds
+   * @param fallback - Value to return on timeout
+   */
+  timeoutTo<B extends Type>(ms: number, fallback: B): IO<R$1, E, A | B>;
+  /**
+   * Converts to string representation.
+   */
+  toString(): string;
+  /**
+   * Converts to JSON representation.
+   */
+  toJSON(): {
+    _tag: string;
+    effect: unknown;
+  };
+  /**
+   * Makes IO iterable for generator do-notation (yield* syntax).
+   * Yields the IO itself, allowing IO.gen to extract the value.
+   */
+  [Symbol.iterator](): Generator<IO<R$1, E, A>, A, A>;
+}
+/**
+ * Do-builder interface for chaining binds and maps
+ */
+interface DoBuilder<R$1 extends Type, E extends Type, Ctx extends Record<string, Type>> {
+  /**
+   * The underlying IO effect
+   */
+  readonly effect: IO<R$1, E, Ctx>;
+  /**
+   * Binds the result of an effect to a named property in the context.
+   * @param name - The property name to bind to
+   * @param f - Function that returns an IO effect (receives current context)
+   */
+  bind<N extends string, R2 extends Type, E2 extends Type, A extends Type>(name: Exclude<N, keyof Ctx>, f: (ctx: Ctx) => IO<R2, E2, A>): DoBuilder<R$1 | R2, E | E2, Ctx & Record<N, A>>;
+  /**
+   * Binds a pure value to a named property in the context.
+   * @param name - The property name to bind to
+   * @param f - Function that returns a value (receives current context)
+   */
+  let<N extends string, A extends Type>(name: Exclude<N, keyof Ctx>, f: (ctx: Ctx) => A): DoBuilder<R$1, E, Ctx & Record<N, A>>;
+  /**
+   * Transforms the final context value.
+   * @param f - Function to transform the context
+   */
+  map<B extends Type>(f: (ctx: Ctx) => B): IO<R$1, E, B>;
+  /**
+   * Chains to another IO based on the context.
+   * @param f - Function that returns an IO effect
+   */
+  flatMap<R2 extends Type, E2 extends Type, B extends Type>(f: (ctx: Ctx) => IO<R2, E2, B>): IO<R$1 | R2, E | E2, B>;
+  /**
+   * Executes a side effect without changing the context.
+   * @param f - Side effect function
+   */
+  tap(f: (ctx: Ctx) => void): DoBuilder<R$1, E, Ctx>;
+  /**
+   * Executes an effectful side effect without changing the context.
+   * @param f - Function returning an IO for the side effect
+   */
+  tapEffect<R2 extends Type, E2 extends Type, B extends Type>(f: (ctx: Ctx) => IO<R2, E2, B>): DoBuilder<R$1 | R2, E | E2, Ctx>;
+  /**
+   * Returns the final context as is.
+   */
+  done(): IO<R$1, E, Ctx>;
+}
+/**
+ * IO effect type for lazy, composable effects with typed errors.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const program = IO.sync(() => 42)
+ *   .map(x => x * 2)
+ *   .flatMap(x => IO.succeed(x + 1))
+ *
+ * const result = await program.run() // 85
+ *
+ * // Error handling
+ * const safe = IO.tryPromise({
+ *   try: () => fetch('/api/data'),
+ *   catch: (e) => new NetworkError(e)
+ * })
+ *   .map(res => res.json())
+ *   .recover({ fallback: 'default' })
+ *
+ * // Composition
+ * const composed = IO.all([
+ *   IO.succeed(1),
+ *   IO.succeed(2),
+ *   IO.succeed(3)
+ * ]) // IO<never, never, [1, 2, 3]>
+ * ```
+ */
+declare const IO: (<A extends Type>(f: () => A | Promise<A>) => IO<never, unknown, A>) & {
+  /**
+   * Creates an IO from a synchronous thunk.
+   * The function is not executed until the IO is run.
+   */
+  sync: <A extends Type>(f: () => A) => IO<never, never, A>;
+  /**
+   * Creates an IO that succeeds with the given value.
+   */
+  succeed: <A extends Type>(value: A) => IO<never, never, A>;
+  /**
+   * Creates an IO that fails with the given error.
+   */
+  fail: <E extends Type>(error: E) => IO<never, E, never>;
+  /**
+   * Creates an IO that dies with an unrecoverable defect.
+   */
+  die: (defect: unknown) => IO<never, never, never>;
+  /**
+   * Creates an IO from an async thunk.
+   * The Promise is not created until the IO is run.
+   */
+  async: <A extends Type>(f: () => Promise<A>) => IO<never, unknown, A>;
+  /**
+   * Creates an IO from a Promise with error handling.
+   */
+  tryPromise: <A extends Type, E extends Type>(opts: {
+    readonly try: () => Promise<A>;
+    readonly catch: (error: unknown) => E;
+  }) => IO<never, E, A>;
+  /**
+   * Creates an IO from a function that might throw.
+   */
+  tryCatch: <A extends Type, E extends Type>(f: () => A, onError: (error: unknown) => E) => IO<never, E, A>;
+  /**
+   * Lifts a synchronous function into an IO-returning function.
+   */
+  liftSync: <Args extends unknown[], A extends Type>(f: (...args: Args) => A) => (...args: Args) => IO<never, never, A>;
+  /**
+   * Lifts a Promise-returning function into an IO-returning function.
+   */
+  liftPromise: <Args extends unknown[], A extends Type>(f: (...args: Args) => Promise<A>) => (...args: Args) => IO<never, unknown, A>;
+  /**
+   * Creates an IO from an Either.
+   */
+  fromEither: <E extends Type, A extends Type>(either: Either<E, A>) => IO<never, E, A>;
+  /**
+   * Creates an IO from an Option.
+   */
+  fromOption: <A extends Type>(option: Option<A>) => IO<never, void, A>;
+  /**
+   * Creates an IO from an Option with custom error.
+   */
+  fromOptionOrFail: <E extends Type, A extends Type>(option: Option<A>, onNone: () => E) => IO<never, E, A>;
+  /**
+   * Creates an IO from a Try.
+   */
+  fromTry: <A extends Type>(t: ReturnType<typeof Try<A>>) => IO<never, Error, A>;
+  /**
+   * Creates an IO from a result object with data/error pattern.
+   * If error is present (truthy), fails with the error.
+   * Otherwise succeeds with Option-wrapped data (None if data is null/undefined).
+   *
+   * This handles the common `{ data, error }` response pattern used by
+   * Supabase, many REST APIs, and similar libraries.
+   *
+   * @example
+   * ```typescript
+   * const response = { data: user, error: null }
+   * const io = IO.fromResult(response) // IO<never, null, Option<User>> -> Some(user)
+   *
+   * const emptyResponse = { data: null, error: null }
+   * const emptyIo = IO.fromResult(emptyResponse) // IO<never, null, Option<User>> -> None
+   *
+   * const errorResponse = { data: null, error: new Error("Not found") }
+   * const failedIo = IO.fromResult(errorResponse) // IO<never, Error, Option<null>> -> fails
+   * ```
+   */
+  fromResult: <D extends Type, E extends Type>(result: {
+    data: D | null;
+    error: E | null;
+  }) => IO<never, E, Option<D>>;
+  /**
+   * Creates an IO from an async thunk with typed error handling.
+   * Catches any thrown errors and maps them using the provided function.
+   * Supports cancellation via AbortSignal.
+   *
+   * This is a simpler alternative to `tryPromise` that takes a direct
+   * error mapper function instead of an options object.
+   *
+   * @param f - Async function to execute (receives optional AbortSignal)
+   * @param onError - Function to map caught errors to typed error E
+   * @param signal - Optional AbortSignal for cancellation support
+   *
+   * @example
+   * ```typescript
+   * const io = IO.tryAsync(
+   *   () => fetch('/api/users').then(r => r.json()),
+   *   (e) => new ApiError(e)
+   * )
+   *
+   * // With cancellation:
+   * const controller = new AbortController()
+   * const io = IO.tryAsync(
+   *   (signal) => fetch('/api/users', { signal }).then(r => r.json()),
+   *   (e) => new ApiError(e),
+   *   controller.signal
+   * )
+   * controller.abort() // Cancels the request
+   * ```
+   */
+  tryAsync: <A extends Type, E extends Type>(f: (signal?: AbortSignal) => Promise<A>, onError: (error: unknown) => E, signal?: AbortSignal) => IO<never, E, A>;
+  /**
+   * Creates an IO from an async function that returns { data, error }.
+   * Handles both:
+   * - Thrown errors (mapped via onThrow)
+   * - Returned errors in the result object
+   * Supports cancellation via AbortSignal.
+   *
+   * This is the most ergonomic way to wrap Supabase and similar API calls.
+   *
+   * @param f - Async function returning { data, error } object (receives optional AbortSignal)
+   * @param onThrow - Function to map thrown errors to typed error E
+   * @param config - Optional configuration for custom field names and cancellation
+   *
+   * @example
+   * ```typescript
+   * // Supabase query in one line:
+   * const getUser = (id: string): IO<never, Error, Option<User>> =>
+   *   IO.asyncResult(
+   *     () => supabase.from('users').select('*').eq('id', id).single(),
+   *     toError
+   *   )
+   *
+   * // With custom field names:
+   * const result = IO.asyncResult(
+   *   () => customApi.fetch(),
+   *   toError,
+   *   { dataKey: 'result', errorKey: 'err' }
+   * )
+   *
+   * // With cancellation:
+   * const controller = new AbortController()
+   * const getUser = IO.asyncResult(
+   *   (signal) => supabase.from('users').abortSignal(signal).select('*').single(),
+   *   toError,
+   *   { signal: controller.signal }
+   * )
+   * controller.abort() // Cancels the request
+   * ```
+   */
+  asyncResult: <D extends Type, E extends Type>(f: (signal?: AbortSignal) => Promise<Record<string, unknown>>, onThrow: (error: unknown) => E, config?: {
+    dataKey?: string;
+    errorKey?: string;
+    signal?: AbortSignal;
+  }) => IO<never, E, Option<D>>;
+  /**
+   * Creates an IO that requires a service identified by the tag.
+   * The service must be provided before the effect can be run.
+   *
+   * @example
+   * ```typescript
+   * interface Logger {
+   *   log(message: string): void
+   * }
+   * const Logger = Tag<Logger>("Logger")
+   *
+   * const program = IO.service(Logger).flatMap(logger =>
+   *   IO.sync(() => logger.log("Hello!"))
+   * )
+   *
+   * // Provide the service to run
+   * program.provideService(Logger, consoleLogger).run()
+   * ```
+   */
+  service: <S extends Type>(tag: Tag<S>) => IO<S, never, S>;
+  /**
+   * Accesses a service and applies a function to it.
+   */
+  serviceWith: <S extends Type, A extends Type>(tag: Tag<S>, f: (service: S) => A) => IO<S, never, A>;
+  /**
+   * Accesses a service and applies an effectful function to it.
+   */
+  serviceWithIO: <S extends Type, R$1 extends Type, E extends Type, A extends Type>(tag: Tag<S>, f: (service: S) => IO<R$1, E, A>) => IO<S | R$1, E, A>;
+  /**
+   * Accesses multiple services and applies a function to them.
+   * Provides a convenient way to work with multiple dependencies.
+   *
+   * @example
+   * ```typescript
+   * const program = IO.withServices(
+   *   { logger: Logger, db: Database },
+   *   ({ logger, db }) => {
+   *     logger.log("Querying...")
+   *     return db.query("SELECT * FROM users")
+   *   }
+   * )
+   * ```
+   */
+  withServices: <Services extends Record<string, Tag<Type>>, A extends Type>(services: Services, f: (ctx: { [K in keyof Services]: TagService<Services[K]> }) => A | Promise<A>) => IO<TagService<Services[keyof Services]>, unknown, A>;
+  /**
+   * Runs all IOs in parallel and collects results.
+   */
+  all: <R$1 extends Type, E extends Type, A extends Type>(effects: readonly IO<R$1, E, A>[]) => IO<R$1, E, readonly A[]>;
+  /**
+   * Runs IOs in sequence, returning the first success or last failure.
+   */
+  firstSuccessOf: <R$1 extends Type, E extends Type, A extends Type>(effects: readonly IO<R$1, E, A>[]) => IO<R$1, E, A>;
+  /**
+   * Creates an IO that sleeps for the specified duration.
+   */
+  sleep: (ms: number) => IO<never, never, void>;
+  /**
+   * Creates an IO that never completes.
+   */
+  never: <A extends Type = never>() => IO<never, never, A>;
+  /**
+   * Creates a unit IO.
+   */
+  readonly unit: IO<never, never, void>;
+  /**
+   * Converts a nullable value to an IO.
+   */
+  fromNullable: <A extends Type>(value: A | null | undefined) => IO<never, void, A>;
+  /**
+   * Creates an IO that is immediately interrupted.
+   */
+  interrupt: () => IO<never, never, never>;
+  /**
+   * Ensures a resource is properly released after use.
+   * The release function always runs, even if use fails.
+   *
+   * @example
+   * ```typescript
+   * const withFile = IO.bracket(
+   *   IO.sync(() => openFile("data.txt")),   // acquire
+   *   file => IO.async(() => file.read()),    // use
+   *   file => IO.sync(() => file.close())     // release
+   * )
+   * ```
+   */
+  bracket: <R$1 extends Type, E extends Type, A extends Type, B extends Type>(acquire: IO<R$1, E, A>, use: (a: A) => IO<R$1, E, B>, release: (a: A) => IO<R$1, never, void>) => IO<R$1, E, B>;
+  /**
+   * Alias for bracket with a more descriptive name.
+   */
+  acquireRelease: <R$1 extends Type, E extends Type, A extends Type, B extends Type>(acquire: IO<R$1, E, A>, use: (a: A) => IO<R$1, E, B>, release: (a: A) => IO<R$1, never, void>) => IO<R$1, E, B>;
+  /**
+   * Races multiple effects, returning the first to complete.
+   * Note: Other effects are NOT cancelled (JS limitation).
+   *
+   * @example
+   * ```typescript
+   * const result = await IO.race([
+   *   IO.sleep(1000).map(() => "slow"),
+   *   IO.sleep(100).map(() => "fast")
+   * ]).run() // "fast"
+   * ```
+   */
+  race: <R$1 extends Type, E extends Type, A extends Type>(effects: readonly IO<R$1, E, A>[]) => IO<R$1, E, A>;
+  /**
+   * Returns the first effect to succeed, or fails if all fail.
+   *
+   * @example
+   * ```typescript
+   * const result = await IO.any([
+   *   IO.fail("error1"),
+   *   IO.succeed("success"),
+   *   IO.fail("error2")
+   * ]).run() // "success"
+   * ```
+   */
+  any: <R$1 extends Type, E extends Type, A extends Type>(effects: readonly IO<R$1, E, A>[]) => IO<R$1, E, A>;
+  /**
+   * Executes an effect for each element in the array, collecting results.
+   *
+   * @example
+   * ```typescript
+   * const results = await IO.forEach([1, 2, 3], n =>
+   *   IO.sync(() => n * 2)
+   * ).run() // [2, 4, 6]
+   * ```
+   */
+  forEach: <R$1 extends Type, E extends Type, A extends Type, B extends Type>(items: readonly A[], f: (a: A) => IO<R$1, E, B>) => IO<R$1, E, readonly B[]>;
+  /**
+   * Executes effects for each element in parallel (limited concurrency coming later).
+   * Alias for forEach.
+   */
+  forEachPar: <R$1 extends Type, E extends Type, A extends Type, B extends Type>(items: readonly A[], f: (a: A) => IO<R$1, E, B>) => IO<R$1, E, readonly B[]>;
+  /**
+   * Creates a timeout effect that fails with TimeoutError.
+   */
+  timeout: <R$1 extends Type, E extends Type, A extends Type>(effect: IO<R$1, E, A>, ms: number) => IO<R$1, E | TimeoutError, A>;
+  /**
+   * Creates an IO from a generator function.
+   * This enables do-notation style programming.
+   *
+   * @example
+   * ```typescript
+   * const program = IO.gen(function* () {
+   *   const a = yield* IO.succeed(1)
+   *   const b = yield* IO.succeed(2)
+   *   return a + b
+   * })
+   * ```
+   */
+  gen: <A extends Type>(f: () => Generator<IO<any, any, any>, A, any>) => IO<never, any, A>;
+  /**
+   * Starts a Do-builder context for binding values.
+   * This enables do-notation style programming without generators.
+   *
+   * @example
+   * ```typescript
+   * const program = IO.Do
+   *   .bind("user", () => getUser("123"))
+   *   .bind("posts", ({ user }) => getPosts(user.id))
+   *   .let("count", ({ posts }) => posts.length)
+   *   .map(({ user, posts, count }) => ({ user, posts, count }))
+   * ```
+   */
+  readonly Do: DoBuilder<never, never, Record<never, never>>;
+};
+/**
+ * An IO with no requirements and no error
+ */
+type UIO<A extends Type> = IO<never, never, A>;
+/**
+ * An IO with no requirements
+ */
+type Task<E extends Type, A extends Type> = IO<never, E, A>;
+/**
+ * An IO with no error
+ */
+type RIO<R$1 extends Type, A extends Type> = IO<R$1, never, A>;
+//#endregion
+//#region src/io/TestClock.d.ts
+/**
+ * TestClock interface for controlling time in tests
+ */
+interface TestClock {
+  /**
+   * Current virtual time in milliseconds
+   */
+  readonly currentTime: number;
+  /**
+   * Advances the clock by the specified duration.
+   * All scheduled tasks with a time <= new current time will be executed.
+   * @param ms - Milliseconds to advance
+   */
+  advance(ms: number): Promise<void>;
+  /**
+   * Sets the clock to a specific time.
+   * @param ms - The absolute time to set
+   */
+  setTime(ms: number): Promise<void>;
+  /**
+   * Runs all pending tasks immediately.
+   */
+  runAll(): Promise<void>;
+  /**
+   * Gets the number of pending scheduled tasks.
+   */
+  readonly pendingCount: number;
+  /**
+   * Sleeps for the specified duration using virtual time.
+   * @param ms - Milliseconds to sleep
+   */
+  sleep(ms: number): Promise<void>;
+}
+/**
+ * Service tag for TestClock
+ */
+declare const TestClockTag: Tag<TestClock>;
+/**
+ * TestClock companion object with factory methods
+ */
+declare const TestClock: {
+  /**
+   * Creates a new TestClock instance
+   */
+  make: () => TestClock;
+  /**
+   * Tag for dependency injection
+   */
+  tag: Tag<TestClock>;
+  /**
+   * Creates a test environment with a TestClock and runs the test function.
+   *
+   * @example
+   * ```typescript
+   * await TestClock.test(async (clock) => {
+   *   const result = await IO.sleep(100).map(() => "done")
+   *     .pipe(clock.runWithClock)
+   *   expect(result).toBe("done")
+   * })
+   * ```
+   */
+  test: <A>(f: (clock: TestClock) => Promise<A>) => Promise<A>;
+  /**
+   * Creates an IO that accesses the TestClock from the environment.
+   */
+  get: IO<TestClock, never, TestClock>;
+  /**
+   * Creates an IO that advances the TestClock.
+   */
+  advance: (ms: number) => IO<TestClock, never, void>;
+  /**
+   * Creates an IO that sets the TestClock time.
+   */
+  setTime: (ms: number) => IO<TestClock, never, void>;
+  /**
+   * Creates an IO that runs all pending tasks.
+   */
+  runAll: IO<TestClock, unknown, void>;
+  /**
+   * Creates a context with a TestClock for testing.
+   */
+  context: () => {
+    clock: TestClock;
+    context: ReturnType<typeof Context.make<TestClock>>;
+  };
+};
+/**
+ * TestContext provides a complete test environment with mocked services.
+ */
+interface TestContext<R$1 extends Type> {
+  /**
+   * The context containing test services
+   */
+  readonly context: ReturnType<typeof Context.empty<R$1>>;
+  /**
+   * The TestClock for controlling time
+   */
+  readonly clock: TestClock;
+  /**
+   * Adds a service to the test context
+   */
+  withService<S extends Type>(tag: Tag<S>, service: S): TestContext<R$1 & S>;
+  /**
+   * Provides the test context to an IO effect and runs it
+   */
+  run<E extends Type, A extends Type>(effect: IO<R$1, E, A>): Promise<A>;
+}
+/**
+ * Creates a TestContext for testing IO effects with mocked services.
+ *
+ * @example
+ * ```typescript
+ * const ctx = TestContext.make()
+ *   .withService(Logger, mockLogger)
+ *   .withService(Database, mockDb)
+ *
+ * const result = await ctx.run(myProgram)
+ * ```
+ */
+declare const TestContext: {
+  /**
+   * Creates a new empty TestContext
+   */
+  make: <R$1 extends Type = never>() => TestContext<R$1>;
+  /**
+   * Creates a TestContext with a TestClock already provided
+   */
+  withClock: () => TestContext<TestClock>;
 };
 //#endregion
 //#region src/lazy/Lazy.d.ts
@@ -2207,7 +3563,7 @@ declare const Identity: (<T$1>(value: T$1) => Identity<T$1>) & {
  * It provides memoization and safe evaluation with integration to Option, Either, and Try.
  * @typeParam T - The type of the value to be computed
  */
-interface Lazy<T$1 extends Type> extends FunctypeBase<T$1, "Lazy">, Extractable<T$1>, Pipe<T$1> {
+interface Lazy<T extends Type> extends FunctypeBase<T, "Lazy">, Extractable<T>, Pipe<T> {
   /** Tag identifying this as a Lazy type */
   readonly _tag: "Lazy";
   /** Whether the computation has been evaluated */
@@ -2217,138 +3573,138 @@ interface Lazy<T$1 extends Type> extends FunctypeBase<T$1, "Lazy">, Extractable<
    * @param defaultValue - The value to return if computation fails
    * @returns The computed value or defaultValue
    */
-  orElse(defaultValue: T$1): T$1;
+  orElse(defaultValue: T): T;
   /**
    * Returns the computed value or null if computation fails
    * @returns The computed value or null
    */
-  orNull(): T$1 | null;
+  orNull(): T | null;
   /**
    * Returns the computed value or throws an error if computation fails
    * @param error - Optional custom error to throw. If not provided, throws the computation error or a default error
    * @returns The computed value
    * @throws The specified error, computation error, or a default error
    */
-  orThrow(error?: Error): T$1;
+  orThrow(error?: Error): T;
   /**
    * Returns this Lazy if computation succeeds, otherwise returns the alternative Lazy
    * @param alternative - The alternative Lazy to use if computation fails
    * @returns This Lazy or the alternative
    */
-  or(alternative: Lazy<T$1>): Lazy<T$1>;
+  or(alternative: Lazy<T>): Lazy<T>;
   /**
    * Maps the value inside the Lazy using the provided function
    * @param f - The mapping function
    * @returns A new Lazy containing the mapped value
    */
-  map<U extends Type>(f: (value: T$1) => U): Lazy<U>;
+  map<U extends Type>(f: (value: T) => U): Lazy<U>;
   /**
    * Applies a wrapped function to a wrapped value (Applicative pattern)
    * @param ff - A Lazy containing a function from T to U
    * @returns A new Lazy containing the result
    */
-  ap<U extends Type>(ff: Lazy<(value: T$1) => U>): Lazy<U>;
+  ap<U extends Type>(ff: Lazy<(value: T) => U>): Lazy<U>;
   /**
    * Maps the value inside the Lazy using an async function
    * @param f - The async mapping function
    * @returns A Promise of a new Lazy containing the mapped value
    */
-  mapAsync<U extends Type>(f: (value: T$1) => Promise<U>): Promise<Lazy<U>>;
+  mapAsync<U extends Type>(f: (value: T) => Promise<U>): Promise<Lazy<U>>;
   /**
    * Maps the value using a function that returns a Lazy
    * @param f - The mapping function returning a Lazy
    * @returns A new Lazy containing the flattened result
    */
-  flatMap<U extends Type>(f: (value: T$1) => Lazy<U>): Lazy<U>;
+  flatMap<U extends Type>(f: (value: T) => Lazy<U>): Lazy<U>;
   /**
    * Maps the value using an async function that returns a Lazy
    * @param f - The async mapping function returning a Lazy
    * @returns A Promise of a new Lazy containing the flattened result
    */
-  flatMapAsync<U extends Type>(f: (value: T$1) => Promise<Lazy<U>>): Promise<Lazy<U>>;
+  flatMapAsync<U extends Type>(f: (value: T) => Promise<Lazy<U>>): Promise<Lazy<U>>;
   /**
    * Returns a Lazy that filters the value based on a predicate
    * @param predicate - The predicate function
    * @returns A Lazy containing an Option of the value
    */
-  filter(predicate: (value: T$1) => boolean): Lazy<Option<T$1>>;
+  filter(predicate: (value: T) => boolean): Lazy<Option<T>>;
   /**
    * Recovers from a failed computation by providing an alternative value
    * @param f - Function that takes the error and returns a recovery value
    * @returns A new Lazy that will use the recovery function if computation fails
    */
-  recover(f: (error: unknown) => T$1): Lazy<T$1>;
+  recover(f: (error: unknown) => T): Lazy<T>;
   /**
    * Recovers from a failed computation by providing an alternative Lazy
    * @param f - Function that takes the error and returns a recovery Lazy
    * @returns A new Lazy that will use the recovery Lazy if computation fails
    */
-  recoverWith(f: (error: unknown) => Lazy<T$1>): Lazy<T$1>;
+  recoverWith(f: (error: unknown) => Lazy<T>): Lazy<T>;
   /**
    * Evaluates the computation and returns it as an Option
    * @returns Some containing the value if successful, None if computation fails
    */
-  toOption(): Option<T$1>;
+  toOption(): Option<T>;
   /**
    * Evaluates the computation and returns it as an Either
    * @returns Right containing the value if successful, Left containing the error if computation fails
    */
-  toEither(): Either<unknown, T$1>;
+  toEither(): Either<unknown, T>;
   /**
    * Evaluates the computation and returns it as an Either with a mapped error
    * @param mapError - Function to map the error
    * @returns Right containing the value if successful, Left containing the mapped error if computation fails
    */
-  toEitherWith<E>(mapError: (error: unknown) => E): Either<E, T$1>;
+  toEitherWith<E>(mapError: (error: unknown) => E): Either<E, T>;
   /**
    * Evaluates the computation and returns it as a Try
    * @returns Try containing the result of the computation
    */
-  toTry(): Try<T$1>;
+  toTry(): Try<T>;
   /**
    * Applies an effect function to the value if computation succeeds
    * @param f - The effect function
    * @returns This Lazy for chaining
    */
-  tap(f: (value: T$1) => void): Lazy<T$1>;
+  tap(f: (value: T) => void): Lazy<T>;
   /**
    * Applies an effect function to the error if computation fails
    * @param f - The effect function for errors
    * @returns This Lazy for chaining
    */
-  tapError(f: (error: unknown) => void): Lazy<T$1>;
+  tapError(f: (error: unknown) => void): Lazy<T>;
   /**
    * Pattern matching on the Lazy value
    * @param f - Function to apply to the computed value
    * @returns The result of applying f to the computed value
    */
-  fold<U>(f: (value: T$1) => U): U;
+  fold<U>(f: (value: T) => U): U;
   /**
    * Pattern matching with success and failure handlers
    * @param onFailure - Function to handle computation failure
    * @param onSuccess - Function to handle successful computation
    * @returns The result of the appropriate handler
    */
-  foldWith<U>(onFailure: (error: unknown) => U, onSuccess: (value: T$1) => U): U;
+  foldWith<U>(onFailure: (error: unknown) => U, onSuccess: (value: T) => U): U;
   /**
    * Left fold operation
    * @param z - Initial value
    * @returns Function that takes an operator and applies it
    */
-  foldLeft: <B>(z: B) => (op: (b: B, a: T$1) => B) => B;
+  foldLeft: <B>(z: B) => (op: (b: B, a: T) => B) => B;
   /**
    * Right fold operation
    * @param z - Initial value
    * @returns Function that takes an operator and applies it
    */
-  foldRight: <B>(z: B) => (op: (a: T$1, b: B) => B) => B;
+  foldRight: <B>(z: B) => (op: (a: T, b: B) => B) => B;
   /**
    * Pattern matching for the Lazy type
    * @param patterns - Object with handler for Lazy pattern
    * @returns The result of the matched handler
    */
   match<R$1>(patterns: {
-    Lazy: (value: T$1) => R$1;
+    Lazy: (value: T) => R$1;
   }): R$1;
   /**
    * Creates a string representation of the Lazy
@@ -2362,7 +3718,7 @@ interface Lazy<T$1 extends Type> extends FunctypeBase<T$1, "Lazy">, Extractable<
   toValue(): {
     _tag: "Lazy";
     evaluated: boolean;
-    value?: T$1;
+    value?: T;
   };
 }
 /**
@@ -2404,50 +3760,50 @@ interface Lazy<T$1 extends Type> extends FunctypeBase<T$1, "Lazy">, Extractable<
  *   .map(user => user.name)
  *   .orThrow() // "Alice"
  */
-declare const Lazy: (<T$1 extends Type>(thunk: () => T$1) => Lazy<T$1>) & {
+declare const Lazy: (<T extends Type>(thunk: () => T) => Lazy<T>) & {
   /**
    * Creates a Lazy from a thunk (deferred computation)
    * @param thunk - Function that computes the value
    * @returns A new Lazy instance
    */
-  of: <T$1 extends Type>(thunk: () => T$1) => Lazy<T$1>;
+  of: <T extends Type>(thunk: () => T) => Lazy<T>;
   /**
    * Creates a Lazy from an immediate value
    * @param value - The value to wrap
    * @returns A new Lazy instance that returns the value
    */
-  fromValue: <T$1 extends Type>(value: T$1) => Lazy<T$1>;
+  fromValue: <T extends Type>(value: T) => Lazy<T>;
   /**
    * Creates a Lazy from an Option
    * @param option - The Option to convert
    * @param defaultThunk - Thunk to compute default value if Option is None
    * @returns A new Lazy instance
    */
-  fromOption: <T$1 extends Type>(option: Option<T$1>, defaultThunk: () => T$1) => Lazy<T$1>;
+  fromOption: <T extends Type>(option: Option<T>, defaultThunk: () => T) => Lazy<T>;
   /**
    * Creates a Lazy from a Try
    * @param tryValue - The Try to convert
    * @returns A new Lazy instance
    */
-  fromTry: <T$1 extends Type>(tryValue: Try<T$1>) => Lazy<T$1>;
+  fromTry: <T extends Type>(tryValue: Try<T>) => Lazy<T>;
   /**
    * Creates a Lazy from an Either
    * @param either - The Either to convert
    * @returns A new Lazy instance
    */
-  fromEither: <E, T$1 extends Type>(either: Either<E, T$1>) => Lazy<T$1>;
+  fromEither: <E, T extends Type>(either: Either<E, T>) => Lazy<T>;
   /**
    * Creates a Lazy that will throw an error since promises need to be awaited first
    * @param promise - The Promise to convert
    * @returns A new Lazy instance that throws an error
    */
-  fromPromise: <T$1 extends Type>(_promise: Promise<T$1>) => Lazy<T$1>;
+  fromPromise: <T extends Type>(_promise: Promise<T>) => Lazy<T>;
   /**
    * Creates a failed Lazy that will throw when evaluated
    * @param error - The error to throw
    * @returns A new Lazy instance that throws the error
    */
-  fail: <T$1 extends Type>(error: unknown) => Lazy<T$1>;
+  fail: <T extends Type>(error: unknown) => Lazy<T>;
 };
 //#endregion
 //#region src/traversable/Traversable.d.ts
@@ -2658,42 +4014,42 @@ declare const createCustomSerializer: (data: Record<string, unknown>) => Seriali
  * @param reconstructor - Function to reconstruct the type from parsed data
  * @returns Reconstructed instance
  */
-declare const fromJSON: <T$1>(json: string, reconstructor: (parsed: {
+declare const fromJSON: <T>(json: string, reconstructor: (parsed: {
   _tag: string;
   [key: string]: unknown;
-}) => T$1) => T$1;
+}) => 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$1>(yaml: string, reconstructor: (parsed: {
+declare const fromYAML: <T>(yaml: string, reconstructor: (parsed: {
   _tag: string;
   [key: string]: unknown;
-}) => T$1) => T$1;
+}) => 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$1>(binary: string, reconstructor: (parsed: {
+declare const fromBinary: <T>(binary: string, reconstructor: (parsed: {
   _tag: string;
   [key: string]: unknown;
-}) => T$1) => T$1;
+}) => 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$1>(reconstructor: (parsed: {
+declare const createSerializationCompanion: <T>(reconstructor: (parsed: {
   _tag: string;
   [key: string]: unknown;
-}) => T$1) => {
-  fromJSON: (json: string) => T$1;
-  fromYAML: (yaml: string) => T$1;
-  fromBinary: (binary: string) => T$1;
+}) => T) => {
+  fromJSON: (json: string) => T;
+  fromYAML: (yaml: string) => T;
+  fromBinary: (binary: string) => T;
 };
 //#endregion
 //#region src/set/Set.d.ts
@@ -2737,9 +4093,9 @@ declare const Set: (<A>(iterable?: Iterable<A>) => Set<A>) & {
 /**
  * Parameters for creating a Valuable instance
  */
-type ValuableParams<Tag extends string, T$1, V> = {
-  _tag: Tag;
-  impl: T$1;
+type ValuableParams<Tag$1 extends string, T, V> = {
+  _tag: Tag$1;
+  impl: T;
   value: V;
 };
 /**
@@ -2748,16 +4104,16 @@ type ValuableParams<Tag extends string, T$1, V> = {
  * @module Valuable
  * @category Utilities
  */
-declare function Valuable<Tag extends string, V, T$1 = object>(params: ValuableParams<Tag, T$1, V>): T$1 & {
+declare function Valuable<Tag$1 extends string, V, T = object>(params: ValuableParams<Tag$1, T, V>): T & {
   toValue: () => {
-    _tag: Tag;
+    _tag: Tag$1;
     value: V;
   };
-  _tag: Tag;
+  _tag: Tag$1;
 };
-type Valuable<Tag extends string, V, T$1 = object> = Typeable<Tag, T$1> & {
+type Valuable<Tag$1 extends string, V, T = object> = Typeable<Tag$1, T> & {
   toValue: () => {
-    _tag: Tag;
+    _tag: Tag$1;
     value: V;
   };
 };
@@ -2876,24 +4232,24 @@ declare const Stack: (<A extends Type>(values?: A[]) => Stack<A>) & {
  * It's used to handle potentially null or undefined values in a type-safe way.
  * @typeParam T - The type of the value contained in the Option
  */
-interface Option<T$1 extends Type> extends Functype<T$1, "Some" | "None">, Promisable<T$1>, Doable<T$1>, Reshapeable<T$1> {
+interface Option<T extends Type> extends Functype<T, "Some" | "None">, Promisable<T>, Doable<T>, Reshapeable<T> {
   /** The contained value (undefined for None) */
-  readonly value: T$1 | undefined;
+  readonly value: T | undefined;
   /** Whether this Option contains no value */
   isEmpty: boolean;
   /**
    * Returns true if this Option is a Some (contains a value)
    * @returns true if this Option contains a value, false otherwise
    */
-  isSome(): this is Option<T$1> & {
-    value: T$1;
+  isSome(): this is Option<T> & {
+    value: T;
     isEmpty: false;
   };
   /**
    * Returns true if this Option is a None (contains no value)
    * @returns true if this Option is empty, false otherwise
    */
-  isNone(): this is Option<T$1> & {
+  isNone(): this is Option<T> & {
     value: undefined;
     isEmpty: true;
   };
@@ -2902,102 +4258,102 @@ interface Option<T$1 extends Type> extends Functype<T$1, "Some" | "None">, Promi
    * @param defaultValue - The value to return if this Option is None
    * @returns The contained value or defaultValue
    */
-  orElse(defaultValue: T$1): T$1;
+  orElse(defaultValue: T): T;
   /**
    * Returns the contained value or throws an error if None
    * @param error - Optional custom error to throw. If not provided, throws a default error
    * @returns The contained value
    * @throws The specified error or a default error if the Option is None
    */
-  orThrow(error?: Error): T$1;
+  orThrow(error?: Error): T;
   /**
    * Returns this Option if it contains a value, otherwise returns the alternative container
    * @param alternative - The alternative Option to return if this is None
    * @returns This Option or the alternative
    */
-  or(alternative: Option<T$1>): Option<T$1>;
+  or(alternative: Option<T>): Option<T>;
   /**
    * Returns the contained value or null if None
    * @returns The contained value or null
    */
-  orNull(): T$1 | null;
+  orNull(): T | null;
   /**
    * Returns the contained value or undefined if None
    * @returns The contained value or undefined
    */
-  orUndefined(): T$1 | undefined;
+  orUndefined(): T | undefined;
   /**
    * Maps the value inside the Option using the provided function
    * @param f - The mapping function
    * @returns A new Option containing the mapped value, or None if this Option is None
    */
-  map<U extends Type>(f: (value: T$1) => U): Option<U>;
+  map<U extends Type>(f: (value: T) => U): Option<U>;
   /**
    * Applies a wrapped function to a wrapped value (Applicative pattern)
    * @param ff - An Option containing a function from T to U
    * @returns A new Option containing the result of applying the function
    */
-  ap<U extends Type>(ff: Option<(value: T$1) => U>): Option<U>;
+  ap<U extends Type>(ff: Option<(value: T) => U>): Option<U>;
   /**
    * Returns this Option if it contains a value that satisfies the predicate, otherwise returns None
    * @param predicate - The predicate function to test the value
    * @returns This Option or None
    */
-  filter(predicate: (value: T$1) => boolean): Option<T$1>;
+  filter(predicate: (value: T) => boolean): Option<T>;
   /**
    * Maps the value using a function that returns an Option
    * @param f - The mapping function returning an Option
    * @returns The result of applying f to the contained value, or None if this Option is None
    */
-  flatMap<U extends Type>(f: (value: T$1) => Option<U>): Option<U>;
+  flatMap<U extends Type>(f: (value: T) => Option<U>): Option<U>;
   /**
    * Maps the value using an async function that returns an Option
    * @param f - The async mapping function returning an Option
    * @returns Promise of the result of applying f to the contained value, or None if this Option is None
    */
-  flatMapAsync<U extends Type>(f: (value: T$1) => Promise<Option<U>>): Promise<Option<U>>;
+  flatMapAsync<U extends Type>(f: (value: T) => Promise<Option<U>>): Promise<Option<U>>;
   /**
    * Applies a binary operator to a start value and the contained value
    * @param f - The binary operator
    * @returns The result of the reduction
    */
-  reduce<U>(f: (acc: U, value: T$1) => U): U;
+  reduce<U>(f: (acc: U, value: T) => U): U;
   /**
    * Applies a binary operator to the contained value and a start value
    * @param f - The binary operator
    * @returns The result of the reduction
    */
-  reduceRight<U>(f: (acc: U, value: T$1) => U): U;
+  reduceRight<U>(f: (acc: U, value: T) => U): U;
   /**
    * Pattern matches over the Option, applying onNone if None and onSome if Some
    * @param onNone - Function to apply if the Option is None
    * @param onSome - Function to apply if the Option has a value
    * @returns The result of applying the appropriate function
    */
-  fold<U>(onNone: () => U, onSome: (value: T$1) => U): U;
+  fold<U>(onNone: () => U, onSome: (value: T) => U): U;
   /**
    * Left-associative fold using the provided zero value and operation
    * @param z - Zero/identity value
    * @returns A function that takes an operation to apply
    */
-  foldLeft<B>(z: B): (op: (b: B, a: T$1) => B) => B;
+  foldLeft<B>(z: B): (op: (b: B, a: T) => B) => B;
   /**
    * Right-associative fold using the provided zero value and operation
    * @param z - Zero/identity value
    * @returns A function that takes an operation to apply
    */
-  foldRight<B>(z: B): (op: (a: T$1, b: B) => B) => B;
+  foldRight<B>(z: B): (op: (a: T, b: B) => B) => B;
   /**
    * Converts this Option to a List
    * @returns A List containing the value if Some, or empty List if None
    */
-  toList(): List<T$1>;
+  toList(): List<T>;
   /**
    * Checks if this Option contains the specified value
    * @param value - The value to check for
    * @returns true if this Option contains the value, false otherwise
    */
-  contains(value: T$1): boolean;
+  contains(value: T): boolean;
   /** The number of elements in this Option (0 or 1) */
   size: number;
   /**
@@ -3005,7 +4361,7 @@ interface Option<T$1 extends Type> extends Functype<T$1, "Some" | "None">, Promi
    * @param left - The value to use for Left if this Option is None
    * @returns Either.Right with the contained value if Some, or Either.Left with left if None
    */
-  toEither<E>(left: E): Either<E, T$1>;
+  toEither<E>(left: E): Either<E, T>;
   /**
    * Returns a string representation of this Option
    * @returns A string representation
@@ -3017,7 +4373,7 @@ interface Option<T$1 extends Type> extends Functype<T$1, "Some" | "None">, Promi
    */
   toValue(): {
     _tag: "Some" | "None";
-    value: T$1;
+    value: T;
   };
   /**
    * Pattern matches over the Option, applying a handler function based on the variant
@@ -3025,7 +4381,7 @@ interface Option<T$1 extends Type> extends Functype<T$1, "Some" | "None">, Promi
    * @returns The result of applying the matching handler function
    */
   match<R$1>(patterns: {
-    Some: (value: T$1) => R$1;
+    Some: (value: T) => R$1;
     None: () => R$1;
   }): R$1;
 }
@@ -3035,13 +4391,13 @@ interface Option<T$1 extends Type> extends Functype<T$1, "Some" | "None">, Promi
  * @returns A new Some instance containing the value
  * @typeParam T - The type of the value
  */
-declare const Some: <T$1 extends Type>(value: T$1) => Option<T$1>;
+declare const Some: <T extends Type>(value: T) => Option<T>;
 /**
  * Creates a None variant of Option representing absence of a value.
  * @returns A new None instance
  * @typeParam T - The type that would be contained if this was a Some
  */
-declare const None: <T$1 extends Type>() => Option<T$1>;
+declare const None: <T extends Type>() => Option<T>;
 /**
  * Safely wraps a value that might be null or undefined in an Option.
  * Creates Some if the value is defined, None otherwise.
@@ -3049,28 +4405,28 @@ declare const None: <T$1 extends Type>() => Option<T$1>;
  * @returns Some(value) if value is defined, None otherwise
  * @typeParam T - The type of the value
  */
-declare const OptionConstructor: <T$1 extends Type>(value: T$1 | null | undefined) => Option<T$1>;
-declare const Option: (<T$1 extends Type>(value: T$1 | null | undefined) => Option<T$1>) & {
+declare const OptionConstructor: <T extends Type>(value: T | null | undefined) => Option<T>;
+declare const Option: (<T extends Type>(value: T | null | undefined) => Option<T>) & {
   /**
    * Creates an Option from any value. Alias for Option function.
    * @param value - The value to wrap
    * @returns Some(value) if value is defined, None otherwise
    * @typeParam T - The type of the value
    */
-  from: <T$1>(value: T$1) => Option<T$1>;
+  from: <T>(value: T) => Option<T>;
   /**
    * Returns a None instance. Alias for None function.
    * @returns A None instance
    * @typeParam T - The type that would be contained if this was a Some
    */
-  none: <T$1>() => Option<T$1>;
+  none: <T>() => Option<T>;
   /**
    * Type guard to check if an Option is Some
    * @param option - The Option to check
    * @returns True if Option is Some
    */
-  isSome: <T$1>(option: Option<T$1>) => option is Option<T$1> & {
-    value: T$1;
+  isSome: <T>(option: Option<T>) => option is Option<T> & {
+    value: T;
     isEmpty: false;
   };
   /**
@@ -3078,7 +4434,7 @@ declare const Option: (<T$1 extends Type>(value: T$1 | null | undefined) => Opti
    * @param option - The Option to check
    * @returns True if Option is None
    */
-  isNone: <T$1>(option: Option<T$1>) => option is Option<T$1> & {
+  isNone: <T>(option: Option<T>) => option is Option<T> & {
     value: undefined;
     isEmpty: true;
   };
@@ -3087,19 +4443,19 @@ declare const Option: (<T$1 extends Type>(value: T$1 | null | undefined) => Opti
    * @param json - The JSON string
    * @returns Option instance
    */
-  fromJSON: <T$1>(json: string) => Option<T$1>;
+  fromJSON: <T>(json: string) => Option<T>;
   /**
    * Creates an Option from YAML string
    * @param yaml - The YAML string
    * @returns Option instance
    */
-  fromYAML: <T$1>(yaml: string) => Option<T$1>;
+  fromYAML: <T>(yaml: string) => Option<T>;
   /**
    * Creates an Option from binary string
    * @param binary - The binary string
    * @returns Option instance
    */
-  fromBinary: <T$1>(binary: string) => Option<T$1>;
+  fromBinary: <T>(binary: string) => Option<T>;
 };
 //#endregion
 //#region src/list/List.d.ts
@@ -3114,7 +4470,7 @@ interface List<A> extends FunctypeCollection<A, "List">, Doable<A>, Reshapeable<
   filter(predicate: (a: A) => unknown): List<A>;
   filterNot: (p: (a: A) => boolean) => List<A>;
   /** @internal */
-  filterType: <T$1 extends Typeable<string, unknown>>(tag: string) => List<T$1 & A>;
+  filterType: <T extends Typeable<string, unknown>>(tag: string) => List<T & A>;
   remove: (value: A) => List<A>;
   removeAt: (index: number) => List<A>;
   add: (item: A) => List<A>;
@@ -3180,8 +4536,8 @@ interface Collection<A> {
  * }
  * ```
  */
-interface FunctypeBase<A, Tag extends string = string> extends AsyncMonad<A>, Traversable<A>, Serializable<A>, Foldable<A>, Typeable<Tag>, ContainerOps<A> {
-  readonly _tag: Tag;
+interface FunctypeBase<A, Tag$1 extends string = string> extends AsyncMonad<A>, Traversable<A>, Serializable<A>, Foldable<A>, Typeable<Tag$1>, ContainerOps<A> {
+  readonly _tag: Tag$1;
 }
 /**
  * Interface for single-value containers like Option, Either, Try.
@@ -3190,9 +4546,9 @@ interface FunctypeBase<A, Tag extends string = string> extends AsyncMonad<A>, Tr
  * @typeParam A - The type of value contained
  * @typeParam Tag - The type tag for pattern matching
  */
-interface Functype<A, Tag extends string = string> extends FunctypeBase<A, Tag>, Extractable<A>, Pipe<A>, Matchable<A, Tag> {
+interface Functype<A, Tag$1 extends string = string> extends FunctypeBase<A, Tag$1>, Extractable<A>, Pipe<A>, Matchable<A, Tag$1> {
   toValue(): {
-    _tag: Tag;
+    _tag: Tag$1;
     value: A;
   };
 }
@@ -3203,13 +4559,13 @@ interface Functype<A, Tag extends string = string> extends FunctypeBase<A, Tag>,
  * @typeParam A - The element type of the collection
  * @typeParam Tag - The type tag for pattern matching
  */
-interface FunctypeCollection<A, Tag extends string = string> extends Omit<FunctypeBase<A, Tag>, "flatMapAsync" | "flatMap">, Iterable<A>, Pipe<A[]>, Collection<A>, CollectionOps<A, FunctypeCollection<A, Tag>> {
+interface FunctypeCollection<A, Tag$1 extends string = string> extends Omit<FunctypeBase<A, Tag$1>, "flatMapAsync" | "flatMap">, Iterable<A>, Pipe<A[]>, Collection<A>, CollectionOps<A, FunctypeCollection<A, Tag$1>> {
   toValue(): {
-    _tag: Tag;
+    _tag: Tag$1;
     value: A[];
   };
-  flatMap<B extends Type>(f: (value: A) => Iterable<B>): FunctypeCollection<B, Tag>;
-  flatMapAsync<B extends Type>(f: (value: A) => PromiseLike<Iterable<B>>): PromiseLike<FunctypeCollection<B, Tag>>;
+  flatMap<B extends Type>(f: (value: A) => Iterable<B>): FunctypeCollection<B, Tag$1>;
+  flatMapAsync<B extends Type>(f: (value: A) => PromiseLike<Iterable<B>>): PromiseLike<FunctypeCollection<B, Tag$1>>;
 }
 //#endregion
 //#region src/either/Either.d.ts
@@ -3251,7 +4607,7 @@ interface Either<L extends Type, R$1 extends Type> extends FunctypeBase<R$1, "Le
   tapLeft: (f: (value: L) => void) => Either<L, R$1>;
   mapLeft: <L2 extends Type>(f: (value: L) => L2) => Either<L2, R$1>;
   bimap: <L2 extends Type, R2 extends Type>(fl: (value: L) => L2, fr: (value: R$1) => R2) => Either<L2, R2>;
-  fold: <T$1 extends Type>(onLeft: (value: L) => T$1, onRight: (value: R$1) => T$1) => T$1;
+  fold: <T extends Type>(onLeft: (value: L) => T, onRight: (value: R$1) => T) => T;
   swap: () => Either<R$1, L>;
   /**
    * Pipes the value through the provided function based on whether this is a Left or Right
@@ -3271,10 +4627,10 @@ interface Either<L extends Type, R$1 extends Type> extends FunctypeBase<R$1, "Le
    * @param patterns - Object with handler functions for Left and Right variants
    * @returns The result of applying the matching handler function
    */
-  match<T$1>(patterns: {
-    Left: (value: L) => T$1;
-    Right: (value: R$1) => T$1;
-  }): T$1;
+  match<T>(patterns: {
+    Left: (value: L) => T;
+    Right: (value: R$1) => T;
+  }): T;
   /**
    * Returns the value and tag for inspection
    */
@@ -3467,12 +4823,12 @@ type TryLike = {
  * @param gen - Generator function that yields monads and returns a result
  * @returns The same monad type as the first yield
  */
-declare function Do<T$1>(gen: () => Generator<OptionLike, T$1, unknown>): Option<T$1>;
+declare function Do<T>(gen: () => Generator<OptionLike, T, unknown>): Option<T>;
 declare function Do<L, R$1>(gen: () => Generator<EitherLike, R$1, unknown>): Either<L, R$1>;
-declare function Do<T$1>(gen: () => Generator<ListLike, T$1, unknown>): List<T$1>;
-declare function Do<T$1>(gen: () => Generator<TryLike, T$1, unknown>): Try<T$1>;
-declare function Do<T$1>(gen: () => Generator<OptionLike | EitherLike | ListLike | TryLike, T$1, unknown>): Reshapeable<T$1>;
-declare function Do<T$1>(gen: () => Generator<unknown, T$1, unknown>): unknown;
+declare function Do<T>(gen: () => Generator<ListLike, T, unknown>): List<T>;
+declare function Do<T>(gen: () => Generator<TryLike, T, unknown>): Try<T>;
+declare function Do<T>(gen: () => Generator<OptionLike | EitherLike | ListLike | TryLike, T, unknown>): Reshapeable<T>;
+declare function Do<T>(gen: () => Generator<unknown, T, unknown>): unknown;
 /**
  * Executes an async generator-based monadic comprehension
  * Returns the same monad type as the first yielded monad
@@ -3490,18 +4846,18 @@ declare function Do<T$1>(gen: () => Generator<unknown, T$1, unknown>): unknown;
  * @param gen - Async generator function that yields monads/promises and returns a result
  * @returns Promise of the same monad type as first yield
  */
-declare function DoAsync<T$1>(gen: () => AsyncGenerator<OptionLike, T$1, unknown>): Promise<Option<T$1>>;
+declare function DoAsync<T>(gen: () => AsyncGenerator<OptionLike, T, unknown>): Promise<Option<T>>;
 declare function DoAsync<L, R$1>(gen: () => AsyncGenerator<EitherLike, R$1, unknown>): Promise<Either<L, R$1>>;
-declare function DoAsync<T$1>(gen: () => AsyncGenerator<ListLike, T$1, unknown>): Promise<List<T$1>>;
-declare function DoAsync<T$1>(gen: () => AsyncGenerator<TryLike, T$1, unknown>): Promise<Try<T$1>>;
-declare function DoAsync<T$1>(gen: () => AsyncGenerator<OptionLike | EitherLike | ListLike | TryLike, T$1, unknown>): Promise<Reshapeable<T$1>>;
-declare function DoAsync<T$1>(gen: () => AsyncGenerator<unknown, T$1, unknown>): Promise<unknown>;
+declare function DoAsync<T>(gen: () => AsyncGenerator<ListLike, T, unknown>): Promise<List<T>>;
+declare function DoAsync<T>(gen: () => AsyncGenerator<TryLike, T, unknown>): Promise<Try<T>>;
+declare function DoAsync<T>(gen: () => AsyncGenerator<OptionLike | EitherLike | ListLike | TryLike, T, unknown>): Promise<Reshapeable<T>>;
+declare function DoAsync<T>(gen: () => AsyncGenerator<unknown, T, unknown>): Promise<unknown>;
 /**
  * Helper function to check if a value implements the Doable interface
  * @param value - Value to check
  * @returns True if the value implements Doable
  */
-declare function isDoCapable<T$1>(value: unknown): value is Doable<T$1>;
+declare function isDoCapable<T>(value: unknown): value is Doable<T>;
 /**
  * Manually unwrap a monad using the Doable interface
  * Useful for testing or when you need to unwrap outside of a Do-comprehension
@@ -3510,7 +4866,7 @@ declare function isDoCapable<T$1>(value: unknown): value is Doable<T$1>;
  * @returns The unwrapped value
  * @throws Error if the monad cannot be unwrapped
  */
-declare function unwrap<T$1>(monad: Doable<T$1>): T$1;
+declare function unwrap<T>(monad: Doable<T>): T;
 /**
  * Type helper for Do-notation generators.
  * Provides better type hints in IDEs.
@@ -3524,7 +4880,7 @@ declare function unwrap<T$1>(monad: Doable<T$1>): T$1;
  * })
  * ```
  */
-type DoGenerator<T$1, TYield = unknown> = Generator<TYield, T$1, unknown>;
+type DoGenerator<T, TYield = unknown> = Generator<TYield, T, unknown>;
 /**
  * Extracts values from monads in Do-notation with type inference.
  * The '$' symbol is the universal extraction operator in functional programming.
@@ -3542,11 +4898,11 @@ type DoGenerator<T$1, TYield = unknown> = Generator<TYield, T$1, unknown>;
  * @param monad - Any monad that can be unwrapped (Option, Either, List, Try, etc.)
  * @returns A generator that yields the monad and returns its extracted value
  */
-declare function $<T$1>(monad: Option<T$1>): Generator<Option<T$1>, T$1, T$1>;
+declare function $<T>(monad: Option<T>): Generator<Option<T>, T, T>;
 declare function $<L, R$1>(monad: Either<L, R$1>): Generator<Either<L, R$1>, R$1, R$1>;
-declare function $<T$1>(monad: List<T$1>): Generator<List<T$1>, T$1, T$1>;
-declare function $<T$1>(monad: Try<T$1>): Generator<Try<T$1>, T$1, T$1>;
-declare function $<T$1>(monad: Doable<T$1>): Generator<Doable<T$1>, T$1, T$1>;
+declare function $<T>(monad: List<T>): Generator<List<T>, T, T>;
+declare function $<T>(monad: Try<T>): Generator<Try<T>, T, T>;
+declare function $<T>(monad: Doable<T>): Generator<Doable<T>, T, T>;
 declare function $<M>(monad: M): Generator<M, InferYieldType<M>, InferYieldType<M>>;
 type InferYieldType<M> = M extends {
   isSome(): boolean;
@@ -3571,5 +4927,5 @@ interface FailureErrorType extends Error {
 }
 declare const FailureError: (cause: Error, message?: string) => FailureErrorType;
 //#endregion
-export { EitherKind as $, isCompanion as $t, OptionConstructor as A, Ok as At, fromBinary as B, createCancellationTokenSource as Bt, Functype as C, ContainerOps as Cn, formatError as Ct, List as D, DoResult as Dn, CancellationToken as Dt, Collection as E, isExtractable as En, Async as Et, Set as F, TaskMetadata as Ft, MatchableUtils as G, NAME as Gt, fromYAML as H, ErrorContext as Ht, SerializationResult as I, TaskOutcome as It, Map$1 as J, Base as Jt, ESMap as K, Throwable as Kt, createCustomSerializer as L, TaskParams as Lt, Stack as M, TaggedThrowable as Mt, Valuable as N, Task as Nt, None as O, Doable as On, CancellationTokenSource as Ot, ValuableParams as P, TaskFailure as Pt, Identity as Q, InstanceType as Qt, createSerializationCompanion as R, TaskResult as Rt, tryCatchAsync as S, CollectionOps as Sn, createErrorSerializer as St, FunctypeCollection as T, Extractable as Tn, safeStringify as Tt, Ref as U, FPromise as Ut, fromJSON as V, isTaggedThrowable as Vt, Matchable as W, FPromiseCompanion as Wt, Traversable as X, Cond as Xt, SafeTraversable as Y, Match as Yt, Lazy as Z, CompanionMethods as Zt, TypeCheckLeft as _, Promisable as _n, ParseError as _t, EmptyListError as a, IntegerNumber as an, UniversalContainer as at, isRight as b, Functor as bn, ErrorWithTaskInfo as bt, LeftError as c, PatternString as cn, FormValidation as ct, isDoCapable as d, UUID as dn, Validator as dt, Companion as en, HKT as et, unwrap as f, UrlString as fn, ErrorCode as ft, TestEither as g, TypeNames as gn, TypedErrorContext as gt, Right as h, Try as hn, TypedError as ht, DoGenerator as i, ISO8601Date as in, TryKind as it, Some as j, Sync as jt, Option as k, Err as kt, LeftErrorType as l, PositiveInteger as ln, Validation as lt, Left as m, ValidatedBrandCompanion as mn, ErrorStatus as mt, Do as n, BoundedString as nn, ListKind as nt, FailureError as o, NonEmptyString as on, FoldableUtils as ot, Either as p, ValidatedBrand as pn, ErrorMessage as pt, ESMapType as q, ThrowableType as qt, DoAsync as r, EmailAddress as rn, OptionKind as rt, FailureErrorType as s, NonNegativeNumber as sn, FieldValidation as st, $ as t, BoundedNumber as tn, Kind as tt, NoneError as u, PositiveNumber as un, ValidationRule as ut, TypeCheckRight as v, Applicative as vn, ErrorChainElement as vt, FunctypeBase as w, LazyList as wn, formatStackTrace as wt, tryCatch as x, Monad as xn, TaskErrorInfo as xt, isLeft as y, AsyncMonad as yn, ErrorFormatterOptions as yt, createSerializer as z, TaskSuccess as zt };
-//# sourceMappingURL=index-Bnjlo4cT.d.ts.map
+export { TestClockTag as $, Task$1 as $t, OptionConstructor as A, PositiveNumber as An, ValidationRule as At, fromBinary as B, Functor as Bn, ErrorWithTaskInfo as Bt, Functype as C, EmailAddress as Cn, OptionKind as Ct, List as D, NonNegativeNumber as Dn, FieldValidation as Dt, Collection as E, NonEmptyString as En, FoldableUtils as Et, Set as F, Try as Fn, TypedError as Ft, MatchableUtils as G, Extractable as Gn, safeStringify as Gt, fromYAML as H, CollectionOps as Hn, createErrorSerializer as Ht, SerializationResult as I, TypeNames as In, TypedErrorContext as It, Map$1 as J, Doable as Jn, CancellationTokenSource as Jt, ESMap as K, isExtractable as Kn, Async as Kt, createCustomSerializer as L, Promisable as Ln, ParseError as Lt, Stack as M, UrlString as Mn, ErrorCode as Mt, Valuable as N, ValidatedBrand as Nn, ErrorMessage as Nt, None as O, PatternString as On, FormValidation as Ot, ValuableParams as P, ValidatedBrandCompanion as Pn, ErrorStatus as Pt, TestClock as Q, TaggedThrowable as Qt, createSerializationCompanion as R, Applicative as Rn, ErrorChainElement as Rt, tryCatchAsync as S, BoundedString as Sn, ListKind as St, FunctypeCollection as T, IntegerNumber as Tn, UniversalContainer as Tt, Ref as U, ContainerOps as Un, formatError as Ut, fromJSON as V, Monad as Vn, TaskErrorInfo as Vt, Matchable as W, LazyList as Wn, formatStackTrace as Wt, Traversable as X, Ok as Xt, SafeTraversable as Y, Err as Yt, Lazy as Z, Sync as Zt, TypeCheckLeft as _, CompanionMethods as _n, TagService as _t, EmptyListError as a, TaskSuccess as an, TimeoutError as at, isRight as b, Companion as bn, HKT as bt, LeftError as c, ErrorContext as cn, LayerError as ct, isDoCapable as d, NAME as dn, Exit as dt, TaskFailure as en, TestContext as et, unwrap as f, Throwable as fn, ExitTag as ft, TestEither as g, Cond as gn, Tag as gt, Right as h, Match as hn, HasService as ht, DoGenerator as i, TaskResult as in, Task as it, Some as j, UUID as jn, Validator as jt, Option as k, PositiveInteger as kn, Validation as kt, LeftErrorType as l, FPromise as ln, LayerInput as lt, Left as m, Base as mn, ContextServices as mt, Do as n, TaskOutcome as nn, InterruptedError as nt, FailureError as o, createCancellationTokenSource as on, UIO as ot, Either as p, ThrowableType as pn, Context as pt, ESMapType as q, DoResult as qn, CancellationToken as qt, DoAsync as r, TaskParams as rn, RIO as rt, FailureErrorType as s, isTaggedThrowable as sn, Layer as st, $ as t, TaskMetadata as tn, IO as tt, NoneError as u, FPromiseCompanion as un, LayerOutput as ut, TypeCheckRight as v, InstanceType as vn, Identity as vt, FunctypeBase as w, ISO8601Date as wn, TryKind as wt, tryCatch as x, BoundedNumber as xn, Kind as xt, isLeft as y, isCompanion as yn, EitherKind as yt, createSerializer as z, AsyncMonad as zn, ErrorFormatterOptions as zt };
+//# sourceMappingURL=index-Bn_yRBx8.d.ts.map