functype 0.45.0 → 0.46.0

package/dist/{index-DBg23xHh.d.ts → Functype-Dc440LS5.d.ts}

@@ -1,5 +1,10 @@
-import { t as Brand } from "./Brand-B_uQBKwR.js";
-import { c as Pipe, l as Foldable, o as Serializable, r as Typeable, t as Tuple, u as Type } from "./Tuple-35L0I92q.js";
+import { Brand } from "./branded/index.js";
+import { a as Serializable, c as Foldable, l as Type, n as Typeable, s as Pipe } from "./Typeable-E4-aX9Gc.js";
+import { Try } from "./try/index.js";
+import { Set } from "./set/index.js";
+import { Option } from "./option/index.js";
+import { List } from "./list/index.js";
+import { Either } from "./either/index.js";
 
 //#region src/error/ParseError.d.ts
 declare const ParseError: (message?: string) => Error & {
@@ -125,6 +130,16 @@ interface LazyList<A extends Type> extends Foldable<A>, Pipe<LazyList<A>>, Seria
   dropWhile(predicate: (a: A) => boolean): LazyList<A>;
   concat(other: LazyList<A>): LazyList<A>;
   zip<B extends Type>(other: LazyList<B>): LazyList<[A, B]>;
+  takeRight(n: number): LazyList<A>;
+  reverse(): LazyList<A>;
+  distinct(): LazyList<A>;
+  zipWithIndex(): LazyList<[A, number]>;
+  get head(): A | undefined;
+  get headOption(): Option<A>;
+  get last(): A | undefined;
+  get lastOption(): Option<A>;
+  get tail(): LazyList<A>;
+  get init(): LazyList<A>;
   toList(): List<A>;
   toArray(): A[];
   forEach(f: (a: A) => void): void;
@@ -133,8 +148,6 @@ interface LazyList<A extends Type> extends Foldable<A>, Pipe<LazyList<A>>, Seria
   some(predicate: (a: A) => boolean): boolean;
   every(predicate: (a: A) => boolean): boolean;
   count(): number;
-  first(): Option<A>;
-  last(): Option<A>;
   toString(): string;
 }
 /**
@@ -292,6 +305,34 @@ interface CollectionOps<A extends Type, Self> {
    * Gets the first element wrapped in Option.
    */
   get headOption(): Option<A>;
+  /**
+   * Takes the first n elements from the collection.
+   */
+  take(n: number): Self;
+  /**
+   * Takes elements from the start while the predicate is true.
+   */
+  takeWhile(p: (a: A) => boolean): Self;
+  /**
+   * Takes the last n elements from the collection.
+   */
+  takeRight(n: number): Self;
+  /**
+   * Gets the last element of the collection.
+   */
+  get last(): A | undefined;
+  /**
+   * Gets the last element wrapped in Option.
+   */
+  get lastOption(): Option<A>;
+  /**
+   * Gets all elements except the first.
+   */
+  get tail(): Self;
+  /**
+   * Gets all elements except the last.
+   */
+  get init(): Self;
   /**
    * Converts the collection to an array.
    */
@@ -374,96 +415,6 @@ interface Promisable<A extends Type> {
   toPromise(): Promise<A>;
 }
 //#endregion
-//#region src/try/Try.d.ts
-/**
- * Possible types of Try instances
- */
-type TypeNames = "Success" | "Failure";
-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> & {
-    readonly _tag: "Success";
-    error: undefined;
-  };
-  isFailure(): this is Try<T> & {
-    readonly _tag: "Failure";
-    error: Error;
-  };
-  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) => U) => U;
-  toString: () => string;
-  /**
-   * Pattern matches over the Try, applying a handler function based on the variant
-   * @param patterns - Object with handler functions for Success and Failure variants
-   * @returns The result of applying the matching handler function
-   */
-  match<R$1>(patterns: {
-    Success: (value: T) => R$1;
-    Failure: (error: Error) => R$1;
-  }): R$1;
-  toValue(): {
-    _tag: TypeNames;
-    value: T | Error;
-  };
-}
-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>(tryValue: Try<T>) => tryValue is Try<T> & {
-    readonly _tag: "Success";
-    error: undefined;
-  };
-  /**
-   * Type guard to check if a Try is Failure
-   * @param tryValue - The Try to check
-   * @returns True if Try is Failure
-   */
-  isFailure: <T>(tryValue: Try<T>) => tryValue is Try<T> & {
-    readonly _tag: "Failure";
-    error: Error;
-  };
-  /**
-   * Creates a Try from JSON string
-   * @param json - The JSON string
-   * @returns Try instance
-   */
-  fromJSON: <T>(json: string) => Try<T>;
-  /**
-   * Creates a Try from YAML string
-   * @param yaml - The YAML string
-   * @returns Try instance
-   */
-  fromYAML: <T>(yaml: string) => Try<T>;
-  /**
-   * Creates a Try from binary string
-   * @param binary - The binary string
-   * @returns Try instance
-   */
-  fromBinary: <T>(binary: string) => Try<T>;
-};
-//#endregion
 //#region src/reshapeable/Reshapeable.d.ts
 /**
  * Interface for types that can be reshaped (converted) between different monadic containers.
@@ -551,18 +502,18 @@ interface Reshapeable<T extends Type> {
 }
 //#endregion
 //#region src/branded/ValidatedBrand.d.ts
-type ValidatedBrand<K$1 extends string, T> = Brand<K$1, T> & {
+type ValidatedBrand<K extends string, T> = Brand<K, T> & {
   readonly __validated: true;
 };
-interface ValidatedBrandCompanion<K$1 extends string, T> {
-  readonly brand: K$1;
+interface ValidatedBrandCompanion<K extends string, T> {
+  readonly brand: K;
   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>>;
+  readonly of: (value: T) => Option<ValidatedBrand<K, T>>;
+  readonly from: (value: T) => Either<string, ValidatedBrand<K, T>>;
+  readonly unsafeOf: (value: T) => ValidatedBrand<K, T>;
+  readonly is: (value: unknown) => value is ValidatedBrand<K, T>;
+  readonly unwrap: (branded: Brand<K, T>) => T;
+  readonly refine: <K2 extends string>(brand: K2, validate: (value: Brand<K, T>) => boolean) => ValidatedBrandCompanion<K2, Brand<K, T>>;
 }
 /**
  * Create a validated brand with runtime validation
@@ -597,7 +548,7 @@ interface ValidatedBrandCompanion<K$1 extends string, T> {
  * // ❌ ValidatedBrand("ValidatedUserId", ...) + Brand<"UserId", string>
  * // ✅ ValidatedBrand("UserId", ...) + Brand<"UserId", string>
  */
-declare function ValidatedBrand<K$1 extends string, T>(brand: K$1, validate: (value: T) => boolean): ValidatedBrandCompanion<K$1, T>;
+declare function ValidatedBrand<K extends string, T>(brand: K, validate: (value: T) => boolean): ValidatedBrandCompanion<K, T>;
 /**
  * Positive number brand (> 0)
  * @example
@@ -835,7 +786,7 @@ declare const Cond: (<T extends Type>() => Cond<T>) & {
    *   "skip": () => defaultValue
    * })
    */
-  match: <T extends string | number | symbol>(value: T) => <R$1 extends Type>(cases: Record<T, R$1 | (() => R$1)>) => R$1;
+  match: <T extends string | number | symbol>(value: T) => <R extends Type>(cases: Record<T, R | (() => R)>) => R;
   /**
    * Create a lazy conditional that defers evaluation
    * @example
@@ -882,7 +833,7 @@ type Pattern<T> = T | { [K in keyof T]?: Pattern<T[K]> } | ((value: T) => boolea
  * Extract result from pattern
  * @internal
  */
-type PatternResult<T, R$1> = R$1 | ((matched: T) => R$1);
+type PatternResult<T, R> = R | ((matched: T) => R);
 /**
  * Untyped Match (before first case is added).
  * The result type R is inferred when the first case method is called.
@@ -894,23 +845,23 @@ type UntypedMatch<T extends Type> = {
   /**
    * Match against a pattern - infers result type R from the result parameter
    */
-  case: <R$1 extends Type>(pattern: Pattern<T>, result: PatternResult<T, R$1>) => Match<T, R$1>;
+  case: <R extends Type>(pattern: Pattern<T>, result: PatternResult<T, R>) => Match<T, R>;
   /**
    * Match a specific value - infers result type R from the result parameter
    */
-  caseValue: <R$1 extends Type>(match: T, result: R$1 | (() => R$1)) => Match<T, R$1>;
+  caseValue: <R extends Type>(match: T, result: R | (() => R)) => Match<T, R>;
   /**
    * Match multiple values - infers result type R from the result parameter
    */
-  caseValues: <R$1 extends Type>(matches: T[], result: R$1 | (() => R$1)) => Match<T, R$1>;
+  caseValues: <R extends Type>(matches: T[], result: R | (() => R)) => Match<T, R>;
   /**
    * Match with a guard function - infers result type R from the result parameter
    */
-  when: <R$1 extends Type>(guard: (value: T) => boolean, result: PatternResult<T, R$1>) => Match<T, R$1>;
+  when: <R extends Type>(guard: (value: T) => boolean, result: PatternResult<T, R>) => Match<T, R>;
   /**
    * Match multiple patterns (OR operation) - infers result type R from the result parameter
    */
-  caseAny: <R$1 extends Type>(patterns: Pattern<T>[], result: PatternResult<T, R$1>) => Match<T, R$1>;
+  caseAny: <R extends Type>(patterns: Pattern<T>[], result: PatternResult<T, R>) => Match<T, R>;
 };
 /**
  * Pattern matching construct similar to Scala's match expressions.
@@ -939,49 +890,49 @@ type UntypedMatch<T extends Type> = {
  *   .case({ role: "user" }, u => `User: ${u.name}`)
  *   .default("Guest")
  */
-type Match<T extends Type, R$1 extends Type> = {
+type Match<T extends Type, R extends Type> = {
   /**
    * Match against a pattern (value, nested object, or predicate).
    * The result type R2 is added to the union of possible results.
    */
-  case: <R2 extends Type>(pattern: Pattern<T>, result: PatternResult<T, R2>) => Match<T, R$1 | R2>;
+  case: <R2 extends Type>(pattern: Pattern<T>, result: PatternResult<T, R2>) => Match<T, R | R2>;
   /**
    * Add a case that matches a specific value.
    * The result type R2 is added to the union of possible results.
    */
-  caseValue: <R2 extends Type>(match: T, result: R2 | (() => R2)) => Match<T, R$1 | R2>;
+  caseValue: <R2 extends Type>(match: T, result: R2 | (() => R2)) => Match<T, R | R2>;
   /**
    * Add a case that matches multiple values.
    * The result type R2 is added to the union of possible results.
    */
-  caseValues: <R2 extends Type>(matches: T[], result: R2 | (() => R2)) => Match<T, R$1 | R2>;
+  caseValues: <R2 extends Type>(matches: T[], result: R2 | (() => R2)) => Match<T, R | R2>;
   /**
    * Match with a guard function (alias for readability).
    * The result type R2 is added to the union of possible results.
    */
-  when: <R2 extends Type>(guard: (value: T) => boolean, result: PatternResult<T, R2>) => Match<T, R$1 | R2>;
+  when: <R2 extends Type>(guard: (value: T) => boolean, result: PatternResult<T, R2>) => Match<T, R | R2>;
   /**
    * Match multiple patterns (OR operation).
    * The result type R2 is added to the union of possible results.
    */
-  caseAny: <R2 extends Type>(patterns: Pattern<T>[], result: PatternResult<T, R2>) => Match<T, R$1 | R2>;
+  caseAny: <R2 extends Type>(patterns: Pattern<T>[], result: PatternResult<T, R2>) => Match<T, R | R2>;
   /**
    * Default case - makes match non-exhaustive.
    * The result type R2 is added to the union of possible results.
    */
-  default: <R2 extends Type>(result: PatternResult<T, R2>) => R$1 | R2;
+  default: <R2 extends Type>(result: PatternResult<T, R2>) => R | R2;
   /**
    * Force exhaustive matching (compile-time check for union types)
    */
-  exhaustive: () => R$1;
+  exhaustive: () => R;
   /**
    * Get result if matched, throws if no match
    */
-  orThrow: (errorMessage?: string) => R$1;
+  orThrow: (errorMessage?: string) => R;
   /**
    * Get result wrapped in Option
    */
-  toOption: () => Option<R$1>;
+  toOption: () => Option<R>;
 };
 /**
  * Pattern matching utility for type-safe conditional logic with exhaustiveness checking,
@@ -1047,7 +998,7 @@ declare const Match: (<T extends Type>(value: T) => UntypedMatch<T>) & {
    * const compute = ops("multiply").fn
    * const result = compute(4, 5) // 20
    */
-  exhaustive: <T extends string | number | symbol, R$1 extends Type>(cases: RequireExhaustive<T, Record<T, R$1>>) => (value: T) => R$1;
+  exhaustive: <T extends string | number | symbol, R extends Type>(cases: RequireExhaustive<T, Record<T, R>>) => (value: T) => R;
   /**
    * Create a partial match that requires a default
    * @example
@@ -1069,8 +1020,8 @@ declare const Match: (<T extends Type>(value: T) => UntypedMatch<T>) & {
    * }).withDefault((n) => `Number: ${n}`)
    * getMessage(5) // "Number: 5"
    */
-  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;
+  partial: <T extends string | number | symbol, R extends Type>(cases: Partial<Record<T, R | ((value: T) => R)>>) => {
+    withDefault: (defaultValue: R | ((value: T) => R)) => (value: T) => R;
   };
   /**
    * Pattern match with guards
@@ -1095,8 +1046,8 @@ declare const Match: (<T extends Type>(value: T) => UntypedMatch<T>) & {
    * ]).withDefault("Unknown")(age)
    * // category = "Adult (25 years)"
    */
-  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;
+  withGuards: <T extends Type, R extends Type>(guards: Array<[(value: T) => boolean, R | ((value: T) => R)]>) => {
+    withDefault: (defaultValue: R | ((value: T) => R)) => (value: T) => R;
   };
   /**
    * Pattern matching for objects with specific structure
@@ -1112,9 +1063,9 @@ declare const Match: (<T extends Type>(value: T) => UntypedMatch<T>) & {
    *   .case({ type: "hover" }, (e) => console.log(`Hovering over ${e.element}`))
    *   .build()
    */
-  struct: <T extends Type, R$1 extends Type>() => {
-    case: (pattern: Pattern<T>, handler: (value: T) => R$1) => /*elided*/any;
-    build: () => (value: T) => R$1;
+  struct: <T extends Type, R extends Type>() => {
+    case: (pattern: Pattern<T>, handler: (value: T) => R) => /*elided*/any;
+    build: () => (value: T) => R;
   };
   /**
    * Create a pattern matcher with guards and nested patterns
@@ -1131,11 +1082,11 @@ declare const Match: (<T extends Type>(value: T) => UntypedMatch<T>) & {
    *   .default(false)
    *   .build()
    */
-  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;
+  builder: <T extends Type, R extends Type>() => {
+    case: (pattern: Pattern<T>, result: PatternResult<T, R>) => /*elided*/any;
+    when: (guard: (value: T) => boolean, result: PatternResult<T, R>) => /*elided*/any;
+    default: (result: PatternResult<T, R>) => {
+      build: () => (value: T) => R;
     };
   };
 };
@@ -1274,11 +1225,8 @@ type TaskResult<T> = Promise<TaskOutcome<T>>;
  * Cancellation is cooperative, meaning the task must check the token and respond to cancellation requests
  */
 type CancellationToken = {
-  /** Whether the token has been cancelled */
-  readonly isCancelled: boolean;
-  /** Signal that can be used with fetch and other abortable APIs */
-  readonly signal: AbortSignal;
-  /** Register a callback to be called when cancellation occurs */
+  /** Whether the token has been cancelled */readonly isCancelled: boolean; /** Signal that can be used with fetch and other abortable APIs */
+  readonly signal: AbortSignal; /** Register a callback to be called when cancellation occurs */
   onCancel(callback: () => void): void;
 };
 /**
@@ -1286,9 +1234,7 @@ type CancellationToken = {
  * The controller can be used to cancel operations that use the token
  */
 type CancellationTokenSource = {
-  /** The token to be passed to cancellable operations */
-  readonly token: CancellationToken;
-  /** Cancel all operations using this token */
+  /** The token to be passed to cancellable operations */readonly token: CancellationToken; /** Cancel all operations using this token */
   cancel(): void;
 };
 /**
@@ -1473,19 +1419,12 @@ type ErrorChainElement = {
  * Options for formatting error chains
  */
 type ErrorFormatterOptions = {
-  /** Include task names in the formatted output */
-  includeTasks?: boolean;
-  /** Include stack traces in the formatted output */
-  includeStackTrace?: boolean;
-  /** Separator between error lines (default: newline) */
-  separator?: string;
-  /** Include detailed error data in the output */
-  includeData?: boolean;
-  /** Maximum number of stack frames to include if stack trace is enabled */
-  maxStackFrames?: number;
-  /** Title to display at the start of the formatted error */
-  title?: string;
-  /** Format the output with colors for console display */
+  /** Include task names in the formatted output */includeTasks?: boolean; /** Include stack traces in the formatted output */
+  includeStackTrace?: boolean; /** Separator between error lines (default: newline) */
+  separator?: string; /** Include detailed error data in the output */
+  includeData?: boolean; /** Maximum number of stack frames to include if stack trace is enabled */
+  maxStackFrames?: number; /** Title to display at the start of the formatted error */
+  title?: string; /** Format the output with colors for console display */
   colors?: boolean;
 };
 /**
@@ -1962,7 +1901,7 @@ type TagService<T> = T extends Tag<infer S> ? S : never;
  * const loggerUnsafe = ctx.unsafeGet(Logger) // Logger (throws if missing)
  * ```
  */
-interface Context<R$1 extends Type> {
+interface Context<R extends Type> {
   /**
    * Type brand
    * @internal
@@ -1972,7 +1911,7 @@ interface Context<R$1 extends Type> {
    * Phantom type for requirements
    * @internal
    */
-  readonly _R?: R$1;
+  readonly _R?: R;
   /**
    * Internal service map
    * @internal
@@ -2003,13 +1942,13 @@ interface Context<R$1 extends Type> {
    * @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>;
+  add<S extends Type>(tag: Tag<S>, service: S): Context<R & 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>;
+  merge<R2 extends Type>(other: Context<R2>): Context<R & R2>;
   /**
    * Returns the number of services in this context.
    */
@@ -2026,7 +1965,7 @@ declare const Context: {
   /**
    * Creates an empty context with no services.
    */
-  empty: <R$1 extends Type = never>() => Context<R$1>;
+  empty: <R extends Type = never>() => Context<R>;
   /**
    * Creates a context with a single service.
    * @param tag - The tag for the service
@@ -2036,7 +1975,7 @@ declare const Context: {
   /**
    * Checks if a value is a Context.
    */
-  isContext: <R$1 extends Type>(value: unknown) => value is Context<R$1>;
+  isContext: <R extends Type>(value: unknown) => value is Context<R>;
 };
 /**
  * Type helper to extract requirements from a Context
@@ -2332,7 +2271,7 @@ declare const Layer: {
    * 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>;
+  fromContext: <R extends Type>(context: Context<R>) => Layer<never, never, R>;
   /**
    * Creates an empty layer that provides nothing.
    */
@@ -2391,7 +2330,7 @@ declare class InterruptedError extends Error {
 /**
  * Internal effect representation types
  */
-type IOEffect<R$1, E, A> = {
+type IOEffect<R, E, A> = {
   readonly _tag: "Sync";
   readonly thunk: () => A;
 } | {
@@ -2413,48 +2352,48 @@ type IOEffect<R$1, E, A> = {
   readonly _tag: "Interrupt";
 } | {
   readonly _tag: "FlatMap";
-  readonly effect: IO<R$1, E, unknown>;
-  readonly f: (a: unknown) => IO<R$1, E, A>;
+  readonly effect: IO<R, E, unknown>;
+  readonly f: (a: unknown) => IO<R, E, A>;
 } | {
   readonly _tag: "Map";
-  readonly effect: IO<R$1, E, unknown>;
+  readonly effect: IO<R, E, unknown>;
   readonly f: (a: unknown) => A;
 } | {
   readonly _tag: "MapError";
-  readonly effect: IO<R$1, unknown, A>;
+  readonly effect: IO<R, unknown, A>;
   readonly f: (e: unknown) => E;
 } | {
   readonly _tag: "Recover";
-  readonly effect: IO<R$1, E, A>;
+  readonly effect: IO<R, 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 effect: IO<R, E, A>;
+  readonly f: (e: E) => IO<R, E, A>;
 } | {
   readonly _tag: "Fold";
-  readonly effect: IO<R$1, E, unknown>;
+  readonly effect: IO<R, 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 acquire: IO<R, E, unknown>;
+  readonly use: (a: unknown) => IO<R, E, A>;
+  readonly release: (a: unknown) => IO<R, never, void>;
 } | {
   readonly _tag: "Race";
-  readonly effects: readonly IO<R$1, E, A>[];
+  readonly effects: readonly IO<R, E, A>[];
 } | {
   readonly _tag: "Timeout";
-  readonly effect: IO<R$1, E, A>;
+  readonly effect: IO<R, 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>;
+  readonly effect: IO<R, E, A>;
+  readonly context: Context<R>;
 };
 /**
  * IO<R, E, A> represents a lazy, composable effect.
@@ -2463,17 +2402,17 @@ type IOEffect<R$1, E, A> = {
  * @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> {
+interface IO<R extends Type, E extends Type, A extends Type> {
   /**
    * Internal effect representation
    * @internal
    */
-  readonly _effect: IOEffect<R$1, E, A>;
+  readonly _effect: IOEffect<R, E, A>;
   /**
    * Phantom type for requirements
    * @internal
    */
-  readonly _R?: R$1;
+  readonly _R?: R;
   /**
    * Phantom type for error
    * @internal
@@ -2489,31 +2428,31 @@ interface IO<R$1 extends Type, E extends Type, A extends Type> {
    * @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>;
+  map<B extends Type>(f: (a: A) => B): IO<R, 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>;
+  flatMap<R2 extends Type, E2 extends Type, B extends Type>(f: (a: A) => IO<R2, E2, B>): IO<R | 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>;
+  tap(f: (a: A) => void): IO<R, 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>;
+  tapEffect<R2 extends Type, E2 extends Type, B extends Type>(f: (a: A) => IO<R2, E2, B>): IO<R | 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>;
+  mapError<E2 extends Type>(f: (e: E) => E2): IO<R, E2, A>;
   /**
    * Executes a side effect on the error without changing it.
    * Useful for logging errors while preserving the error chain.
@@ -2528,92 +2467,92 @@ interface IO<R$1 extends Type, E extends Type, A extends Type> {
    *   .map(data => transform(data))
    * ```
    */
-  tapError(f: (e: E) => void): IO<R$1, E, A>;
+  tapError(f: (e: E) => void): IO<R, 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>;
+  recover<B extends Type>(fallback: B): IO<R, 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>;
+  recoverWith<R2 extends Type, E2 extends Type, B extends Type>(f: (e: E) => IO<R2, E2, B>): IO<R | 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>;
+  fold<B extends Type>(onFailure: (e: E) => B, onSuccess: (a: A) => B): IO<R, 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>;
+  }): IO<R, 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 {
+  catchTag<K 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;
+  } ? E["_tag"] : never), R2 extends Type, E2 extends Type, B extends Type>(tag: K, handler: (e: Extract<E, {
+    _tag: K;
+  }>) => IO<R2, E2, B>): IO<R | R2, Exclude<E, {
+    _tag: K;
   }> | 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>;
+  catchAll<R2 extends Type, E2 extends Type, B extends Type>(handler: (e: E) => IO<R2, E2, B>): IO<R | 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>;
+  retry(n: number): IO<R, 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>;
+  retryWithDelay(n: number, delayMs: number): IO<R, 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>;
+  zipRight<R2 extends Type, E2 extends Type, B extends Type>(that: IO<R2, E2, B>): IO<R | 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>;
+  zipLeft<R2 extends Type, E2 extends Type, B extends Type>(that: IO<R2, E2, B>): IO<R | 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]>;
+  zip<R2 extends Type, E2 extends Type, B extends Type>(that: IO<R2, E2, B>): IO<R | 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>;
+  flatten<R2 extends Type, E2 extends Type, B extends Type>(this: IO<R, E, IO<R2, E2, B>>): IO<R | 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>;
+  provideContext<R2 extends R>(context: Context<R2>): IO<Exclude<R, 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>;
+  provideService<S extends Type>(tag: Tag<S>, service: S): IO<Exclude<R, 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>;
+  provideLayer<RIn extends Type, E2 extends Type, ROut extends R>(layer: Layer<RIn, E2, ROut>): IO<RIn | Exclude<R, ROut>, E | E2, A>;
   /**
    * Runs the effect and returns an Either. Never throws.
    * This is the safe default - all errors become Left.
@@ -2656,22 +2595,22 @@ interface IO<R$1 extends Type, E extends Type, A extends Type> {
   /**
    * Pipes the IO through a function.
    */
-  pipe<B>(f: (self: IO<R$1, E, A>) => B): B;
+  pipe<B>(f: (self: IO<R, E, A>) => B): B;
   /**
    * Delays execution by the specified milliseconds.
    */
-  delay(ms: number): IO<R$1, E, A>;
+  delay(ms: number): IO<R, 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>;
+  timeout(ms: number): IO<R, 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>;
+  timeoutTo<B extends Type>(ms: number, fallback: B): IO<R, E, A | B>;
   /**
    * Converts to string representation.
    */
@@ -2687,52 +2626,52 @@ interface IO<R$1 extends Type, E extends Type, A extends Type> {
    * 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>;
+  [Symbol.iterator](): Generator<IO<R, 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>> {
+interface DoBuilder<R extends Type, E extends Type, Ctx extends Record<string, Type>> {
   /**
    * The underlying IO effect
    */
-  readonly effect: IO<R$1, E, Ctx>;
+  readonly effect: IO<R, 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>>;
+  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 | 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>>;
+  let<N extends string, A extends Type>(name: Exclude<N, keyof Ctx>, f: (ctx: Ctx) => A): DoBuilder<R, 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>;
+  map<B extends Type>(f: (ctx: Ctx) => B): IO<R, 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>;
+  flatMap<R2 extends Type, E2 extends Type, B extends Type>(f: (ctx: Ctx) => IO<R2, E2, B>): IO<R | 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>;
+  tap(f: (ctx: Ctx) => void): DoBuilder<R, 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>;
+  tapEffect<R2 extends Type, E2 extends Type, B extends Type>(f: (ctx: Ctx) => IO<R2, E2, B>): DoBuilder<R | R2, E | E2, Ctx>;
   /**
    * Returns the final context as is.
    */
-  done(): IO<R$1, E, Ctx>;
+  done(): IO<R, E, Ctx>;
 }
 /**
  * IO effect type for lazy, composable effects with typed errors.
@@ -2945,7 +2884,7 @@ declare const IO: (<A extends Type>(f: () => A | Promise<A>) => IO<never, unknow
   /**
    * 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>;
+  serviceWithIO: <S extends Type, R extends Type, E extends Type, A extends Type>(tag: Tag<S>, f: (service: S) => IO<R, E, A>) => IO<S | R, E, A>;
   /**
    * Accesses multiple services and applies a function to them.
    * Provides a convenient way to work with multiple dependencies.
@@ -2965,11 +2904,11 @@ declare const IO: (<A extends Type>(f: () => A | Promise<A>) => IO<never, unknow
   /**
    * 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[]>;
+  all: <R extends Type, E extends Type, A extends Type>(effects: readonly IO<R, E, A>[]) => IO<R, 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>;
+  firstSuccessOf: <R extends Type, E extends Type, A extends Type>(effects: readonly IO<R, E, A>[]) => IO<R, E, A>;
   /**
    * Creates an IO that sleeps for the specified duration.
    */
@@ -3003,11 +2942,11 @@ declare const IO: (<A extends Type>(f: () => A | Promise<A>) => IO<never, unknow
    * )
    * ```
    */
-  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>;
+  bracket: <R extends Type, E extends Type, A extends Type, B extends Type>(acquire: IO<R, E, A>, use: (a: A) => IO<R, E, B>, release: (a: A) => IO<R, never, void>) => IO<R, 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>;
+  acquireRelease: <R extends Type, E extends Type, A extends Type, B extends Type>(acquire: IO<R, E, A>, use: (a: A) => IO<R, E, B>, release: (a: A) => IO<R, never, void>) => IO<R, E, B>;
   /**
    * Races multiple effects, returning the first to complete.
    * Note: Other effects are NOT cancelled (JS limitation).
@@ -3020,7 +2959,7 @@ declare const IO: (<A extends Type>(f: () => A | Promise<A>) => IO<never, unknow
    * ]).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>;
+  race: <R extends Type, E extends Type, A extends Type>(effects: readonly IO<R, E, A>[]) => IO<R, E, A>;
   /**
    * Returns the first effect to succeed, or fails if all fail.
    *
@@ -3033,7 +2972,7 @@ declare const IO: (<A extends Type>(f: () => A | Promise<A>) => IO<never, unknow
    * ]).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>;
+  any: <R extends Type, E extends Type, A extends Type>(effects: readonly IO<R, E, A>[]) => IO<R, E, A>;
   /**
    * Executes an effect for each element in the array, collecting results.
    *
@@ -3044,16 +2983,16 @@ declare const IO: (<A extends Type>(f: () => A | Promise<A>) => IO<never, unknow
    * ).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[]>;
+  forEach: <R extends Type, E extends Type, A extends Type, B extends Type>(items: readonly A[], f: (a: A) => IO<R, E, B>) => IO<R, 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[]>;
+  forEachPar: <R extends Type, E extends Type, A extends Type, B extends Type>(items: readonly A[], f: (a: A) => IO<R, E, B>) => IO<R, 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>;
+  timeout: <R extends Type, E extends Type, A extends Type>(effect: IO<R, E, A>, ms: number) => IO<R, E | TimeoutError, A>;
   /**
    * Creates an IO from a generator function.
    * This enables do-notation style programming.
@@ -3094,7 +3033,7 @@ 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>;
+type RIO<R extends Type, A extends Type> = IO<R, never, A>;
 //#endregion
 //#region src/io/TestClock.d.ts
 /**
@@ -3186,11 +3125,11 @@ declare const TestClock: {
 /**
  * TestContext provides a complete test environment with mocked services.
  */
-interface TestContext<R$1 extends Type> {
+interface TestContext<R extends Type> {
   /**
    * The context containing test services
    */
-  readonly context: ReturnType<typeof Context.empty<R$1>>;
+  readonly context: ReturnType<typeof Context.empty<R>>;
   /**
    * The TestClock for controlling time
    */
@@ -3198,11 +3137,11 @@ interface TestContext<R$1 extends Type> {
   /**
    * Adds a service to the test context
    */
-  withService<S extends Type>(tag: Tag<S>, service: S): TestContext<R$1 & S>;
+  withService<S extends Type>(tag: Tag<S>, service: S): TestContext<R & 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>;
+  run<E extends Type, A extends Type>(effect: IO<R, E, A>): Promise<A>;
 }
 /**
  * Creates a TestContext for testing IO effects with mocked services.
@@ -3220,7 +3159,7 @@ declare const TestContext: {
   /**
    * Creates a new empty TestContext
    */
-  make: <R$1 extends Type = never>() => TestContext<R$1>;
+  make: <R extends Type = never>() => TestContext<R>;
   /**
    * Creates a TestContext with a TestClock already provided
    */
@@ -3378,9 +3317,9 @@ interface Lazy<T extends Type> extends FunctypeBase<T, "Lazy">, Extractable<T>,
    * @param patterns - Object with handler for Lazy pattern
    * @returns The result of the matched handler
    */
-  match<R$1>(patterns: {
-    Lazy: (value: T) => R$1;
-  }): R$1;
+  match<R>(patterns: {
+    Lazy: (value: T) => R;
+  }): R;
   /**
    * Creates a string representation of the Lazy
    * @returns String representation showing evaluation status
@@ -3493,72 +3432,6 @@ interface Traversable<A extends Type> extends AsyncMonad<A> {
   reduceRight(f: (b: A, a: A) => A): A;
 }
 //#endregion
-//#region src/map/Map.d.ts
-/**
- * A traversable interface for map that excludes map and flatMap operations
- */
-type SafeTraversable<K$1, V> = Omit<Traversable<Tuple<[K$1, V]>>, "map" | "flatMap" | "flatMapAsync" | "ap">;
-interface Map$1<K$1, V> extends SafeTraversable<K$1, V>, Collection<Tuple<[K$1, V]>>, Typeable<"Map">, Serializable<[K$1, V][]>, Pipe<[K$1, V][]>, Foldable<Tuple<[K$1, V]>>, Iterable<[K$1, V]> {
-  readonly _tag: "Map";
-  add(item: Tuple<[K$1, V]>): Map$1<K$1, V>;
-  remove(value: K$1): Map$1<K$1, V>;
-  map<U>(f: (value: V) => U): Map$1<K$1, U>;
-  ap<U>(ff: Map$1<K$1, (value: V) => U>): Map$1<K$1, U>;
-  flatMap<K2, V2>(f: (entry: Tuple<[K$1, V]>) => Iterable<[K2, V2]>): Map$1<K2, V2>;
-  flatMapAsync<U>(f: (value: V) => PromiseLike<Map$1<K$1, U>>): PromiseLike<Map$1<K$1, U>>;
-  get(key: K$1): Option<V>;
-  getOrElse(key: K$1, defaultValue: V): V;
-  orElse(key: K$1, alternative: Option<V>): Option<V>;
-  fold<U extends Type>(onEmpty: () => U, onValue: (value: Tuple<[K$1, V]>) => U): U;
-  foldLeft<B>(z: B): (op: (b: B, a: Tuple<[K$1, V]>) => B) => B;
-  foldRight<B>(z: B): (op: (a: Tuple<[K$1, V]>, b: B) => B) => B;
-  /**
-   * Pattern matches over the Map, applying a handler function based on whether it's empty
-   * @param patterns - Object with handler functions for Empty and NonEmpty variants
-   * @returns The result of applying the matching handler function
-   */
-  match<R$1>(patterns: {
-    Empty: () => R$1;
-    NonEmpty: (entries: Array<Tuple<[K$1, V]>>) => R$1;
-  }): R$1;
-  toValue(): {
-    _tag: "Map";
-    value: [K$1, V][];
-  };
-}
-declare const Map$1: (<K$1, V>(entries?: readonly (readonly [K$1, V])[] | IterableIterator<[K$1, V]> | null) => Map$1<K$1, V>) & {
-  /**
-   * Creates an empty Map
-   * Returns a singleton instance for efficiency
-   * @returns An empty Map instance
-   */
-  empty: <K$1, V>() => Map$1<K$1, V>;
-  /**
-   * Creates a Map from variadic key-value pair arguments
-   * @param entries - Key-value pairs to create map from
-   * @returns A Map containing the entries
-   */
-  of: <K$1, V>(...entries: [K$1, V][]) => Map$1<K$1, V>;
-  /**
-   * Creates a Map from JSON string
-   * @param json - The JSON string
-   * @returns Map instance
-   */
-  fromJSON: <K$1, V>(json: string) => Map$1<K$1, V>;
-  /**
-   * Creates a Map from YAML string
-   * @param yaml - The YAML string
-   * @returns Map instance
-   */
-  fromYAML: <K$1, V>(yaml: string) => Map$1<K$1, V>;
-  /**
-   * Creates a Map from binary string
-   * @param binary - The binary string
-   * @returns Map instance
-   */
-  fromBinary: <K$1, V>(binary: string) => Map$1<K$1, V>;
-};
-//#endregion
 //#region src/map/shim.d.ts
 /**
  * Type alias for the native JavaScript Map
@@ -3566,7 +3439,7 @@ declare const Map$1: (<K$1, V>(entries?: readonly (readonly [K$1, V])[] | Iterab
  * @module Map
  * @category Collections
  */
-type ESMapType<K$1, V> = Map<K$1, V>;
+type ESMapType<K, V> = Map<K, V>;
 /**
  * Reference to the native JavaScript Map
  * @module Map
@@ -3591,7 +3464,7 @@ interface Matchable<A, Tags extends string = string> {
    * @param patterns - An object containing handler functions for each variant
    * @returns The result of applying the matching handler function
    */
-  match<R$1>(patterns: Record<Tags, (value: A) => R$1>): R$1;
+  match<R>(patterns: Record<Tags, (value: A) => R>): R;
 }
 /**
  * Utility functions for working with Matchable data structures
@@ -3603,7 +3476,7 @@ declare const MatchableUtils: {
    * @param handler - The default handler function to apply
    * @returns A function that always applies the default handler
    */
-  default: <A, R$1>(handler: (value: A) => R$1) => (value: A) => R$1;
+  default: <A, R>(handler: (value: A) => R) => (value: A) => R;
   /**
    * Helper function to create a match pattern that guards based on a predicate
    *
@@ -3611,7 +3484,7 @@ declare const MatchableUtils: {
    * @param handler - The handler function to apply if the predicate passes
    * @returns A function that applies the handler only if the predicate passes
    */
-  when: <A, R$1>(predicate: (value: A) => boolean, handler: (value: A) => R$1) => (value: A) => R$1 | undefined;
+  when: <A, R>(predicate: (value: A) => boolean, handler: (value: A) => R) => (value: A) => R | undefined;
 };
 //#endregion
 //#region src/ref/Ref.d.ts
@@ -3739,61 +3612,12 @@ declare const createSerializationCompanion: <T>(reconstructor: (parsed: {
   fromBinary: (binary: string) => T;
 };
 //#endregion
-//#region src/set/Set.d.ts
-interface Set<A> extends FunctypeCollection<A, "Set">, Collection<A> {
-  add: (value: A) => Set<A>;
-  remove: (value: A) => Set<A>;
-  contains: (value: A) => boolean;
-  has: (value: A) => boolean;
-  map: <B>(f: (a: A) => B) => Set<B>;
-  flatMap: <B>(f: (a: A) => Iterable<B>) => Set<B>;
-  filter: (p: (a: A) => boolean) => Set<A>;
-  filterNot: (p: (a: A) => boolean) => Set<A>;
-  fold: <U extends Type>(onEmpty: () => U, onValue: (value: A) => U) => U;
-  toList: () => List<A>;
-  toSet: () => Set<A>;
-  toArray: <B = A>() => B[];
-  toString: () => string;
-}
-declare const Set: (<A>(iterable?: Iterable<A>) => Set<A>) & {
-  /**
-   * Creates an empty Set
-   * Returns a singleton instance for efficiency
-   * @returns An empty Set instance
-   */
-  empty: <A extends Type>() => Set<A>;
-  /**
-   * Creates a Set from variadic arguments
-   * @param values - Values to create set from
-   * @returns A Set containing the unique values
-   */
-  of: <A extends Type>(...values: A[]) => Set<A>;
-  /**
-   * Creates a Set from JSON string
-   * @param json - The JSON string
-   * @returns Set instance
-   */
-  fromJSON: <A>(json: string) => Set<A>;
-  /**
-   * Creates a Set from YAML string
-   * @param yaml - The YAML string
-   * @returns Set instance
-   */
-  fromYAML: <A>(yaml: string) => Set<A>;
-  /**
-   * Creates a Set from binary string
-   * @param binary - The binary string
-   * @returns Set instance
-   */
-  fromBinary: <A>(binary: string) => Set<A>;
-};
-//#endregion
 //#region src/valuable/Valuable.d.ts
 /**
  * Parameters for creating a Valuable instance
  */
-type ValuableParams<Tag$1 extends string, T, V> = {
-  _tag: Tag$1;
+type ValuableParams<Tag extends string, T, V> = {
+  _tag: Tag;
   impl: T;
   value: V;
 };
@@ -3803,16 +3627,16 @@ type ValuableParams<Tag$1 extends string, T, V> = {
  * @module Valuable
  * @category Utilities
  */
-declare function Valuable<Tag$1 extends string, V, T = object>(params: ValuableParams<Tag$1, T, V>): T & {
+declare function Valuable<Tag extends string, V, T = object>(params: ValuableParams<Tag, T, V>): T & {
   toValue: () => {
-    _tag: Tag$1;
+    _tag: Tag;
     value: V;
   };
-  _tag: Tag$1;
+  _tag: Tag;
 };
-type Valuable<Tag$1 extends string, V, T = object> = Typeable<Tag$1, T> & {
+type Valuable<Tag extends string, V, T = object> = Typeable<Tag, T> & {
   toValue: () => {
-    _tag: Tag$1;
+    _tag: Tag;
     value: V;
   };
 };
@@ -3883,10 +3707,10 @@ type Stack<A extends Type> = {
    * @param patterns - Object with handler functions for Empty and NonEmpty variants
    * @returns The result of applying the matching handler function
    */
-  match<R$1>(patterns: {
-    Empty: () => R$1;
-    NonEmpty: (values: A[]) => R$1;
-  }): R$1;
+  match<R>(patterns: {
+    Empty: () => R;
+    NonEmpty: (values: A[]) => R;
+  }): R;
 } & Traversable<A> & Valuable<"Stack", A[]> & Serializable<A> & Pipe<A[]> & Foldable<A> & Matchable<A[], "Empty" | "NonEmpty">;
 declare const Stack: (<A extends Type>(values?: A[]) => Stack<A>) & {
   /**
@@ -3920,304 +3744,6 @@ declare const Stack: (<A extends Type>(values?: A[]) => Stack<A>) & {
   fromBinary: <A>(binary: string) => Stack<A>;
 };
 //#endregion
-//#region src/option/Option.d.ts
-/**
- * Option type module
- * @module Option
- * @category Core
- */
-/**
- * The Option type represents a value that may or may not exist.
- * 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 extends Type> extends Functype<T, "Some" | "None">, Promisable<T>, Doable<T>, Reshapeable<T> {
-  /** The contained value (undefined for None) */
-  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> & {
-    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> & {
-    value: undefined;
-    isEmpty: true;
-  };
-  /**
-   * Returns the contained value or a default value if None
-   * @param defaultValue - The value to return if this Option is None
-   * @returns The contained value or defaultValue
-   */
-  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;
-  /**
-   * 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>): Option<T>;
-  /**
-   * Returns the contained value or null if None
-   * @returns The contained value or null
-   */
-  orNull(): T | null;
-  /**
-   * Returns the contained value or undefined if None
-   * @returns The contained value or 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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, 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>;
-  /**
-   * 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): boolean;
-  /** The number of elements in this Option (0 or 1) */
-  size: number;
-  /**
-   * Converts this Option to an Either
-   * @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>;
-  /**
-   * Returns a string representation of this Option
-   * @returns A string representation
-   */
-  toString(): string;
-  /**
-   * Returns a simple object representation of this Option
-   * @returns An object with _tag and value properties
-   */
-  toValue(): {
-    _tag: "Some" | "None";
-    value: T;
-  };
-  /**
-   * Pattern matches over the Option, applying a handler function based on the variant
-   * @param patterns - Object with handler functions for Some and None variants
-   * @returns The result of applying the matching handler function
-   */
-  match<R$1>(patterns: {
-    Some: (value: T) => R$1;
-    None: () => R$1;
-  }): R$1;
-}
-/**
- * Creates a Some variant of Option containing a value.
- * @param value - The value to wrap in Some
- * @returns A new Some instance containing the value
- * @typeParam T - The type of the value
- */
-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 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.
- * @param value - The value to wrap (might be null/undefined)
- * @returns Some(value) if value is defined, None otherwise
- * @typeParam T - The type of the value
- */
-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>(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>() => 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>(option: Option<T>) => option is Option<T> & {
-    value: T;
-    isEmpty: false;
-  };
-  /**
-   * Type guard to check if an Option is None
-   * @param option - The Option to check
-   * @returns True if Option is None
-   */
-  isNone: <T>(option: Option<T>) => option is Option<T> & {
-    value: undefined;
-    isEmpty: true;
-  };
-  /**
-   * Creates an Option from JSON string
-   * @param json - The JSON string
-   * @returns Option instance
-   */
-  fromJSON: <T>(json: string) => Option<T>;
-  /**
-   * Creates an Option from YAML string
-   * @param yaml - The YAML string
-   * @returns Option instance
-   */
-  fromYAML: <T>(yaml: string) => Option<T>;
-  /**
-   * Creates an Option from binary string
-   * @param binary - The binary string
-   * @returns Option instance
-   */
-  fromBinary: <T>(binary: string) => Option<T>;
-};
-//#endregion
-//#region src/list/List.d.ts
-interface List<A> extends FunctypeCollection<A, "List">, Doable<A>, Reshapeable<A> {
-  readonly length: number;
-  readonly [Symbol.iterator]: () => Iterator<A>;
-  map: <B>(f: (a: A) => B) => List<B>;
-  ap: <B>(ff: List<(value: A) => B>) => List<B>;
-  flatMap: <B>(f: (a: A) => Iterable<B>) => List<B>;
-  flatMapAsync: <B>(f: (a: A) => PromiseLike<Iterable<B>>) => PromiseLike<List<B>>;
-  filter<S extends A>(predicate: (a: A) => a is S): List<S>;
-  filter(predicate: (a: A) => unknown): List<A>;
-  filterNot: (p: (a: A) => boolean) => List<A>;
-  /** @internal */
-  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>;
-  get: (index: number) => Option<A>;
-  concat: (other: List<A>) => List<A>;
-  /**
-   * Pattern matches over the List, applying a handler function based on whether it's empty
-   * @param patterns - Object with handler functions for Empty and NonEmpty variants
-   * @returns The result of applying the matching handler function
-   */
-  match<R$1>(patterns: {
-    Empty: () => R$1;
-    NonEmpty: (values: A[]) => R$1;
-  }): R$1;
-}
-declare const List: (<A>(values?: Iterable<A>) => List<A>) & {
-  /**
-   * Creates an empty List
-   * Returns a singleton instance for efficiency
-   * @returns An empty List instance
-   */
-  empty: <A extends Type>() => List<A>;
-  /**
-   * Creates a List from variadic arguments
-   * @param values - Values to create list from
-   * @returns A List containing the values
-   */
-  of: <A extends Type>(...values: A[]) => List<A>;
-  /**
-   * Creates a List from JSON string
-   * @param json - The JSON string
-   * @returns List instance
-   */
-  fromJSON: <A>(json: string) => List<A>;
-  /**
-   * Creates a List from YAML string
-   * @param yaml - The YAML string
-   * @returns List instance
-   */
-  fromYAML: <A>(yaml: string) => List<A>;
-  /**
-   * Creates a List from binary string
-   * @param binary - The binary string
-   * @returns List instance
-   */
-  fromBinary: <A>(binary: string) => List<A>;
-};
-//#endregion
 //#region src/collections/index.d.ts
 /**
  * Represents a collection with conversion capabilities
@@ -4247,8 +3773,8 @@ interface Collection<A> {
  * }
  * ```
  */
-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 FunctypeBase<A, Tag extends string = string> extends AsyncMonad<A>, Traversable<A>, Serializable<A>, Foldable<A>, Typeable<Tag>, ContainerOps<A> {
+  readonly _tag: Tag;
 }
 /**
  * Interface for single-value containers like Option, Either, Try.
@@ -4257,9 +3783,9 @@ interface FunctypeBase<A, Tag$1 extends string = string> extends AsyncMonad<A>,
  * @typeParam A - The type of value contained
  * @typeParam Tag - The type tag for pattern matching
  */
-interface Functype<A, Tag$1 extends string = string> extends FunctypeBase<A, Tag$1>, Extractable<A>, Pipe<A>, Matchable<A, Tag$1> {
+interface Functype<A, Tag extends string = string> extends FunctypeBase<A, Tag>, Extractable<A>, Pipe<A>, Matchable<A, Tag> {
   toValue(): {
-    _tag: Tag$1;
+    _tag: Tag;
     value: A;
   };
 }
@@ -4270,372 +3796,13 @@ interface Functype<A, Tag$1 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$1 extends string = string> extends Omit<FunctypeBase<A, Tag$1>, "flatMapAsync" | "flatMap">, Iterable<A>, Pipe<A[]>, Collection<A>, CollectionOps<A, FunctypeCollection<A, Tag$1>> {
+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>> {
   toValue(): {
-    _tag: Tag$1;
+    _tag: Tag;
     value: A[];
   };
-  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
-/**
- * Either type module
- * @module Either
- * @category Core
- */
-interface Either<L extends Type, R$1 extends Type> extends FunctypeBase<R$1, "Left" | "Right">, Promisable<R$1>, Doable<R$1>, Reshapeable<R$1>, Extractable<R$1> {
-  readonly _tag: "Left" | "Right";
-  value: L | R$1;
-  isLeft(): this is Either<L, R$1> & {
-    readonly _tag: "Left";
-    value: L;
-  };
-  isRight(): this is Either<L, R$1> & {
-    readonly _tag: "Right";
-    value: R$1;
-  };
-  orElse: (defaultValue: R$1) => R$1;
-  orThrow: (error?: Error) => R$1;
-  or(alternative: Either<L, R$1>): Either<L, R$1>;
-  orNull: () => R$1 | null;
-  orUndefined: () => R$1 | undefined;
-  readonly map: <U extends Type>(f: (value: R$1) => U) => Either<L, U>;
-  ap: <U extends Type>(ff: Either<L, (value: R$1) => U>) => Either<L, U>;
-  merge: <L1 extends Type, R1 extends Type>(other: Either<L1, R1>) => Either<L | L1, [R$1, R1]>;
-  mapAsync: <U extends Type>(f: (value: R$1) => Promise<U>) => Promise<Either<L, U>>;
-  flatMap: <U extends Type>(f: (value: R$1) => Either<L, U>) => Either<L, U>;
-  flatMapAsync: <U extends Type>(f: (value: R$1) => Promise<Either<L, U>>) => Promise<Either<L, U>>;
-  toOption: () => Option<R$1>;
-  toList: () => List<R$1>;
-  toString: () => string;
-  [Symbol.iterator]: () => Iterator<R$1>;
-  yield: () => Generator<R$1, void, unknown>;
-  traverse: <U extends Type>(f: (value: R$1) => Either<L, U>) => Either<L, U[]>;
-  lazyMap: <U extends Type>(f: (value: R$1) => U) => Generator<Either<L, U>, void, unknown>;
-  tap: (f: (value: R$1) => void) => Either<L, R$1>;
-  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 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
-   * @param onLeft - The function to apply if this is a Left
-   * @param onRight - The function to apply if this is a Right
-   * @returns The result of applying the appropriate function
-   */
-  pipeEither<U extends Type>(onLeft: (value: L) => U, onRight: (value: R$1) => U): U;
-  /**
-   * Pipes the Either value through the provided function
-   * @param f - The function to apply to the value (Left or Right)
-   * @returns The result of applying the function to the value
-   */
-  pipe<U extends Type>(f: (value: L | R$1) => U): U;
-  /**
-   * Pattern matches over the Either, applying a handler function based on the variant
-   * @param patterns - Object with handler functions for Left and Right variants
-   * @returns The result of applying the matching handler function
-   */
-  match<T>(patterns: {
-    Left: (value: L) => T;
-    Right: (value: R$1) => T;
-  }): T;
-  /**
-   * Returns the value and tag for inspection
-   */
-  toValue(): {
-    _tag: "Left" | "Right";
-    value: L | R$1;
-  };
-  /**
-   * Custom JSON serialization that excludes getter properties
-   */
-  toJSON(): {
-    _tag: "Left" | "Right";
-    value: L | R$1;
-  };
-}
-type TestEither<L extends Type, R$1 extends Type> = Either<L, R$1> & AsyncMonad<R$1>;
-declare const Right: <L extends Type, R$1 extends Type>(value: R$1) => Either<L, R$1>;
-declare const Left: <L extends Type, R$1 extends Type>(value: L) => Either<L, R$1>;
-declare const isRight: <L extends Type, R$1 extends Type>(either: Either<L, R$1>) => either is Either<L, R$1> & {
-  value: R$1;
-};
-declare const isLeft: <L extends Type, R$1 extends Type>(either: Either<L, R$1>) => either is Either<L, R$1> & {
-  value: L;
-};
-declare const tryCatch: <L extends Type, R$1 extends Type>(f: () => R$1, onError: (error: unknown) => L) => Either<L, R$1>;
-declare const TypeCheckRight: <L extends Type, R$1 extends Type>(value: R$1) => TestEither<L, R$1>;
-declare const TypeCheckLeft: <L extends Type, R$1 extends Type>(value: L) => TestEither<L, R$1>;
-declare const tryCatchAsync: <L extends Type, R$1 extends Type>(f: () => Promise<R$1>, onError: (error: unknown) => L) => Promise<Either<L, R$1>>;
-declare const Either: (<L extends Type, R$1 extends Type>(value: R$1 | L, isRight: boolean) => Either<L, R$1>) & {
-  /**
-   * Creates a Left instance
-   * @param value - The left value
-   * @returns Left Either
-   */
-  left: <L extends Type, R$1 extends Type>(value: L) => Either<L, R$1>;
-  /**
-   * Creates a Right instance
-   * @param value - The right value
-   * @returns Right Either
-   */
-  right: <L extends Type, R$1 extends Type>(value: R$1) => Either<L, R$1>;
-  /**
-   * Type guard to check if an Either is Right
-   * @param either - The Either to check
-   * @returns True if Either is Right
-   */
-  isRight: <L extends Type, R$1 extends Type>(either: Either<L, R$1>) => either is Either<L, R$1> & {
-    value: R$1;
-  };
-  /**
-   * Type guard to check if an Either is Left
-   * @param either - The Either to check
-   * @returns True if Either is Left
-   */
-  isLeft: <L extends Type, R$1 extends Type>(either: Either<L, R$1>) => either is Either<L, R$1> & {
-    value: L;
-  };
-  /**
-   * Combines an array of Eithers into a single Either containing an array
-   * @param eithers - Array of Either values
-   * @returns Either with array of values or first Left encountered
-   */
-  sequence: <L extends Type, R$1 extends Type>(eithers: Either<L, R$1>[]) => Either<L, R$1[]>;
-  /**
-   * Maps an array through a function that returns Either, then sequences the results
-   * @param arr - Array of values
-   * @param f - Function that returns Either
-   * @returns Either with array of results or first Left encountered
-   */
-  traverse: <L extends Type, R$1 extends Type, U extends Type>(arr: R$1[], f: (value: R$1) => Either<L, U>) => Either<L, U[]>;
-  /**
-   * Creates an Either from a nullable value
-   * @param value - The value that might be null or undefined
-   * @param leftValue - The value to use for Left if value is null/undefined
-   * @returns Right if value is not null/undefined, Left otherwise
-   */
-  fromNullable: <L extends Type, R$1 extends Type>(value: R$1 | null | undefined, leftValue: L) => Either<L, R$1>;
-  /**
-   * Creates an Either based on a predicate
-   * @param value - The value to test
-   * @param predicate - The predicate function
-   * @param leftValue - The value to use for Left if predicate fails
-   * @returns Right if predicate passes, Left otherwise
-   */
-  fromPredicate: <L extends Type, R$1 extends Type>(value: R$1, predicate: (value: R$1) => boolean, leftValue: L) => Either<L, R$1>;
-  /**
-   * Applicative apply - applies a wrapped function to a wrapped value
-   * @param eitherF - Either containing a function
-   * @param eitherV - Either containing a value
-   * @returns Either with function applied to value
-   */
-  ap: <L extends Type, R$1 extends Type, U extends Type>(eitherF: Either<L, (value: R$1) => U>, eitherV: Either<L, R$1>) => Either<L, U>;
-  /**
-   * Creates an Either from a Promise
-   * @param promise - The Promise to convert
-   * @param onRejected - Function to convert rejection reason to Left value
-   * @returns Promise that resolves to Either
-   */
-  fromPromise: <L, R$1>(promise: Promise<R$1>, onRejected: (reason: unknown) => L) => Promise<Either<L, R$1>>;
-  /**
-   * Creates an Either from JSON string
-   * @param json - The JSON string
-   * @returns Either instance
-   */
-  fromJSON: <L extends Type, R$1 extends Type>(json: string) => Either<L, R$1>;
-  /**
-   * Creates an Either from YAML string
-   * @param yaml - The YAML string
-   * @returns Either instance
-   */
-  fromYAML: <L extends Type, R$1 extends Type>(yaml: string) => Either<L, R$1>;
-  /**
-   * Creates an Either from binary string
-   * @param binary - The binary string
-   * @returns Either instance
-   */
-  fromBinary: <L extends Type, R$1 extends Type>(binary: string) => Either<L, R$1>;
-};
-//#endregion
-//#region src/do/index.d.ts
-type OptionLike = {
-  _tag: "Some" | "None";
-  isSome(): boolean;
-  get(): unknown;
-};
-type EitherLike = {
-  _tag: "Left" | "Right";
-  isLeft(): boolean;
-  isRight(): boolean;
-  value: unknown;
-};
-type ListLike = {
-  _tag: "List";
-  toArray(): unknown[];
-};
-type TryLike = {
-  _tag: "Success" | "Failure";
-  isSuccess(): boolean;
-  get(): unknown;
-};
-/**
- * Executes a generator-based monadic comprehension
- * Returns the same monad type as the first yielded monad (Scala semantics)
- *
- * - Option comprehensions return Option (None on short-circuit)
- * - Either comprehensions return Either (Left with error on short-circuit)
- * - List comprehensions return List (empty or cartesian product)
- * - Try comprehensions return Try (Failure with error on short-circuit)
- *
- * Type Inference Notes:
- * - TypeScript infers the correct return type for homogeneous comprehensions
- * - For mixed monad types, TypeScript returns a union type
- * - Use DoTyped<T> or type assertions for mixed scenarios
- *
- * @example
- * ```typescript
- * // Option comprehension returns Option:
- * const result = Do(function* () {
- *   const x = yield* $(Option(5));
- *   const y = yield* $(Option(10));
- *   return x + y;
- * });
- * // result: Option(15)
- *
- * // Either comprehension returns Either:
- * const result = Do(function* () {
- *   const x = yield* $(Right(5));
- *   const y = yield* $(Left("error"));
- *   return x + y;
- * });
- * // result: Left("error") - error is preserved
- *
- * // List comprehension returns List with cartesian product:
- * const result = Do(function* () {
- *   const x = yield* $(List([1, 2]));
- *   const y = yield* $(List([3, 4]));
- *   return x + y;
- * });
- * // result: List([4, 5, 5, 6])
- *
- * // Mixed types - use type assertion or DoTyped:
- * const result = Do(function* () {
- *   const x = yield* $(Option(5));
- *   const y = yield* $(Right<string, number>(10));
- *   return x + y;
- * }) as Option<number>;
- * // result: Option(15)
- * ```
- *
- * @param gen - Generator function that yields monads and returns a result
- * @returns The same monad type as the first yield
- */
-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>(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
- *
- * @example
- * ```typescript
- * const result = await DoAsync(async function* () {
- *   const user = yield* $(await fetchUser(id));       // Promise<Option<User>> → User
- *   const profile = yield* $(await getProfile(user)); // Promise<Either<Error, Profile>> → Profile
- *   return { user, profile };
- * });
- * // result type matches first yield
- * ```
- *
- * @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>(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>(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>(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
- *
- * @param monad - Monad to unwrap
- * @returns The unwrapped value
- * @throws Error if the monad cannot be unwrapped
- */
-declare function unwrap<T>(monad: Doable<T>): T;
-/**
- * Type helper for Do-notation generators.
- * Provides better type hints in IDEs.
- *
- * @example
- * ```typescript
- * const result = Do(function* (): DoGenerator<number> {
- *   const x = yield* $(List([1, 2]))  // x is still unknown but return type is clear
- *   const y = yield* $(List([3, 4]))
- *   return x + y
- * })
- * ```
- */
-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.
- *
- * @example
- * ```typescript
- * const result = Do(function* () {
- *   const x = yield* $(Option(5))        // x: number
- *   const y = yield* $(List([1, 2, 3]))  // y: number (for cartesian product)
- *   const name = yield* $(Right("Alice")) // name: string
- *   return `${name}: ${x + y}`
- * })
- * ```
- *
- * @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>(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>(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;
-  get(): infer T;
-} ? T : M extends {
-  isRight(): boolean;
-  value: infer R;
-} ? R : M extends {
-  toArray(): (infer T)[];
-} ? T : M extends {
-  isSuccess(): boolean;
-  get(): infer T;
-} ? T : M extends Doable<infer T> ? T : unknown;
-declare const NoneError: (message?: string) => Error;
-interface LeftErrorType<L> extends Error {
-  value: L;
-}
-declare const LeftError: <L>(value: L, message?: string) => LeftErrorType<L>;
-declare const EmptyListError: (message?: string) => Error;
-interface FailureErrorType extends Error {
-  cause: Error;
+  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>>;
 }
-declare const FailureError: (cause: Error, message?: string) => FailureErrorType;
 //#endregion
-export { TestClockTag as $, TaskFailure as $t, OptionConstructor as A, ValidatedBrand as An, ValidationRule as At, fromBinary as B, ContainerOps as Bn, TaskErrorInfo as Bt, Functype as C, NonEmptyString as Cn, OptionKind as Ct, List as D, PositiveNumber as Dn, FieldValidation as Dt, Collection as E, PositiveInteger as En, FoldableUtils as Et, Set as F, Applicative as Fn, TypedError as Ft, MatchableUtils as G, Doable as Gn, Async as Gt, fromYAML as H, Extractable as Hn, formatError as Ht, SerializationResult as I, AsyncMonad as In, TypedErrorContext as It, Map$1 as J, Err as Jt, ESMap as K, ParseError as Kn, CancellationToken as Kt, createCustomSerializer as L, Functor as Ln, ErrorChainElement as Lt, Stack as M, Try as Mn, ErrorCode as Mt, Valuable as N, TypeNames as Nn, ErrorMessage as Nt, None as O, UUID as On, FormValidation as Ot, ValuableParams as P, Promisable as Pn, ErrorStatus as Pt, TestClock as Q, Task$1 as Qt, createSerializationCompanion as R, Monad as Rn, ErrorFormatterOptions as Rt, tryCatchAsync as S, IntegerNumber as Sn, ListKind as St, FunctypeCollection as T, PatternString as Tn, UniversalContainer as Tt, Ref as U, isExtractable as Un, formatStackTrace as Ut, fromJSON as V, LazyList as Vn, createErrorSerializer as Vt, Matchable as W, DoResult as Wn, safeStringify as Wt, Traversable as X, Sync as Xt, SafeTraversable as Y, Ok as Yt, Lazy as Z, TaggedThrowable as Zt, TypeCheckLeft as _, Companion as _n, TagService as _t, EmptyListError as a, createCancellationTokenSource as an, TimeoutError as at, isRight as b, EmailAddress as bn, HKT as bt, LeftError as c, Throwable as cn, LayerError as ct, isDoCapable as d, Match as dn, Exit as dt, TaskMetadata as en, TestContext as et, unwrap as f, UntypedMatch as fn, ExitTag as ft, TestEither as g, isCompanion as gn, Tag as gt, Right as h, InstanceType as hn, HasService as ht, DoGenerator as i, TaskSuccess as in, Task as it, Some as j, ValidatedBrandCompanion as jn, Validator as jt, Option as k, UrlString as kn, Validation as kt, LeftErrorType as l, ThrowableType as ln, LayerInput as lt, Left as m, CompanionMethods as mn, ContextServices as mt, Do as n, TaskParams as nn, InterruptedError as nt, FailureError as o, isTaggedThrowable as on, UIO as ot, Either as p, Cond as pn, Context as pt, ESMapType as q, CancellationTokenSource as qt, DoAsync as r, TaskResult as rn, RIO as rt, FailureErrorType as s, NAME as sn, Layer as st, $ as t, TaskOutcome as tn, IO as tt, NoneError as u, Base as un, LayerOutput as ut, TypeCheckRight as v, BoundedNumber as vn, Identity as vt, FunctypeBase as w, NonNegativeNumber as wn, TryKind as wt, tryCatch as x, ISO8601Date as xn, Kind as xt, isLeft as y, BoundedString as yn, EitherKind as yt, createSerializer as z, CollectionOps as zn, ErrorWithTaskInfo as zt };
+export { Validation as $, UrlString as $t, UIO as A, isTaggedThrowable as At, Tag as B, isCompanion as Bt, TestClockTag as C, TaskFailure as Ct, RIO as D, TaskResult as Dt, InterruptedError as E, TaskParams as Et, Exit as F, Match as Ft, Kind as G, ISO8601Date as Gt, Identity as H, BoundedNumber as Ht, ExitTag as I, UntypedMatch as It, TryKind as J, NonNegativeNumber as Jt, ListKind as K, IntegerNumber as Kt, Context as L, Cond as Lt, LayerError as M, Throwable as Mt, LayerInput as N, ThrowableType as Nt, Task as O, TaskSuccess as Ot, LayerOutput as P, Base as Pt, FormValidation as Q, UUID as Qt, ContextServices as R, CompanionMethods as Rt, TestClock as S, Task$1 as St, IO as T, TaskOutcome as Tt, EitherKind as U, BoundedString as Ut, TagService as V, Companion as Vt, HKT as W, EmailAddress as Wt, FoldableUtils as X, PositiveInteger as Xt, UniversalContainer as Y, PatternString as Yt, FieldValidation as Z, PositiveNumber as Zt, MatchableUtils as _, CancellationTokenSource as _t, Stack as a, AsyncMonad as an, TypedError as at, Traversable as b, Sync as bt, SerializationResult as c, CollectionOps as cn, ErrorFormatterOptions as ct, createSerializer as d, Extractable as dn, createErrorSerializer as dt, ValidatedBrand as en, ValidationRule as et, fromBinary as f, isExtractable as fn, formatError as ft, Matchable as g, CancellationToken as gt, Ref as h, ParseError as hn, Async as ht, Collection as i, Applicative as in, ErrorStatus as it, Layer as j, NAME as jt, TimeoutError as k, createCancellationTokenSource as kt, createCustomSerializer as l, ContainerOps as ln, ErrorWithTaskInfo as lt, fromYAML as m, Doable as mn, safeStringify as mt, FunctypeBase as n, Reshapeable as nn, ErrorCode as nt, Valuable as o, Functor as on, TypedErrorContext as ot, fromJSON as p, DoResult as pn, formatStackTrace as pt, OptionKind as q, NonEmptyString as qt, FunctypeCollection as r, Promisable as rn, ErrorMessage as rt, ValuableParams as s, Monad as sn, ErrorChainElement as st, Functype as t, ValidatedBrandCompanion as tn, Validator as tt, createSerializationCompanion as u, LazyList as un, TaskErrorInfo as ut, ESMap as v, Err as vt, TestContext as w, TaskMetadata as wt, Lazy as x, TaggedThrowable as xt, ESMapType as y, Ok as yt, HasService as z, InstanceType as zt };