functype 0.20.2 → 0.30.0

package/dist/src-BeaSFZFq.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"src-BeaSFZFq.js","names":["parsed: Record<string, unknown>","NONE: Option<never>","values: ESSetType<A>","set: Set<A>","Set","lazyList: LazyList<A>","elements: A[]","array: A[]","list: List<A>","Set","error: unknown","isRight","PositiveNumber: ValidatedBrandCompanion<\"PositiveNumber\", number>","NonNegativeNumber: ValidatedBrandCompanion<\"NonNegativeNumber\", number>","IntegerNumber: ValidatedBrandCompanion<\"IntegerNumber\", number>","PositiveInteger: ValidatedBrandCompanion<\n  \"PositiveInteger\",\n  Brand<\"PositiveNumber\", number>\n>","NonEmptyString: ValidatedBrandCompanion<\"NonEmptyString\", string>","EmailAddress: ValidatedBrandCompanion<\"EmailAddress\", string>","UrlString: ValidatedBrandCompanion<\"UrlString\", string>","UUID: ValidatedBrandCompanion<\"UUID\", string>","ISO8601Date: ValidatedBrandCompanion<\"ISO8601Date\", string>","cond: Cond<T>","state: CondState<T>","lazyChain: LazyCondChain<T>","match: Match<T, R>","newState: MatchState<T, R>","patterns: Array<{ pattern: Pattern<T>; handler: (value: T) => R }>","patterns: Array<{ pattern: Pattern<T>; result: PatternResult<T, R> }>","defaultResult: PatternResult<T, R> | undefined","result","error","results: Array<Either<E, T>>","errors: E[]","meta: TaskMetadata","error","TryConstructor","MonadConstructors: Record<string, MonadConstructor>","firstMonadType: string | null","cachedConstructor: MonadConstructor | undefined","localResults: T[]","accumulatedValues: unknown[]","defaultOptions: ErrorFormatterOptions","serialized: Record<string, unknown>","errors: TypedError<\"VALIDATION_FAILED\">[]","validated: Partial<T>","allValues: unknown[]","results: A[]","duration: number","io: IO<R, E, A>","ContextCompanion","buildIO: IO<RIn, E2, Context<ROut>>","initial: IO<TagService<Services[keyof Services]>, never, Partial<Ctx>>","initial: IO<R, E, A[]>","initial: IO<R, E, B[]>","ContextCompanion","_scheduled: ScheduledTask[]","IOCompanion","testContext: TestContext<R>","value: T | undefined","error: unknown | undefined","state: MapState<K, V>","newEntries: Array<[K, U]>","entries","Set","Map","result: B[]"],"sources":["../src/serialization/SerializationCompanion.ts","../src/option/Option.ts","../src/set/shim.ts","../src/set/Set.ts","../src/ref/Ref.ts","../src/internal/mutation-utils.ts","../src/list/LazyList.ts","../src/try/Try.ts","../src/typeable/Typeable.ts","../src/list/List.ts","../src/either/Either.ts","../src/branded/ValidatedBrand.ts","../src/companion/CompanionTypes.ts","../src/conditional/Cond.ts","../src/conditional/Match.ts","../src/core/base/Base.ts","../src/core/throwable/Throwable.ts","../src/fpromise/FPromise.ts","../src/core/task/Task.ts","../src/do/index.ts","../src/error/ErrorFormatter.ts","../src/error/ParseError.ts","../src/error/typed/TypedError.ts","../src/error/typed/Validation.ts","../src/extractable/Extractable.ts","../src/foldable/index.ts","../src/hkt/index.ts","../src/identity/Identity.ts","../src/io/Context.ts","../src/io/Exit.ts","../src/io/IO.ts","../src/io/Layer.ts","../src/io/Tag.ts","../src/io/TestClock.ts","../src/lazy/Lazy.ts","../src/map/shim.ts","../src/map/Map.ts","../src/matchable/Matchable.ts","../src/stack/Stack.ts","../src/valuable/Valuable.ts"],"sourcesContent":["import stringify from \"safe-stable-stringify\"\n\n/**\n * Serialization result containing methods for different formats\n */\nexport interface SerializationResult {\n  /** Serializes to JSON string */\n  toJSON: () => string\n  /** Serializes to YAML string */\n  toYAML: () => string\n  /** Serializes to base64-encoded binary string */\n  toBinary: () => string\n}\n\n/**\n * Creates a serializer for a simple tagged value\n * @param tag - The type tag (e.g., \"Some\", \"List\", \"Success\")\n * @param value - The value to serialize\n * @returns Serialization methods\n */\nexport const createSerializer = (tag: string, value: unknown): SerializationResult => ({\n  toJSON: () => JSON.stringify({ _tag: tag, value }),\n  toYAML: () => `_tag: ${tag}\\nvalue: ${stringify(value)}`,\n  toBinary: () => Buffer.from(JSON.stringify({ _tag: tag, value })).toString(\"base64\"),\n})\n\n/**\n * Creates a serializer for complex objects with custom serialization logic\n * @param data - The data object to serialize (should include _tag)\n * @returns Serialization methods\n */\nexport const createCustomSerializer = (data: Record<string, unknown>): SerializationResult => ({\n  toJSON: () => JSON.stringify(data),\n  toYAML: () => {\n    const entries = Object.entries(data)\n    return entries.map(([key, val]) => `${key}: ${stringify(val)}`).join(\"\\n\")\n  },\n  toBinary: () => Buffer.from(JSON.stringify(data)).toString(\"base64\"),\n})\n\n/**\n * Generic deserializer from JSON\n * @param json - The JSON string to parse\n * @param reconstructor - Function to reconstruct the type from parsed data\n * @returns Reconstructed instance\n */\nexport const fromJSON = <T>(\n  json: string,\n  reconstructor: (parsed: { _tag: string; [key: string]: unknown }) => T,\n): T => {\n  const parsed = JSON.parse(json) as { _tag: string; [key: string]: unknown }\n  return reconstructor(parsed)\n}\n\n/**\n * Generic deserializer from YAML (simple format)\n * @param yaml - The YAML string to parse\n * @param reconstructor - Function to reconstruct the type from parsed data\n * @returns Reconstructed instance\n */\nexport const fromYAML = <T>(\n  yaml: string,\n  reconstructor: (parsed: { _tag: string; [key: string]: unknown }) => T,\n): T => {\n  const lines = yaml.split(\"\\n\")\n  const parsed: Record<string, unknown> = {}\n\n  for (const line of lines) {\n    const colonIndex = line.indexOf(\": \")\n    if (colonIndex === -1) continue\n\n    const key = line.substring(0, colonIndex)\n    const valueStr = line.substring(colonIndex + 2)\n\n    if (!valueStr) {\n      parsed[key] = null\n      continue\n    }\n\n    // Try to parse as JSON, otherwise use as string\n    try {\n      parsed[key] = valueStr === \"null\" ? null : JSON.parse(valueStr)\n    } catch {\n      parsed[key] = valueStr\n    }\n  }\n\n  return reconstructor(parsed as { _tag: string; [key: string]: unknown })\n}\n\n/**\n * Generic deserializer from binary (base64-encoded JSON)\n * @param binary - The base64-encoded binary string\n * @param reconstructor - Function to reconstruct the type from parsed data\n * @returns Reconstructed instance\n */\nexport const fromBinary = <T>(\n  binary: string,\n  reconstructor: (parsed: { _tag: string; [key: string]: unknown }) => T,\n): T => {\n  const json = Buffer.from(binary, \"base64\").toString()\n  return fromJSON(json, reconstructor)\n}\n\n/**\n * Creates companion serialization methods for a type\n * @param reconstructor - Function to reconstruct the type from parsed data\n * @returns Companion methods object with fromJSON, fromYAML, and fromBinary\n */\nexport const createSerializationCompanion = <T>(\n  reconstructor: (parsed: { _tag: string; [key: string]: unknown }) => T,\n) => ({\n  fromJSON: (json: string) => fromJSON(json, reconstructor),\n  fromYAML: (yaml: string) => fromYAML(yaml, reconstructor),\n  fromBinary: (binary: string) => fromBinary(binary, reconstructor),\n})\n","import stringify from \"safe-stable-stringify\"\n\nimport { Companion } from \"@/companion/Companion\"\nimport { type Doable, type DoResult } from \"@/do/protocol\"\nimport type { Functype } from \"@/functype\"\nimport type { Reshapeable } from \"@/reshapeable\"\nimport { createSerializer } from \"@/serialization\"\nimport type { Promisable } from \"@/typeclass\"\nimport type { Type } from \"@/types\"\n\nimport type { Either } from \"../index\"\nimport { Left, List, Right, Try } from \"../index\"\n\n/**\n * Option type module\n * @module Option\n * @category Core\n */\n\n/**\n * The Option type represents a value that may or may not exist.\n * It's used to handle potentially null or undefined values in a type-safe way.\n * @typeParam T - The type of the value contained in the Option\n */\nexport interface Option<T extends Type> extends Functype<T, \"Some\" | \"None\">, Promisable<T>, Doable<T>, Reshapeable<T> {\n  /** The contained value (undefined for None) */\n  readonly value: T | undefined\n  /** Whether this Option contains no value */\n  isEmpty: boolean\n  /**\n   * Returns true if this Option is a Some (contains a value)\n   * @returns true if this Option contains a value, false otherwise\n   */\n  isSome(): this is Option<T> & { value: T; isEmpty: false }\n  /**\n   * Returns true if this Option is a None (contains no value)\n   * @returns true if this Option is empty, false otherwise\n   */\n  isNone(): this is Option<T> & { value: undefined; isEmpty: true }\n  /**\n   * Returns the contained value or a default value if None\n   * @param defaultValue - The value to return if this Option is None\n   * @returns The contained value or defaultValue\n   */\n  orElse(defaultValue: T): T\n  /**\n   * Returns the contained value or throws an error if None\n   * @param error - Optional custom error to throw. If not provided, throws a default error\n   * @returns The contained value\n   * @throws The specified error or a default error if the Option is None\n   */\n  orThrow(error?: Error): T\n  /**\n   * Returns this Option if it contains a value, otherwise returns the alternative container\n   * @param alternative - The alternative Option to return if this is None\n   * @returns This Option or the alternative\n   */\n  or(alternative: Option<T>): Option<T>\n  /**\n   * Returns the contained value or null if None\n   * @returns The contained value or null\n   */\n  orNull(): T | null\n  /**\n   * Returns the contained value or undefined if None\n   * @returns The contained value or undefined\n   */\n  orUndefined(): T | undefined\n  /**\n   * Maps the value inside the Option using the provided function\n   * @param f - The mapping function\n   * @returns A new Option containing the mapped value, or None if this Option is None\n   */\n  map<U extends Type>(f: (value: T) => U): Option<U>\n  /**\n   * Applies a wrapped function to a wrapped value (Applicative pattern)\n   * @param ff - An Option containing a function from T to U\n   * @returns A new Option containing the result of applying the function\n   */\n  ap<U extends Type>(ff: Option<(value: T) => U>): Option<U>\n  /**\n   * Returns this Option if it contains a value that satisfies the predicate, otherwise returns None\n   * @param predicate - The predicate function to test the value\n   * @returns This Option or None\n   */\n  filter(predicate: (value: T) => boolean): Option<T>\n  /**\n   * Maps the value using a function that returns an Option\n   * @param f - The mapping function returning an Option\n   * @returns The result of applying f to the contained value, or None if this Option is None\n   */\n  flatMap<U extends Type>(f: (value: T) => Option<U>): Option<U>\n  /**\n   * Maps the value using an async function that returns an Option\n   * @param f - The async mapping function returning an Option\n   * @returns Promise of the result of applying f to the contained value, or None if this Option is None\n   */\n  flatMapAsync<U extends Type>(f: (value: T) => Promise<Option<U>>): Promise<Option<U>>\n  /**\n   * Applies a binary operator to a start value and the contained value\n   * @param f - The binary operator\n   * @returns The result of the reduction\n   */\n  reduce<U>(f: (acc: U, value: T) => U): U\n  /**\n   * Applies a binary operator to the contained value and a start value\n   * @param f - The binary operator\n   * @returns The result of the reduction\n   */\n  reduceRight<U>(f: (acc: U, value: T) => U): U\n  /**\n   * Pattern matches over the Option, applying onNone if None and onSome if Some\n   * @param onNone - Function to apply if the Option is None\n   * @param onSome - Function to apply if the Option has a value\n   * @returns The result of applying the appropriate function\n   */\n  fold<U>(onNone: () => U, onSome: (value: T) => U): U\n  /**\n   * Left-associative fold using the provided zero value and operation\n   * @param z - Zero/identity value\n   * @returns A function that takes an operation to apply\n   */\n  foldLeft<B>(z: B): (op: (b: B, a: T) => B) => B\n  /**\n   * Right-associative fold using the provided zero value and operation\n   * @param z - Zero/identity value\n   * @returns A function that takes an operation to apply\n   */\n  foldRight<B>(z: B): (op: (a: T, b: B) => B) => B\n  /**\n   * Converts this Option to a List\n   * @returns A List containing the value if Some, or empty List if None\n   */\n  toList(): List<T>\n  /**\n   * Checks if this Option contains the specified value\n   * @param value - The value to check for\n   * @returns true if this Option contains the value, false otherwise\n   */\n  contains(value: T): boolean\n  /** The number of elements in this Option (0 or 1) */\n  size: number\n  /**\n   * Converts this Option to an Either\n   * @param left - The value to use for Left if this Option is None\n   * @returns Either.Right with the contained value if Some, or Either.Left with left if None\n   */\n  toEither<E>(left: E): Either<E, T>\n  /**\n   * Returns a string representation of this Option\n   * @returns A string representation\n   */\n  toString(): string\n  /**\n   * Returns a simple object representation of this Option\n   * @returns An object with _tag and value properties\n   */\n  toValue(): { _tag: \"Some\" | \"None\"; value: T }\n  /**\n   * Pattern matches over the Option, applying a handler function based on the variant\n   * @param patterns - Object with handler functions for Some and None variants\n   * @returns The result of applying the matching handler function\n   */\n  match<R>(patterns: { Some: (value: T) => R; None: () => R }): R\n}\n\n/**\n * Creates a Some variant of Option containing a value.\n * @param value - The value to wrap in Some\n * @returns A new Some instance containing the value\n * @typeParam T - The type of the value\n */\nexport const Some = <T extends Type>(value: T): Option<T> => ({\n  _tag: \"Some\",\n  value,\n  isEmpty: false,\n  isSome(): this is Option<T> & { value: T; isEmpty: false } {\n    return true\n  },\n  isNone(): this is Option<T> & { value: undefined; isEmpty: true } {\n    return false\n  },\n  orElse: () => value,\n  orThrow: () => value,\n  or: (_alternative: Option<T>) => Some(value),\n  orNull: () => value,\n  orUndefined: () => value,\n  map: <U extends Type>(f: (value: T) => U) => Some(f(value)),\n  ap: <U extends Type>(ff: Option<(value: T) => U>) =>\n    ff._tag === \"Some\" && ff.value ? Some(ff.value(value)) : (NONE as unknown as Option<U>),\n  filter(predicate: (value: T) => boolean) {\n    if (predicate(value)) {\n      return Some<T>(value) // type narrowing\n    } else {\n      return NONE as unknown as Option<T>\n    }\n  },\n  count: (p: (x: T) => boolean) => (p(value) ? 1 : 0),\n  find: (p: (a: T) => boolean) => (p(value) ? Some(value) : (NONE as unknown as Option<T>)),\n  exists: (p: (a: T) => boolean) => p(value),\n  forEach: (f: (a: T) => void) => f(value),\n  fold: <U extends Type>(_onNone: () => U, onSome: (value: T) => U) => {\n    return onSome(value)\n  },\n  match: <R>(patterns: { Some: (value: T) => R; None: () => R }): R => {\n    return patterns.Some(value)\n  },\n  flatMap: <U extends Type>(f: (value: T) => Option<U>) => f(value),\n  flatMapAsync: async <U extends Type>(f: (value: T) => Promise<Option<U>>) => {\n    return await f(value)\n  },\n  reduce: <U>(f: (acc: U, value: T) => U) => f(undefined as never, value),\n  reduceRight: <U>(f: (acc: U, value: T) => U) => f(undefined as never, value),\n  foldLeft:\n    <B>(z: B) =>\n    (op: (b: B, a: T) => B) =>\n      op(z, value),\n  foldRight:\n    <B>(z: B) =>\n    (op: (a: T, b: B) => B) =>\n      op(value, z),\n  toList: () => List<T>([value]),\n  contains: (val: T) => val === value,\n  size: 1,\n  toOption: () => Some(value),\n  toEither: <E>(_left: E) => Right<E, T>(value),\n  toTry: () => Try(() => value),\n  toPromise: (): Promise<T> => Promise.resolve(value),\n  toString: () => `Some(${stringify(value)})`,\n  toValue: () => ({ _tag: \"Some\", value }),\n  pipe: <U extends Type>(f: (value: T) => U) => f(value),\n  serialize: () => createSerializer(\"Some\", value),\n  // Implement Doable interface for Do-notation\n  doUnwrap(): DoResult<T> {\n    return { ok: true, value }\n  },\n})\n\nconst NONE: Option<never> = {\n  _tag: \"None\",\n  value: undefined as never,\n  isEmpty: true,\n  isSome(): this is Option<never> & { value: never; isEmpty: false } {\n    return false\n  },\n  isNone(): this is Option<never> & { value: undefined; isEmpty: true } {\n    return true\n  },\n  orElse: <T>(defaultValue: T) => defaultValue,\n  orThrow<T>(error?: Error): T {\n    throw error ?? new Error(\"Cannot extract value from None\")\n  },\n  or: (alternative: Option<never>) => alternative,\n  orNull: () => null,\n  orUndefined: () => undefined,\n  map: <U extends Type>(_f: (value: never) => U) => NONE as unknown as Option<U>,\n  ap: <U extends Type>(_ff: Option<(value: never) => U>) => NONE as unknown as Option<U>,\n  filter(_predicate: (value: never) => boolean): Option<never> {\n    return NONE\n  },\n  count: (_p: (x: never) => boolean) => 0,\n  find: (_p: (a: never) => boolean) => NONE as unknown as Option<never>,\n  exists: (_p: (a: never) => boolean) => false,\n  forEach: (_f: (a: never) => void) => {},\n  flatMap: <U extends Type>(_f: (value: never) => Option<U>) => NONE as unknown as Option<U>,\n  flatMapAsync: <U extends Type>(_f: (value: never) => Promise<Option<U>>): Promise<Option<U>> => {\n    return Promise.resolve(NONE as unknown as Option<U>)\n  },\n  reduce: () => undefined as never,\n  reduceRight: () => undefined as never,\n  fold: <U extends Type>(onNone: () => U, _onSome: (value: never) => U) => {\n    return onNone()\n  },\n  match: <R>(patterns: { Some: (value: never) => R; None: () => R }): R => {\n    return patterns.None()\n  },\n  foldLeft:\n    <B>(z: B) =>\n    () =>\n      z,\n  foldRight:\n    <B>(z: B) =>\n    () =>\n      z,\n  toList: () => List([]),\n  contains: () => false,\n  size: 0,\n  toOption: <T>() => NONE as unknown as Option<T>,\n  toEither: <E>(left: E) => Left<E, never>(left),\n  toTry: <T>() =>\n    Try<T>(() => {\n      throw new Error(\"None\")\n    }),\n  toPromise: <T>(): Promise<T> => Promise.reject(new Error(\"Cannot convert None to Promise\")),\n  toString: () => \"None\",\n  toValue: () => ({ _tag: \"None\", value: undefined as never }),\n  pipe: <U extends Type>(f: (_value: never) => U) => f(undefined as never),\n  serialize: () => createSerializer(\"None\", null),\n  // Implement Doable interface for Do-notation\n  doUnwrap(): DoResult<never> {\n    return { ok: false, empty: true }\n  },\n}\n\n/**\n * Creates a None variant of Option representing absence of a value.\n * @returns A new None instance\n * @typeParam T - The type that would be contained if this was a Some\n */\nexport const None = <T extends Type>(): Option<T> => NONE as unknown as Option<T>\n\n/**\n * Safely wraps a value that might be null or undefined in an Option.\n * Creates Some if the value is defined, None otherwise.\n * @param value - The value to wrap (might be null/undefined)\n * @returns Some(value) if value is defined, None otherwise\n * @typeParam T - The type of the value\n */\nexport const OptionConstructor = <T extends Type>(value: T | null | undefined): Option<T> =>\n  value !== null && value !== undefined ? Some<T>(value) : None<T>()\n\nconst OptionCompanion = {\n  /**\n   * Creates an Option from any value. Alias for Option function.\n   * @param value - The value to wrap\n   * @returns Some(value) if value is defined, None otherwise\n   * @typeParam T - The type of the value\n   */\n  from: <T>(value: T) => Option(value),\n  /**\n   * Returns a None instance. Alias for None function.\n   * @returns A None instance\n   * @typeParam T - The type that would be contained if this was a Some\n   */\n  none: <T>() => None<T>(),\n  /**\n   * Type guard to check if an Option is Some\n   * @param option - The Option to check\n   * @returns True if Option is Some\n   */\n  isSome: <T>(option: Option<T>): option is Option<T> & { value: T; isEmpty: false } => option.isSome(),\n  /**\n   * Type guard to check if an Option is None\n   * @param option - The Option to check\n   * @returns True if Option is None\n   */\n  isNone: <T>(option: Option<T>): option is Option<T> & { value: undefined; isEmpty: true } => option.isNone(),\n  /**\n   * Creates an Option from JSON string\n   * @param json - The JSON string\n   * @returns Option instance\n   */\n  fromJSON: <T>(json: string): Option<T> => {\n    const parsed = JSON.parse(json) as { _tag: string; value: T | null }\n    return parsed._tag === \"Some\" ? Some<T>(parsed.value as T) : None<T>()\n  },\n  /**\n   * Creates an Option from YAML string\n   * @param yaml - The YAML string\n   * @returns Option instance\n   */\n  fromYAML: <T>(yaml: string): Option<T> => {\n    const lines = yaml.split(\"\\n\")\n    const tag = lines[0]?.split(\": \")[1]\n    const valueStr = lines[1]?.split(\": \")[1]\n    if (!tag || !valueStr) {\n      return None<T>()\n    }\n    const value = valueStr === \"null\" ? null : (JSON.parse(valueStr) as T)\n    return tag === \"Some\" ? Some<T>(value as T) : None<T>()\n  },\n  /**\n   * Creates an Option from binary string\n   * @param binary - The binary string\n   * @returns Option instance\n   */\n  fromBinary: <T>(binary: string): Option<T> => {\n    const json = Buffer.from(binary, \"base64\").toString()\n    return OptionCompanion.fromJSON<T>(json)\n  },\n}\n\nexport const Option = Companion(OptionConstructor, OptionCompanion)\n","export type ESSetType<T> = Set<T>\nexport const ESSet = Set\n","import type { Collection } from \"@/collections\"\nimport { Companion } from \"@/companion/Companion\"\nimport type { FunctypeCollection } from \"@/functype\"\nimport { List } from \"@/list/List\"\nimport { Option } from \"@/option/Option\"\nimport { createSerializer } from \"@/serialization\"\nimport type { Type } from \"@/types\"\n\nimport { ESSet, type ESSetType } from \"./shim\"\n\nexport interface Set<A> extends FunctypeCollection<A, \"Set\">, Collection<A> {\n  add: (value: A) => Set<A>\n  remove: (value: A) => Set<A>\n  contains: (value: A) => boolean\n  has: (value: A) => boolean\n  map: <B>(f: (a: A) => B) => Set<B>\n  flatMap: <B>(f: (a: A) => Iterable<B>) => Set<B>\n  filter: (p: (a: A) => boolean) => Set<A>\n  filterNot: (p: (a: A) => boolean) => Set<A>\n  fold: <U extends Type>(onEmpty: () => U, onValue: (value: A) => U) => U\n  toList: () => List<A>\n  toSet: () => Set<A>\n  toArray: <B = A>() => B[]\n  toString: () => string\n}\n\nconst createSet = <A>(iterable?: Iterable<A>): Set<A> => {\n  const values: ESSetType<A> = new ESSet<A>(iterable)\n\n  const set: Set<A> = {\n    _tag: \"Set\",\n\n    [Symbol.iterator]: () => values[Symbol.iterator](),\n\n    add: (value: A): Set<A> => createSet([...values, value]),\n\n    remove: (value: A): Set<A> => {\n      const newSet = new ESSet(values)\n      newSet.delete(value)\n      return createSet(newSet)\n    },\n\n    contains: (value: A): boolean => values.has(value),\n\n    has: (value: A): boolean => values.has(value),\n\n    map: <B>(f: (a: A) => B): Set<B> => createSet(Array.from(values).map(f)),\n\n    ap: <B>(ff: Set<(value: A) => B>): Set<B> => {\n      const results = new ESSet<B>()\n      for (const a of values) {\n        for (const f of ff) {\n          results.add(f(a))\n        }\n      }\n      return createSet(results)\n    },\n\n    flatMap: <B>(f: (a: A) => Iterable<B>): Set<B> => {\n      const results = new ESSet<B>()\n      for (const a of values) {\n        for (const b of f(a)) {\n          results.add(b)\n        }\n      }\n      return createSet(results)\n    },\n\n    flatMapAsync: async <B>(f: (a: A) => PromiseLike<Iterable<B>>): Promise<Set<B>> => {\n      const results = new ESSet<B>()\n      for (const a of values) {\n        const items = await f(a)\n        for (const b of items) {\n          results.add(b)\n        }\n      }\n      return createSet(results)\n    },\n\n    fold: <U extends Type>(onEmpty: () => U, onValue: (value: A) => U): U => {\n      if (values.size === 0) return onEmpty()\n\n      // For Set, we'll always return the first entry as the value for fold\n      // This is consistent with how Option and other single-value types work\n      const entries = Array.from(values)\n      if (entries.length === 0) {\n        return onEmpty()\n      }\n\n      const firstEntry = entries[0]\n      // Make sure we handle potential undefined values\n      if (firstEntry === undefined) {\n        return onEmpty()\n      }\n\n      return onValue(firstEntry)\n    },\n\n    foldLeft:\n      <B>(z: B) =>\n      (op: (b: B, a: A) => B) => {\n        let acc = z\n        for (const a of values) {\n          acc = op(acc, a)\n        }\n        return acc\n      },\n\n    foldRight:\n      <B>(z: B) =>\n      (op: (a: A, b: B) => B) => {\n        const arr = Array.from(values)\n        return arr.reduceRight((acc, value) => op(value, acc), z)\n      },\n\n    get size() {\n      return values.size\n    },\n\n    get isEmpty() {\n      return values.size === 0\n    },\n\n    reduce: (f: (prev: A, curr: A) => A) => {\n      const arr = Array.from(values)\n      if (arr.length === 0) throw new Error(\"Cannot reduce empty Set\")\n      return arr.reduce(f)\n    },\n\n    reduceRight: (f: (prev: A, curr: A) => A) => {\n      const arr = Array.from(values)\n      if (arr.length === 0) throw new Error(\"Cannot reduceRight empty Set\")\n      return arr.reduceRight(f)\n    },\n\n    count: (p: (x: A) => boolean) => {\n      let count = 0\n      for (const a of values) {\n        if (p(a)) count++\n      }\n      return count\n    },\n\n    find: (p: (a: A) => boolean) => {\n      for (const a of values) {\n        if (p(a)) return Option(a)\n      }\n      return Option<A>(null)\n    },\n\n    exists: (p: (a: A) => boolean) => {\n      for (const a of values) {\n        if (p(a)) return true\n      }\n      return false\n    },\n\n    forEach: (f: (a: A) => void) => {\n      values.forEach(f)\n    },\n\n    filter: (p: (a: A) => boolean) => {\n      const results = new ESSet<A>()\n      for (const a of values) {\n        if (p(a)) results.add(a)\n      }\n      return createSet(results)\n    },\n\n    filterNot: (p: (a: A) => boolean) => {\n      const results = new ESSet<A>()\n      for (const a of values) {\n        if (!p(a)) results.add(a)\n      }\n      return createSet(results)\n    },\n\n    drop: (n: number) => createSet(Array.from(values).slice(n)),\n\n    dropRight: (n: number) => createSet(Array.from(values).slice(0, -n)),\n\n    dropWhile: (p: (a: A) => boolean) => {\n      const arr = Array.from(values)\n      const idx = arr.findIndex((x) => !p(x))\n      return createSet(idx === -1 ? [] : arr.slice(idx))\n    },\n\n    flatten: <B>() => {\n      const results = new ESSet<B>()\n      for (const item of values) {\n        if (Array.isArray(item)) {\n          for (const subItem of item) {\n            results.add(subItem as B)\n          }\n        } else if (item && typeof item === \"object\" && Symbol.iterator in item) {\n          for (const subItem of item as Iterable<B>) {\n            results.add(subItem)\n          }\n        } else {\n          results.add(item as unknown as B)\n        }\n      }\n      return createSet(results)\n    },\n\n    get head() {\n      return Array.from(values)[0] as A | undefined\n    },\n\n    get headOption() {\n      const first = Array.from(values)[0]\n      return Option(first)\n    },\n\n    toList: (): List<A> => List(Array.from(values)),\n\n    toSet: (): Set<A> => set,\n\n    toArray: <B = A>(): B[] => Array.from(values) as unknown as B[],\n\n    toString: (): string => `Set(${Array.from(values).toString()})`,\n\n    toValue: (): { _tag: \"Set\"; value: A[] } => ({ _tag: \"Set\", value: Array.from(values) }),\n\n    pipe: <U>(f: (value: A[]) => U) => f(Array.from(values)),\n\n    serialize: () => createSerializer(\"Set\", Array.from(values)),\n  }\n\n  return set\n}\n\nconst SetConstructor = <A>(iterable?: Iterable<A>): Set<A> => createSet(iterable)\n\nconst SetCompanion = {\n  /**\n   * Creates a Set from JSON string\n   * @param json - The JSON string\n   * @returns Set instance\n   */\n  fromJSON: <A>(json: string): Set<A> => {\n    const parsed = JSON.parse(json) as { _tag: string; value: A[] }\n    return Set<A>(parsed.value)\n  },\n\n  /**\n   * Creates a Set from YAML string\n   * @param yaml - The YAML string\n   * @returns Set instance\n   */\n  fromYAML: <A>(yaml: string): Set<A> => {\n    const lines = yaml.split(\"\\n\")\n    const valueStr = lines[1]?.split(\": \")[1]\n    if (!valueStr) {\n      return Set<A>([])\n    }\n    const value = JSON.parse(valueStr) as A[]\n    return Set<A>(value)\n  },\n\n  /**\n   * Creates a Set from binary string\n   * @param binary - The binary string\n   * @returns Set instance\n   */\n  fromBinary: <A>(binary: string): Set<A> => {\n    const json = Buffer.from(binary, \"base64\").toString()\n    return SetCompanion.fromJSON<A>(json)\n  },\n}\n\nexport const Set = Companion(SetConstructor, SetCompanion)\n","import { Companion } from \"@/companion/Companion\"\nimport type { Type } from \"@/types\"\n\n/**\n * A mutable reference container that holds a value of type A.\n * This provides controlled mutability in a functional context.\n *\n * @example\n * const counter = Ref(0)\n * counter.get() // 0\n * counter.set(5)\n * counter.get() // 5\n * counter.update(n => n + 1)\n * counter.get() // 6\n */\nexport interface Ref<A> {\n  /**\n   * Get the current value\n   */\n  get(): A\n\n  /**\n   * Set a new value\n   */\n  set(value: A): void\n\n  /**\n   * Update the value using a function\n   */\n  update(f: (current: A) => A): void\n\n  /**\n   * Update and return the old value\n   */\n  getAndSet(value: A): A\n\n  /**\n   * Update and return the new value\n   */\n  updateAndGet(f: (current: A) => A): A\n\n  /**\n   * Update and return the old value\n   */\n  getAndUpdate(f: (current: A) => A): A\n\n  /**\n   * Compare and swap - only updates if current value equals expected\n   */\n  compareAndSet(expected: A, newValue: A): boolean\n\n  /**\n   * Modify the value and return a result\n   */\n  modify<B>(f: (current: A) => [A, B]): B\n}\n\n/**\n * Creates a new mutable reference containing the given value\n */\nconst RefConstructor = <A extends Type>(initial: A): Ref<A> => {\n  let _value = initial\n\n  const ref: Ref<A> = {\n    get(): A {\n      return _value\n    },\n\n    set(value: A): void {\n      _value = value\n    },\n\n    update(f: (current: A) => A): void {\n      _value = f(_value)\n    },\n\n    getAndSet(value: A): A {\n      const old = _value\n      _value = value\n      return old\n    },\n\n    updateAndGet(f: (current: A) => A): A {\n      _value = f(_value)\n      return _value\n    },\n\n    getAndUpdate(f: (current: A) => A): A {\n      const old = _value\n      _value = f(_value)\n      return old\n    },\n\n    compareAndSet(expected: A, newValue: A): boolean {\n      if (_value === expected) {\n        _value = newValue\n        return true\n      }\n      return false\n    },\n\n    modify<B>(f: (current: A) => [A, B]): B {\n      const [newValue, result] = f(_value)\n      _value = newValue\n      return result\n    },\n  }\n\n  return ref\n}\n\nconst RefCompanion = {\n  /**\n   * Creates a Ref. Alias for Ref constructor.\n   * @param initial - The initial value\n   * @returns Ref instance\n   */\n  of: <A extends Type>(initial: A) => RefConstructor(initial),\n}\n\nexport const Ref = Companion(RefConstructor, RefCompanion)\n","/**\n * Centralized mutation utilities using Ref for controlled impurity\n *\n * These utilities provide approved patterns for mutation in functype,\n * keeping impure operations explicit and contained.\n */\n\nimport { Ref } from \"@/ref/Ref\"\nimport type { Type } from \"@/types\"\n\n/**\n * Counter utility for managing incrementing/decrementing numbers\n *\n * @example\n * const attempts = Counter(0)\n * attempts.increment() // returns 1\n * attempts.get() // 1\n * attempts.decrement() // returns 0\n */\nexport interface Counter {\n  get(): number\n  set(value: number): void\n  increment(): number\n  decrement(): number\n  reset(): void\n  compareAndSet(expected: number, newValue: number): boolean\n}\n\nexport const Counter = (initial: number = 0): Counter => {\n  const ref = Ref(initial)\n  const initialValue = initial\n\n  return {\n    get: () => ref.get(),\n    set: (value: number) => ref.set(value),\n    increment: () => ref.updateAndGet((n) => n + 1),\n    decrement: () => ref.updateAndGet((n) => n - 1),\n    reset: () => ref.set(initialValue),\n    compareAndSet: (expected: number, newValue: number) => ref.compareAndSet(expected, newValue),\n  }\n}\n\n/**\n * Cache utility for managing optional cached values\n *\n * @example\n * const cache = Cache<string>()\n * if (!cache.has()) {\n *   cache.set(expensiveComputation())\n * }\n * return cache.get() // string | undefined\n */\nexport interface Cache<T extends Type> {\n  get(): T | undefined\n  set(value: T): void\n  has(): boolean\n  clear(): void\n  getOrCompute(compute: () => T): T\n}\n\nexport const Cache = <T extends Type>(initial?: T): Cache<T> => {\n  const ref = Ref<T | undefined>(initial)\n\n  return {\n    get: () => ref.get(),\n    set: (value: T) => ref.set(value),\n    has: () => ref.get() !== undefined,\n    clear: () => ref.set(undefined),\n    getOrCompute: (compute: () => T): T => {\n      const cached = ref.get()\n      if (cached !== undefined) {\n        return cached\n      }\n      const computed = compute()\n      ref.set(computed)\n      return computed\n    },\n  }\n}\n\n/**\n * Builder utility for incrementally constructing arrays\n *\n * @example\n * const builder = ArrayBuilder<string>()\n * builder.add(\"hello\")\n * builder.add(\"world\")\n * const result = builder.build() // [\"hello\", \"world\"]\n */\nexport interface ArrayBuilder<T extends Type> {\n  add(item: T): void\n  addAll(items: T[]): void\n  build(): T[]\n  clear(): void\n  size(): number\n}\n\nexport const ArrayBuilder = <T extends Type>(): ArrayBuilder<T> => {\n  const ref = Ref<T[]>([])\n\n  return {\n    add: (item: T) => ref.update((arr) => [...arr, item]),\n    addAll: (items: T[]) => ref.update((arr) => [...arr, ...items]),\n    build: () => ref.get(),\n    clear: () => ref.set([]),\n    size: () => ref.get().length,\n  }\n}\n\n/**\n * ObjectBuilder utility for incrementally constructing objects\n *\n * @example\n * const builder = ObjectBuilder<{name: string, age: number}>()\n * builder.set('name', 'John')\n * builder.set('age', 30)\n * const result = builder.build() // {name: 'John', age: 30}\n */\nexport interface ObjectBuilder<T extends Record<string, Type>> {\n  set<K extends keyof T>(key: K, value: T[K]): void\n  get<K extends keyof T>(key: K): T[K] | undefined\n  has<K extends keyof T>(key: K): boolean\n  build(): Partial<T>\n  clear(): void\n}\n\nexport const ObjectBuilder = <T extends Record<string, Type>>(): ObjectBuilder<T> => {\n  const ref = Ref<Partial<T>>({})\n\n  return {\n    set: <K extends keyof T>(key: K, value: T[K]) => {\n      ref.update((obj) => ({ ...obj, [key]: value }))\n    },\n    get: <K extends keyof T>(key: K): T[K] | undefined => {\n      return ref.get()[key]\n    },\n    has: <K extends keyof T>(key: K): boolean => {\n      return key in ref.get()\n    },\n    build: () => ref.get(),\n    clear: () => ref.set({}),\n  }\n}\n","import stringify from \"safe-stable-stringify\"\n\nimport { Companion } from \"@/companion/Companion\"\nimport type { Foldable } from \"@/foldable/Foldable\"\nimport { Counter } from \"@/internal/mutation-utils\"\nimport { Option } from \"@/option\"\nimport type { Pipe } from \"@/pipe\"\nimport { Ref } from \"@/ref/Ref\"\nimport type { Serializable } from \"@/serializable/Serializable\"\nimport type { Typeable } from \"@/typeable/Typeable\"\nimport type { Type } from \"@/types\"\n\nimport { List } from \"./List\"\n\n/**\n * LazyList provides lazy evaluation for list operations.\n * Operations are deferred until the list is materialized.\n *\n * @example\n * // Basic lazy evaluation\n * const result = LazyList([1, 2, 3, 4, 5])\n *   .map(x => x * 2)\n *   .filter(x => x > 5)\n *   .toArray() // [6, 8, 10]\n *\n * @example\n * // Infinite sequences with take\n * const fibonacci = LazyList.iterate([0, 1], ([a, b]) => [b, a + b])\n *   .map(([a]) => a)\n *   .take(10)\n *   .toArray() // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n */\nexport interface LazyList<A extends Type>\n  extends Foldable<A>, Pipe<LazyList<A>>, Serializable<LazyList<A>>, Typeable<\"LazyList\"> {\n  // Iterator protocol\n  [Symbol.iterator](): Iterator<A>\n\n  // Lazy operations\n  map<B extends Type>(f: (a: A) => B): LazyList<B>\n  flatMap<B extends Type>(f: (a: A) => LazyList<B>): LazyList<B>\n  filter(predicate: (a: A) => boolean): LazyList<A>\n  take(n: number): LazyList<A>\n  drop(n: number): LazyList<A>\n  takeWhile(predicate: (a: A) => boolean): LazyList<A>\n  dropWhile(predicate: (a: A) => boolean): LazyList<A>\n  concat(other: LazyList<A>): LazyList<A>\n  zip<B extends Type>(other: LazyList<B>): LazyList<[A, B]>\n\n  // Terminal operations (force evaluation)\n  toList(): List<A>\n  toArray(): A[]\n  forEach(f: (a: A) => void): void\n  reduce<B extends Type>(f: (acc: B, a: A) => B, initial: B): B\n  find(predicate: (a: A) => boolean): Option<A>\n  some(predicate: (a: A) => boolean): boolean\n  every(predicate: (a: A) => boolean): boolean\n  count(): number\n  first(): Option<A>\n  last(): Option<A>\n\n  // Additional methods for clarity\n  toString(): string\n}\n\nconst LazyListObject = <A extends Type>(iterable: Iterable<A>): LazyList<A> => {\n  const lazyList: LazyList<A> = {\n    _tag: \"LazyList\" as const,\n    [Symbol.iterator]: () => iterable[Symbol.iterator](),\n\n    map: <B extends Type>(f: (a: A) => B) =>\n      LazyListObject(\n        (function* () {\n          for (const item of iterable) {\n            yield f(item)\n          }\n        })(),\n      ),\n\n    flatMap: <B extends Type>(f: (a: A) => LazyList<B>) =>\n      LazyListObject(\n        (function* () {\n          for (const item of iterable) {\n            yield* f(item)\n          }\n        })(),\n      ),\n\n    filter: (predicate: (a: A) => boolean) =>\n      LazyListObject(\n        (function* () {\n          for (const item of iterable) {\n            if (predicate(item)) {\n              yield item\n            }\n          }\n        })(),\n      ),\n\n    take: (n: number) =>\n      LazyListObject(\n        (function* () {\n          const counter = Counter(0)\n          for (const item of iterable) {\n            if (counter.get() >= n) break\n            yield item\n            counter.increment()\n          }\n        })(),\n      ),\n\n    drop: (n: number) =>\n      LazyListObject(\n        (function* () {\n          const counter = Counter(0)\n          for (const item of iterable) {\n            if (counter.get() >= n) {\n              yield item\n            }\n            counter.increment()\n          }\n        })(),\n      ),\n\n    takeWhile: (predicate: (a: A) => boolean) =>\n      LazyListObject(\n        (function* () {\n          for (const item of iterable) {\n            if (!predicate(item)) break\n            yield item\n          }\n        })(),\n      ),\n\n    dropWhile: (predicate: (a: A) => boolean) =>\n      LazyListObject(\n        (function* () {\n          const dropping = Ref(true)\n          for (const item of iterable) {\n            if (dropping.get() && predicate(item)) continue\n            dropping.set(false)\n            yield item\n          }\n        })(),\n      ),\n\n    concat: (other: LazyList<A>) =>\n      LazyListObject(\n        (function* () {\n          yield* iterable\n          yield* other\n        })(),\n      ),\n\n    zip: <B extends Type>(other: LazyList<B>) =>\n      LazyListObject(\n        (function* () {\n          const iter1 = iterable[Symbol.iterator]()\n          const iter2 = other[Symbol.iterator]()\n\n          while (true) {\n            const next1 = iter1.next()\n            const next2 = iter2.next()\n\n            if (next1.done || next2.done) break\n            yield [next1.value, next2.value] as [A, B]\n          }\n        })(),\n      ),\n\n    // Terminal operations\n    toList: () => List(Array.from(iterable)),\n\n    toArray: () => Array.from(iterable),\n\n    forEach: (f: (a: A) => void) => {\n      for (const item of iterable) {\n        f(item)\n      }\n    },\n\n    reduce: <B extends Type>(f: (acc: B, a: A) => B, initial: B) => {\n      const acc = Ref(initial)\n      for (const item of iterable) {\n        acc.set(f(acc.get(), item))\n      }\n      return acc.get()\n    },\n\n    find: (predicate: (a: A) => boolean) => {\n      for (const item of iterable) {\n        if (predicate(item)) {\n          return Option(item)\n        }\n      }\n      return Option.none()\n    },\n\n    some: (predicate: (a: A) => boolean) => {\n      for (const item of iterable) {\n        if (predicate(item)) return true\n      }\n      return false\n    },\n\n    every: (predicate: (a: A) => boolean) => {\n      for (const item of iterable) {\n        if (!predicate(item)) return false\n      }\n      return true\n    },\n\n    count: () => {\n      const counter = Counter(0)\n\n      for (const _ of iterable) {\n        counter.increment()\n      }\n      return counter.get()\n    },\n\n    first: () => {\n      const iter = iterable[Symbol.iterator]()\n      const next = iter.next()\n      return next.done ? Option.none() : Option(next.value)\n    },\n\n    last: () => {\n      const lastValue = Ref<A | undefined>(undefined)\n      const hasValue = Ref(false)\n      for (const item of iterable) {\n        lastValue.set(item)\n        hasValue.set(true)\n      }\n      return hasValue.get() ? Option(lastValue.get() as A) : Option.none()\n    },\n\n    // Foldable implementation\n    fold: <B extends Type>(onEmpty: () => B, onValue: (value: A) => B): B => {\n      const iter = iterable[Symbol.iterator]()\n      const next = iter.next()\n      return next.done ? onEmpty() : onValue(next.value)\n    },\n\n    foldLeft:\n      <B extends Type>(z: B) =>\n      (op: (b: B, a: A) => B) => {\n        const acc = Ref(z)\n        for (const item of iterable) {\n          acc.set(op(acc.get(), item))\n        }\n        return acc.get()\n      },\n\n    foldRight:\n      <B extends Type>(z: B) =>\n      (op: (a: A, b: B) => B) => {\n        // For lazy list, we need to materialize to fold right\n        const arr = Array.from(iterable)\n        return arr.reduceRight((acc, value) => op(value, acc), z)\n      },\n\n    // Pipe implementation\n    pipe: <U extends Type>(f: (value: LazyList<A>) => U): U => f(lazyList),\n\n    // Serializable implementation\n    serialize: () => {\n      // For serialization, we need to materialize the lazy list\n      const array = Array.from(iterable)\n      return {\n        toJSON: () => JSON.stringify({ _tag: \"LazyList\", value: array }),\n        toYAML: () => `_tag: LazyList\\nvalue: ${stringify(array)}`,\n        toBinary: () => Buffer.from(JSON.stringify({ _tag: \"LazyList\", value: array })).toString(\"base64\"),\n      }\n    },\n\n    // Override toString from Base to show elements (limited for infinite lists)\n    toString: () => {\n      const maxShow = 10\n      const elements: A[] = []\n      const counter = Counter(0)\n      const hasMore = Ref(false)\n\n      for (const item of iterable) {\n        if (counter.get() < maxShow) {\n          elements.push(item)\n          counter.increment()\n        } else {\n          hasMore.set(true)\n          break\n        }\n      }\n\n      const elemStr = elements.map((e) => String(e)).join(\", \")\n      return hasMore.get() ? `LazyList(${elemStr}, ...)` : `LazyList(${elemStr})`\n    },\n  }\n\n  return lazyList\n}\n\n/**\n * Create a LazyList from an iterable\n * @example\n * const lazy = LazyList([1, 2, 3, 4, 5])\n *   .map(x => x * x)\n *   .filter(x => x % 2 === 1)\n *   .toArray() // [1, 9, 25]\n *\n * @example\n * // From generator function\n * function* naturals() {\n *   let n = 1\n *   while (true) yield n++\n * }\n * const firstTenSquares = LazyList(naturals())\n *   .map(x => x * x)\n *   .take(10)\n *   .toArray() // [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n */\nconst LazyListConstructor = <A extends Type>(iterable: Iterable<A>): LazyList<A> => {\n  return LazyListObject(iterable)\n}\n\nconst LazyListCompanion = {\n  /**\n   * Create an empty LazyList\n   * @example\n   * const empty = LazyList.empty<number>()\n   * empty.toArray() // []\n   */\n  empty: <A extends Type>(): LazyList<A> => {\n    return LazyListObject<A>([])\n  },\n\n  /**\n   * Create a LazyList from a single value\n   * @example\n   * const single = LazyList.of(42)\n   *   .map(x => x * 2)\n   *   .toArray() // [84]\n   */\n  of: <A extends Type>(value: A): LazyList<A> => {\n    return LazyListObject([value])\n  },\n\n  /**\n   * Create a LazyList from multiple values\n   */\n  from: <A extends Type>(...values: A[]): LazyList<A> => {\n    return LazyListObject(values)\n  },\n\n  /**\n   * Create an infinite LazyList by repeatedly applying a function\n   * @example\n   * // Powers of 2\n   * const powers = LazyList.iterate(1, x => x * 2)\n   *   .take(10)\n   *   .toArray() // [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]\n   *\n   * @example\n   * // Fibonacci sequence\n   * const fib = LazyList.iterate([0, 1], ([a, b]) => [b, a + b])\n   *   .map(([a]) => a)\n   *   .take(8)\n   *   .toArray() // [0, 1, 1, 2, 3, 5, 8, 13]\n   */\n  iterate: <A extends Type>(initial: A, f: (a: A) => A): LazyList<A> => {\n    return LazyListObject(\n      (function* () {\n        const current = Ref(initial)\n        while (true) {\n          yield current.get()\n          current.set(f(current.get()))\n        }\n      })(),\n    )\n  },\n\n  /**\n   * Create an infinite LazyList by repeatedly calling a function\n   */\n  generate: <A extends Type>(f: () => A): LazyList<A> => {\n    return LazyListObject(\n      (function* () {\n        while (true) {\n          yield f()\n        }\n      })(),\n    )\n  },\n\n  /**\n   * Create a LazyList of numbers from start to end (exclusive)\n   * @example\n   * LazyList.range(1, 6).toArray() // [1, 2, 3, 4, 5]\n   * LazyList.range(0, 10, 2).toArray() // [0, 2, 4, 6, 8]\n   * LazyList.range(10, 0, -1).toArray() // [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n   *\n   * @example\n   * // Sum of squares from 1 to 100\n   * const sum = LazyList.range(1, 101)\n   *   .map(x => x * x)\n   *   .reduce((a, b) => a + b, 0) // 338350\n   */\n  range: (start: number, end: number, step = 1): LazyList<number> => {\n    return LazyListObject(\n      (function* () {\n        if (step === 0) throw new Error(\"Step cannot be zero\")\n\n        const current = Ref(start)\n        if (step > 0) {\n          while (current.get() < end) {\n            yield current.get()\n            current.set(current.get() + step)\n          }\n        } else {\n          while (current.get() > end) {\n            yield current.get()\n            current.set(current.get() + step)\n          }\n        }\n      })(),\n    )\n  },\n\n  /**\n   * Create a LazyList that repeats a value n times (or infinitely if n is not provided)\n   */\n  repeat: <A extends Type>(value: A, n?: number): LazyList<A> => {\n    return LazyListObject(\n      (function* () {\n        if (n === undefined) {\n          while (true) yield value\n        } else {\n          const counter = Counter(0)\n          while (counter.get() < n) {\n            yield value\n            counter.increment()\n          }\n        }\n      })(),\n    )\n  },\n\n  /**\n   * Create a LazyList that cycles through an iterable infinitely\n   */\n  cycle: <A extends Type>(iterable: Iterable<A>): LazyList<A> => {\n    return LazyListObject(\n      (function* () {\n        const items = Array.from(iterable)\n        if (items.length === 0) return\n\n        while (true) {\n          yield* items\n        }\n      })(),\n    )\n  },\n}\n\n/**\n * Lazy list implementation for efficient deferred computation\n * @example\n * // Process large datasets efficiently\n * const result = LazyList.range(1, 1000000)\n *   .filter(x => x % 2 === 0)\n *   .map(x => x * x)\n *   .take(5)\n *   .toArray() // [4, 16, 36, 64, 100]\n *\n * @example\n * // Infinite sequences\n * const primes = LazyList.iterate(2, n => n + 1)\n *   .filter(isPrime)\n *   .take(10)\n *   .toArray() // First 10 prime numbers\n *\n * @example\n * // Combining operations\n * const evens = LazyList.range(0, 100, 2)\n * const odds = LazyList.range(1, 100, 2)\n * const combined = evens.zip(odds)\n *   .map(([e, o]) => e + o)\n *   .take(5)\n *   .toArray() // [1, 5, 9, 13, 17]\n */\nexport const LazyList = Companion(LazyListConstructor, LazyListCompanion)\n","import stringify from \"safe-stable-stringify\"\n\nimport { Companion } from \"@/companion/Companion\"\nimport { type Doable, type DoResult } from \"@/do/protocol\"\nimport type { Either } from \"@/either/Either\"\nimport { Left, Right } from \"@/either/Either\"\nimport type { Extractable } from \"@/extractable\"\nimport type { FunctypeBase } from \"@/functype\"\nimport { List } from \"@/list\"\nimport { None, Option, Some } from \"@/option\"\nimport type { Pipe } from \"@/pipe\"\nimport type { Reshapeable } from \"@/reshapeable\"\nimport { createCustomSerializer, createSerializer } from \"@/serialization\"\nimport type { Promisable } from \"@/typeclass\"\nimport type { Type } from \"@/types\"\n\n/**\n * Possible types of Try instances\n */\nexport type TypeNames = \"Success\" | \"Failure\"\n\nexport interface Try<T>\n  extends FunctypeBase<T, TypeNames>, Extractable<T>, Pipe<T>, Promisable<T>, Doable<T>, Reshapeable<T> {\n  readonly _tag: TypeNames\n  readonly error: Error | undefined\n  isSuccess(): this is Try<T> & { readonly _tag: \"Success\"; error: undefined }\n  isFailure(): this is Try<T> & { readonly _tag: \"Failure\"; error: Error }\n  orElse: (defaultValue: T) => T\n  orThrow: (error?: Error) => T\n  or: (alternative: Try<T>) => Try<T>\n  orNull: () => T | null\n  orUndefined: () => T | undefined\n  toOption: () => Option<T>\n  toEither: <E extends Type>(leftValue: E) => Either<E, T>\n  toList: () => List<T>\n  toTry: () => Try<T>\n  map: <U>(f: (value: T) => U) => Try<U>\n  ap: <U>(ff: Try<(value: T) => U>) => Try<U>\n  flatMap: <U>(f: (value: T) => Try<U>) => Try<U>\n  flatMapAsync: <U>(f: (value: T) => Promise<Try<U>>) => Promise<Try<U>>\n  /**\n   * Pattern matches over the Try, applying onFailure if Failure and onSuccess if Success\n   * @param onFailure - Function to apply if the Try is Failure\n   * @param onSuccess - Function to apply if the Try is Success\n   * @returns The result of applying the appropriate function\n   */\n  fold: <U extends Type>(onFailure: (error: Error) => U, onSuccess: (value: T) => U) => U\n  toString: () => string\n  /**\n   * Pattern matches over the Try, applying a handler function based on the variant\n   * @param patterns - Object with handler functions for Success and Failure variants\n   * @returns The result of applying the matching handler function\n   */\n  match<R>(patterns: { Success: (value: T) => R; Failure: (error: Error) => R }): R\n  toValue(): { _tag: TypeNames; value: T | Error }\n}\n\nconst Success = <T>(value: T): Try<T> => ({\n  _tag: \"Success\",\n  error: undefined,\n  isSuccess(): this is Try<T> & { readonly _tag: \"Success\"; error: undefined } {\n    return true\n  },\n  isFailure(): this is Try<T> & { readonly _tag: \"Failure\"; error: Error } {\n    return false\n  },\n  orElse: (_defaultValue: T) => value,\n  orThrow: (_error?: Error) => value,\n  or: (_alternative: Try<T>) => Success(value),\n  orNull: () => value,\n  orUndefined: () => value,\n  toEither: <E extends Type>(_leftValue: E) => Right<E, T>(value),\n  map: <U>(f: (value: T) => U) => Try(() => f(value)),\n  ap: <U>(ff: Try<(value: T) => U>) => ff.map((f) => f(value)),\n  flatMap: <U>(f: (value: T) => Try<U>) => f(value),\n  flatMapAsync: async <U>(f: (value: T) => Promise<Try<U>>) => f(value),\n  fold: <U extends Type>(_onFailure: (error: Error) => U, onSuccess: (value: T) => U): U => onSuccess(value),\n  match: <R>(patterns: { Success: (value: T) => R; Failure: (error: Error) => R }): R => patterns.Success(value),\n  foldLeft:\n    <B>(z: B) =>\n    (op: (b: B, a: T) => B) =>\n      op(z, value),\n  foldRight:\n    <B>(z: B) =>\n    (op: (a: T, b: B) => B) =>\n      op(value, z),\n  toString: () => `Success(${stringify(value)})`,\n  toPromise: (): Promise<T> => Promise.resolve(value),\n  toValue: () => ({ _tag: \"Success\", value }),\n  toOption: () => Some(value),\n  toList: () => List([value]),\n  toTry: () => Success(value),\n  pipe: <U>(f: (value: T) => U) => f(value),\n  serialize: () => createSerializer(\"Success\", value),\n  get size() {\n    return 1\n  },\n  get isEmpty() {\n    return false\n  },\n  contains: (v: T) => value === v,\n  reduce: (_f: (b: T, a: T) => T) => value,\n  reduceRight: (_f: (b: T, a: T) => T) => value,\n  count: (p: (x: T) => boolean) => (p(value) ? 1 : 0),\n  find: (p: (a: T) => boolean) => (p(value) ? Option(value) : Option(undefined)) as Option<T>,\n  exists: (p: (a: T) => boolean) => p(value),\n  forEach: (f: (a: T) => void) => f(value),\n  // Implement Doable interface for Do-notation\n  doUnwrap(): DoResult<T> {\n    return { ok: true, value }\n  },\n})\n\nconst Failure = <T>(error: Error): Try<T> => ({\n  _tag: \"Failure\",\n  error,\n  isSuccess(): this is Try<T> & { readonly _tag: \"Success\"; error: undefined } {\n    return false\n  },\n  isFailure(): this is Try<T> & { readonly _tag: \"Failure\"; error: Error } {\n    return true\n  },\n  orElse: (defaultValue: T) => defaultValue,\n  orThrow: (e?: Error) => {\n    throw e ?? error\n  },\n  or: (alternative: Try<T>) => alternative,\n  orNull: () => null,\n  orUndefined: () => undefined,\n  toEither: <E extends Type>(_leftValue: E) => Left<E, T>(error as E),\n  map: <U>(_f: (value: T) => U) => Failure<U>(error),\n  ap: <U>(_ff: Try<(value: T) => U>) => Failure<U>(error),\n  flatMap: <U>(_f: (value: T) => Try<U>) => Failure<U>(error),\n  flatMapAsync: <U>(_f: (value: T) => Promise<Try<U>>): Promise<Try<U>> => Promise.resolve(Failure<U>(error)),\n  fold: <U extends Type>(onFailure: (error: Error) => U, _onSuccess: (value: T) => U): U => onFailure(error),\n  match: <R>(patterns: { Success: (value: T) => R; Failure: (error: Error) => R }): R => patterns.Failure(error),\n  foldLeft:\n    <B>(z: B) =>\n    (_op: (b: B, a: T) => B) =>\n      z, // No transformation on failure\n  foldRight:\n    <B>(z: B) =>\n    (_op: (a: T, b: B) => B) =>\n      z, // No transformation on failure\n  toString: () => `Failure(${stringify(error)}))`,\n  toPromise: (): Promise<T> => Promise.reject(error),\n  toValue: () => ({ _tag: \"Failure\", value: error }),\n  toOption: () => None<T>(),\n  toList: () => List<T>([]),\n  toTry: () => Failure<T>(error),\n  pipe: <U>(_f: (value: T) => U) => {\n    throw error\n  },\n  serialize: () => createCustomSerializer({ _tag: \"Failure\", error: error.message, stack: error.stack }),\n  get size() {\n    return 0\n  },\n  get isEmpty() {\n    return true\n  },\n  contains: (_v: T) => false,\n  reduce: (_f: (b: T, a: T) => T) => {\n    throw new Error(\"Cannot reduce a Failure\")\n  },\n  reduceRight: (_f: (b: T, a: T) => T) => {\n    throw new Error(\"Cannot reduceRight a Failure\")\n  },\n  count: (_p: (x: T) => boolean) => 0,\n  find: (_p: (a: T) => boolean) => Option<T>(null),\n  exists: (_p: (a: T) => boolean) => false,\n  forEach: (_f: (a: T) => void) => {},\n  // Implement Doable interface for Do-notation\n  doUnwrap(): DoResult<never> {\n    return { ok: false, empty: false, error }\n  },\n})\n\nconst TryConstructor = <T>(f: () => T): Try<T> => {\n  try {\n    return Success(f())\n  } catch (error) {\n    return Failure(error instanceof Error ? error : new Error(String(error)))\n  }\n}\n\nconst TryCompanion = {\n  /**\n   * Type guard to check if a Try is Success\n   * @param tryValue - The Try to check\n   * @returns True if Try is Success\n   */\n  isSuccess: <T>(tryValue: Try<T>): tryValue is Try<T> & { readonly _tag: \"Success\"; error: undefined } =>\n    tryValue.isSuccess(),\n  /**\n   * Type guard to check if a Try is Failure\n   * @param tryValue - The Try to check\n   * @returns True if Try is Failure\n   */\n  isFailure: <T>(tryValue: Try<T>): tryValue is Try<T> & { readonly _tag: \"Failure\"; error: Error } =>\n    tryValue.isFailure(),\n  /**\n   * Creates a Try from JSON string\n   * @param json - The JSON string\n   * @returns Try instance\n   */\n  fromJSON: <T>(json: string): Try<T> => {\n    const parsed = JSON.parse(json) as { _tag: string; value?: T; error?: string; stack?: string }\n    if (parsed._tag === \"Success\") {\n      return Success<T>(parsed.value as T)\n    } else {\n      const error = new Error(parsed.error)\n      if (parsed.stack) {\n        error.stack = parsed.stack\n      }\n      return Failure<T>(error)\n    }\n  },\n\n  /**\n   * Creates a Try from YAML string\n   * @param yaml - The YAML string\n   * @returns Try instance\n   */\n  fromYAML: <T>(yaml: string): Try<T> => {\n    const lines = yaml.split(\"\\n\")\n    const tag = lines[0]?.split(\": \")[1]\n\n    if (!tag) {\n      return Failure<T>(new Error(\"Invalid YAML format for Try\"))\n    }\n\n    if (tag === \"Success\") {\n      const valueStr = lines[1]?.split(\": \")[1]\n      if (!valueStr) {\n        return Failure<T>(new Error(\"Invalid YAML format for Try Success\"))\n      }\n      const value = JSON.parse(valueStr) as T\n      return Success<T>(value)\n    } else {\n      const errorMsg = lines[1]?.split(\": \")[1]\n      if (!errorMsg) {\n        return Failure<T>(new Error(\"Invalid YAML format for Try Failure\"))\n      }\n      const stackLine = lines[2]?.split(\": \")\n      const stack = stackLine && stackLine.length > 1 ? stackLine.slice(1).join(\": \") : undefined\n      const error = new Error(errorMsg)\n      if (stack) {\n        error.stack = stack\n      }\n      return Failure<T>(error)\n    }\n  },\n\n  /**\n   * Creates a Try from binary string\n   * @param binary - The binary string\n   * @returns Try instance\n   */\n  fromBinary: <T>(binary: string): Try<T> => {\n    const json = Buffer.from(binary, \"base64\").toString()\n    return TryCompanion.fromJSON<T>(json)\n  },\n}\n\nexport const Try = Companion(TryConstructor, TryCompanion)\n","/**\n * Base interface for objects with a type tag\n * @internal\n */\ninterface TypeableBase<Tag extends string> {\n  readonly _tag: Tag\n}\n\nexport type Typeable<Tag extends string, T = object> = T & TypeableBase<Tag>\n\n/**\n * Parameters for creating a Typeable instance\n * @internal\n */\nexport type TypeableParams<Tag extends string, T> = { _tag: Tag; impl: T }\n\n/**\n * Utility type to extract the Tag from a Typeable type\n * @typeParam T - The Typeable type to extract the tag from\n * @internal\n */\nexport type ExtractTag<T> = T extends Typeable<infer Tag, unknown> ? Tag : never\n\n/**\n * Core utility for creating nominal typing in TypeScript by adding a type tag to any object.\n * This allows for creating distinct types that are structurally identical but considered different by TypeScript's type system.\n *\n * @param params - The parameters containing the tag and implementation\n * @returns A Typeable object with the specified tag\n * @typeParam Tag - The string literal type used as the discriminator\n * @typeParam T - The base type to extend with the tag\n */\nexport function Typeable<Tag extends string, T>({ _tag, impl }: TypeableParams<Tag, T>): Typeable<Tag, T> {\n  return {\n    ...impl,\n    _tag,\n  }\n}\n\n/**\n * Type guard with automatic type inference using the full type\n * @param value - The value to check\n * @param tag - The tag to check for\n * @returns Whether the value is a Typeable with the specified tag\n */\nexport function isTypeable<T>(value: unknown, tag: string): value is T {\n  if (!value || typeof value !== \"object\" || !(\"_tag\" in value)) {\n    return false\n  }\n\n  return tag ? value._tag === tag : true\n}\n\n// // Usage\n// type User = Typeable<\n//   \"User\",\n//   {\n//     id: string\n//     name: string\n//     email: string\n//   }\n// >\n//\n// const user = Typeable(\"User\", {\n//   id: \"123\",\n//   name: \"John\",\n//   email: \"john@example.com\",\n// })\n//\n// const maybeUser: unknown = user\n//\n// // Now we only need to specify User type\n// if (isTypeable<User>(maybeUser, \"User\")) {\n//   console.log(maybeUser.name) // typed\n//   console.log(maybeUser.email) // typed\n//   console.log(maybeUser._tag) // typed as \"User\"\n// }\n//\n// // Can still check just for Typeable without specific tag\n// if (isTypeable<User>(maybeUser)) {\n//   console.log(maybeUser.name) // typed\n//   console.log(maybeUser.email) // typed\n//   console.log(maybeUser._tag) // typed as \"User\"\n// }\n","import stringify from \"safe-stable-stringify\"\n\nimport { Companion } from \"@/companion/Companion\"\nimport { type Doable, type DoResult } from \"@/do/protocol\"\nimport { Left, Right } from \"@/either\"\nimport type { FunctypeCollection } from \"@/functype\"\nimport { None, Option } from \"@/option/Option\"\nimport type { Reshapeable } from \"@/reshapeable\"\nimport { createSerializer } from \"@/serialization\"\nimport { Set } from \"@/set/Set\"\nimport { Try } from \"@/try\"\nimport type { Typeable } from \"@/typeable/Typeable\"\nimport { type ExtractTag, isTypeable } from \"@/typeable/Typeable\"\nimport type { Type } from \"@/types\"\n\nexport interface List<A> extends FunctypeCollection<A, \"List\">, Doable<A>, Reshapeable<A> {\n  readonly length: number\n  readonly [Symbol.iterator]: () => Iterator<A>\n  // Override these to return List instead of FunctypeCollection\n  map: <B>(f: (a: A) => B) => List<B>\n  ap: <B>(ff: List<(value: A) => B>) => List<B>\n  flatMap: <B>(f: (a: A) => Iterable<B>) => List<B>\n  flatMapAsync: <B>(f: (a: A) => PromiseLike<Iterable<B>>) => PromiseLike<List<B>>\n  // Override filter for type guard support\n  filter<S extends A>(predicate: (a: A) => a is S): List<S>\n  filter(predicate: (a: A) => unknown): List<A>\n  filterNot: (p: (a: A) => boolean) => List<A>\n  // List-specific methods\n  /** @internal */\n  filterType: <T extends Typeable<string, unknown>>(tag: string) => List<T & A>\n  remove: (value: A) => List<A>\n  removeAt: (index: number) => List<A>\n  add: (item: A) => List<A>\n  get: (index: number) => Option<A>\n  concat: (other: List<A>) => List<A>\n  /**\n   * Pattern matches over the List, applying a handler function based on whether it's empty\n   * @param patterns - Object with handler functions for Empty and NonEmpty variants\n   * @returns The result of applying the matching handler function\n   */\n  match<R>(patterns: { Empty: () => R; NonEmpty: (values: A[]) => R }): R\n}\n\nconst ListObject = <A>(values?: Iterable<A>): List<A> => {\n  const array: A[] = Array.from(values ?? [])\n\n  const list: List<A> = {\n    _tag: \"List\" as const,\n\n    [Symbol.iterator]: () => array[Symbol.iterator](),\n\n    get size() {\n      return array.length\n    },\n\n    get length() {\n      return array.length\n    },\n\n    map: <B>(f: (a: A) => B) => ListObject(array.map(f)),\n\n    ap: <B>(ff: List<(value: A) => B>) => ListObject(array.flatMap((a) => Array.from(ff).map((f) => f(a)))),\n\n    flatMap: <B>(f: (a: A) => Iterable<B>) => ListObject(array.flatMap((a) => Array.from(f(a)))),\n\n    flatMapAsync: async <B>(f: (a: A) => PromiseLike<Iterable<B>>): Promise<List<B>> => {\n      const results = await Promise.all(array.map(async (a) => await f(a)))\n      return ListObject(results.flatMap((iterable) => Array.from(iterable)))\n    },\n\n    forEach: (f: (a: A) => void) => array.forEach(f),\n\n    contains: (value: A): boolean => array.includes(value),\n\n    count: (p: (x: A) => boolean) => array.filter(p).length,\n\n    exists: (p: (a: A) => boolean) => array.some(p),\n\n    filter: (predicate: (a: A) => unknown) => ListObject(array.filter(predicate as (a: A) => boolean)),\n\n    filterNot: (p: (a: A) => boolean) => ListObject(array.filter((x) => !p(x))),\n\n    filterType: <T extends Typeable<string, unknown>>(tag: string) =>\n      ListObject(array.filter((x): x is T & A => isTypeable(x, tag))),\n\n    find: <T extends A = A>(predicate: (a: A) => boolean, tag?: ExtractTag<T>) => {\n      const result = array.find((x) => predicate(x) && (tag ? isTypeable(x, tag) : true))\n      return Option<T>(result as T | null | undefined)\n    },\n\n    get head() {\n      return array[0] as A | undefined\n    },\n\n    get headOption() {\n      return array.length > 0 ? Option(array[0]) : None<A>()\n    },\n\n    get isEmpty() {\n      return array.length === 0\n    },\n\n    toArray: <B = A>(): B[] => [...array] as unknown as B[],\n\n    reduce: (f: (prev: A, curr: A) => A) => array.reduce(f),\n\n    reduceRight: (f: (prev: A, curr: A) => A) => array.reduceRight(f),\n\n    fold: <B extends Type>(onEmpty: () => B, onValue: (value: A) => B): B => {\n      if (array.length === 0) {\n        return onEmpty()\n      }\n      const firstElement = array[0] as A // Type assertion to avoid undefined\n      return onValue(firstElement)\n    },\n\n    foldLeft:\n      <B>(z: B) =>\n      (op: (b: B, a: A) => B) =>\n        array.reduce(op, z),\n\n    foldRight:\n      <B>(z: B) =>\n      (op: (a: A, b: B) => B) =>\n        array.reduceRight((acc, value) => op(value, acc), z),\n\n    match: <R>(patterns: { Empty: () => R; NonEmpty: (values: A[]) => R }): R => {\n      return array.length === 0 ? patterns.Empty() : patterns.NonEmpty([...array])\n    },\n\n    remove: (value: A) => ListObject(array.filter((x) => x !== value)),\n\n    removeAt: (index: number) =>\n      index < 0 || index >= array.length ? list : ListObject([...array.slice(0, index), ...array.slice(index + 1)]),\n\n    add: (item: A) => ListObject([...array, item]),\n\n    get: (index: number) => Option(array[index]),\n\n    concat: (other: List<A>) => ListObject([...array, ...other.toArray()]),\n\n    drop: (n: number) => ListObject(array.slice(n)),\n\n    dropRight: (n: number) => ListObject(array.slice(0, -n)),\n\n    dropWhile: (p: (a: A) => boolean) => ListObject(array.slice(array.findIndex((x) => !p(x)))),\n\n    flatten: <B>() => ListObject(array.flatMap((item) => (Array.isArray(item) ? item : ([item] as unknown as B[])))),\n\n    toList: () => list,\n\n    toSet: () => Set(array),\n\n    toOption: () => (array.length > 0 ? Option(array[0]) : None<A>()),\n\n    toEither: <E extends Type>(leftValue: E) => (array.length > 0 ? Right<E, A>(array[0]!) : Left<E, A>(leftValue)),\n\n    toTry: () =>\n      array.length > 0\n        ? Try<A>(() => array[0]!)\n        : Try<A>(() => {\n            throw new Error(\"Empty list\")\n          }),\n\n    toString: () => `List(${stringify(array)})`,\n\n    toValue: () => ({ _tag: \"List\", value: array }),\n\n    pipe: <U>(f: (value: A[]) => U) => f([...array]),\n\n    serialize: () => createSerializer(\"List\", array),\n    // Implement Doable interface for Do-notation\n    doUnwrap(): DoResult<A> {\n      if (array.length === 0) {\n        return { ok: false, empty: true }\n      }\n      return { ok: true, value: array[0]! }\n    },\n  }\n\n  return list\n}\n\nconst ListConstructor = <A>(values?: Iterable<A>): List<A> => ListObject(values)\n\nconst ListCompanion = {\n  /**\n   * Creates a List from JSON string\n   * @param json - The JSON string\n   * @returns List instance\n   */\n  fromJSON: <A>(json: string): List<A> => {\n    const parsed = JSON.parse(json) as { _tag: string; value: A[] }\n    return List<A>(parsed.value)\n  },\n\n  /**\n   * Creates a List from YAML string\n   * @param yaml - The YAML string\n   * @returns List instance\n   */\n  fromYAML: <A>(yaml: string): List<A> => {\n    const lines = yaml.split(\"\\n\")\n    const valueStr = lines[1]?.split(\": \")[1]\n    if (!valueStr) {\n      return List<A>([])\n    }\n    const value = JSON.parse(valueStr) as A[]\n    return List<A>(value)\n  },\n\n  /**\n   * Creates a List from binary string\n   * @param binary - The binary string\n   * @returns List instance\n   */\n  fromBinary: <A>(binary: string): List<A> => {\n    const json = Buffer.from(binary, \"base64\").toString()\n    return ListCompanion.fromJSON<A>(json)\n  },\n}\n\nexport const List = Companion(ListConstructor, ListCompanion)\n","import stringify from \"safe-stable-stringify\"\n\nimport { Companion } from \"@/companion/Companion\"\nimport { type Doable, type DoResult } from \"@/do/protocol\"\nimport type { Extractable } from \"@/extractable/Extractable\"\nimport type { FunctypeBase } from \"@/functype\"\nimport { List } from \"@/list/List\"\nimport type { Option } from \"@/option/Option\"\nimport { None, Some } from \"@/option/Option\"\nimport type { Reshapeable } from \"@/reshapeable\"\nimport { createSerializer } from \"@/serialization\"\nimport { Try } from \"@/try\"\nimport type { AsyncMonad, Promisable } from \"@/typeclass\"\nimport type { Type } from \"@/types\"\n\n/**\n * Either type module\n * @module Either\n * @category Core\n */\nexport interface Either<L extends Type, R extends Type>\n  extends FunctypeBase<R, \"Left\" | \"Right\">, Promisable<R>, Doable<R>, Reshapeable<R>, Extractable<R> {\n  readonly _tag: \"Left\" | \"Right\"\n  value: L | R\n  isLeft(): this is Either<L, R> & { readonly _tag: \"Left\"; value: L }\n  isRight(): this is Either<L, R> & { readonly _tag: \"Right\"; value: R }\n  orElse: (defaultValue: R) => R\n  orThrow: (error?: Error) => R\n  or(alternative: Either<L, R>): Either<L, R>\n  orNull: () => R | null\n  orUndefined: () => R | undefined\n  readonly map: <U extends Type>(f: (value: R) => U) => Either<L, U>\n  ap: <U extends Type>(ff: Either<L, (value: R) => U>) => Either<L, U>\n  merge: <L1 extends Type, R1 extends Type>(other: Either<L1, R1>) => Either<L | L1, [R, R1]>\n  mapAsync: <U extends Type>(f: (value: R) => Promise<U>) => Promise<Either<L, U>>\n  flatMap: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U>\n  flatMapAsync: <U extends Type>(f: (value: R) => Promise<Either<L, U>>) => Promise<Either<L, U>>\n  toOption: () => Option<R>\n  toList: () => List<R>\n  toString: () => string\n  [Symbol.iterator]: () => Iterator<R>\n  yield: () => Generator<R, void, unknown>\n  traverse: <U extends Type>(f: (value: R) => Either<L, U>) => Either<L, U[]>\n  lazyMap: <U extends Type>(f: (value: R) => U) => Generator<Either<L, U>, void, unknown>\n  tap: (f: (value: R) => void) => Either<L, R>\n  tapLeft: (f: (value: L) => void) => Either<L, R>\n  mapLeft: <L2 extends Type>(f: (value: L) => L2) => Either<L2, R>\n  bimap: <L2 extends Type, R2 extends Type>(fl: (value: L) => L2, fr: (value: R) => R2) => Either<L2, R2>\n  fold: <T extends Type>(onLeft: (value: L) => T, onRight: (value: R) => T) => T\n  swap: () => Either<R, L>\n  /**\n   * Pipes the value through the provided function based on whether this is a Left or Right\n   * @param onLeft - The function to apply if this is a Left\n   * @param onRight - The function to apply if this is a Right\n   * @returns The result of applying the appropriate function\n   */\n  pipeEither<U extends Type>(onLeft: (value: L) => U, onRight: (value: R) => U): U\n\n  /**\n   * Pipes the Either value through the provided function\n   * @param f - The function to apply to the value (Left or Right)\n   * @returns The result of applying the function to the value\n   */\n  pipe<U extends Type>(f: (value: L | R) => U): U\n  /**\n   * Pattern matches over the Either, applying a handler function based on the variant\n   * @param patterns - Object with handler functions for Left and Right variants\n   * @returns The result of applying the matching handler function\n   */\n  match<T>(patterns: { Left: (value: L) => T; Right: (value: R) => T }): T\n  /**\n   * Returns the value and tag for inspection\n   */\n  toValue(): { _tag: \"Left\" | \"Right\"; value: L | R }\n  /**\n   * Custom JSON serialization that excludes getter properties\n   */\n  toJSON(): { _tag: \"Left\" | \"Right\"; value: L | R }\n}\n\nexport type TestEither<L extends Type, R extends Type> = Either<L, R> & AsyncMonad<R>\n\nconst RightConstructor = <L extends Type, R extends Type>(value: R): Either<L, R> => ({\n  _tag: \"Right\",\n  value,\n  isLeft(): this is Either<L, R> & { readonly _tag: \"Left\"; value: L } {\n    return false\n  },\n  isRight(): this is Either<L, R> & { readonly _tag: \"Right\"; value: R } {\n    return true\n  },\n  orElse: (_defaultValue: R) => value,\n  orThrow: () => value,\n  or: (_alternative: Either<L, R>) => Right<L, R>(value),\n  orNull: () => value,\n  orUndefined: () => value,\n  map: <U extends Type>(f: (value: R) => U): Either<L, U> => Right(f(value)),\n  ap: <U extends Type>(ff: Either<L, (value: R) => U>): Either<L, U> =>\n    ff._tag === \"Right\" ? Right((ff.value as (value: R) => U)(value)) : Left(ff.value as L),\n  mapAsync: <U extends Type>(f: (value: R) => Promise<U>): Promise<Either<L, U>> =>\n    f(value)\n      .then((result) => Right<L, U>(result))\n      .catch((error: unknown) => Promise.resolve(Left<L, U>(error as L))) as Promise<Either<L, U>>,\n  merge: <L1 extends Type, R1 extends Type>(other: Either<L1, R1>): Either<L | L1, [R, R1]> =>\n    other.isLeft() ? Left<L | L1, [R, R1]>(other.value as L1) : Right<L | L1, [R, R1]>([value, other.value as R1]),\n  flatMap: <U extends Type>(f: (value: R) => Either<L, U>): Either<L, U> => f(value),\n  flatMapAsync: <U extends Type>(f: (value: R) => Promise<Either<L, U>>): Promise<Either<L, U>> =>\n    f(value).catch((error: unknown) => Left<L, U>(error as L)) as Promise<Either<L, U>>,\n  toOption: () => Some<R>(value),\n  toList: () => List<R>([value]),\n  toEither: <E extends Type>(_leftValue: E) => Right<E, R>(value),\n  toTry: () => Try(() => value),\n  toJSON() {\n    return { _tag: \"Right\", value }\n  },\n  toString: () => {\n    return `Right(${stringify(value)})`\n  },\n  *[Symbol.iterator]() {\n    yield value\n  },\n  *yield() {\n    yield value\n  },\n  traverse: <U extends Type>(f: (value: R) => Either<L, U>): Either<L, U[]> => {\n    const result = f(value)\n    return result.isLeft() ? Left(result.value as L) : Right([result.value as U])\n  },\n  *lazyMap<U extends Type>(f: (value: R) => U) {\n    yield Right<L, U>(f(value))\n  },\n  tap: (f: (value: R) => void) => {\n    f(value)\n    return Right<L, R>(value)\n  },\n  tapLeft: (_f: (value: L) => void) => Right<L, R>(value),\n  mapLeft: <L2 extends Type>(_f: (value: L) => L2) => Right<L2, R>(value),\n  bimap: <L2 extends Type, R2 extends Type>(_fl: (value: L) => L2, fr: (value: R) => R2) => Right<L2, R2>(fr(value)),\n  fold: <T extends Type>(_onLeft: (value: L) => T, onRight: (value: R) => T) => onRight(value),\n  foldLeft:\n    <B>(z: B) =>\n    (op: (b: B, a: R) => B) =>\n      op(z, value),\n  foldRight:\n    <B>(z: B) =>\n    (op: (a: R, b: B) => B) =>\n      op(value, z),\n  match: <T>(patterns: { Left: (value: L) => T; Right: (value: R) => T }): T => patterns.Right(value),\n  swap: () => Left<R, L>(value),\n  toPromise: (): Promise<R> => Promise.resolve(value),\n  toValue: () => ({ _tag: \"Right\", value }),\n  pipeEither: <U extends Type>(_onLeft: (value: L) => U, onRight: (value: R) => U) => onRight(value),\n  pipe: <U extends Type>(f: (value: L | R) => U) => f(value),\n  serialize: () => createSerializer(\"Right\", value),\n  get size() {\n    return 1\n  },\n  get isEmpty() {\n    return false\n  },\n  contains: (v: R) => value === v,\n  reduce: (_f: (b: R, a: R) => R) => value,\n  reduceRight: (_f: (b: R, a: R) => R) => value,\n  count: (p: (x: R) => boolean) => (p(value) ? 1 : 0),\n  find: (p: (a: R) => boolean) => (p(value) ? Some(value) : None<R>()),\n  exists: (p: (a: R) => boolean) => p(value),\n  forEach: (f: (a: R) => void) => f(value),\n  // Implement Doable interface for Do-notation\n  doUnwrap(): DoResult<R> {\n    return { ok: true, value }\n  },\n})\n\nconst LeftConstructor = <L extends Type, R extends Type>(value: L): Either<L, R> => ({\n  _tag: \"Left\",\n  value,\n  isLeft(): this is Either<L, R> & { readonly _tag: \"Left\"; value: L } {\n    return true\n  },\n  isRight(): this is Either<L, R> & { readonly _tag: \"Right\"; value: R } {\n    return false\n  },\n  orElse: (defaultValue: R): R => defaultValue,\n  orThrow: (error?: Error) => {\n    throw error ?? value\n  },\n  or: (alternative: Either<L, R>) => alternative,\n  orNull: () => null,\n  orUndefined: () => undefined,\n  map: <U extends Type>(_f: (value: R) => U): Either<L, U> => Left<L, U>(value),\n  ap: <U extends Type>(_ff: Either<L, (value: R) => U>): Either<L, U> => Left<L, U>(value),\n  mapAsync: <U extends Type>(_f: (value: R) => Promise<U>): Promise<Either<L, U>> =>\n    Promise.resolve(Left<L, U>(value)) as Promise<Either<L, U>>,\n  merge: <L1 extends Type, R1 extends Type>(_other: Either<L1, R1>): Either<L | L1, [R, R1]> =>\n    Left<L | L1, [R, R1]>(value),\n  flatMap: <U extends Type>(_f: (value: R) => Either<L, U>): Either<L, U> => Left<L, U>(value),\n  flatMapAsync: <U extends Type>(_f: (value: R) => Promise<Either<L, U>>): Promise<Either<L, U>> =>\n    Promise.resolve(Left<L, U>(value)) as Promise<Either<L, U>>,\n  toOption: () => None<R>(),\n  toList: () => List<R>(),\n  toEither: <E extends Type>(leftValue: E) => Left<E, R>(leftValue),\n  toTry: () =>\n    Try<R>(() => {\n      throw new Error(String(value))\n    }),\n  toJSON() {\n    return { _tag: \"Left\", value }\n  },\n  toString: () => `Left(${stringify(value)})`,\n  *[Symbol.iterator]() {\n    // Left doesn't yield any values\n  },\n  *yield() {\n    // Left doesn't yield any values\n  },\n  traverse: <U extends Type>(_f: (value: R) => Either<L, U>): Either<L, U[]> => Left(value),\n  *lazyMap<U extends Type>(_f: (value: R) => U) {\n    yield Left<L, U>(value)\n  },\n  tap: (_f: (value: R) => void) => Left<L, R>(value),\n  tapLeft: (f: (value: L) => void) => {\n    f(value)\n    return Left<L, R>(value)\n  },\n  mapLeft: <L2 extends Type>(f: (value: L) => L2) => Left<L2, R>(f(value)),\n  bimap: <L2 extends Type, R2 extends Type>(fl: (value: L) => L2, _fr: (value: R) => R2) => Left<L2, R2>(fl(value)),\n  fold: <T extends Type>(onLeft: (value: L) => T, _onRight: (value: R) => T) => onLeft(value),\n  foldLeft:\n    <B>(z: B) =>\n    (_op: (b: B, a: R) => B) =>\n      z,\n  foldRight:\n    <B>(z: B) =>\n    (_op: (a: R, b: B) => B) =>\n      z,\n  match: <T>(patterns: { Left: (value: L) => T; Right: (value: R) => T }): T => patterns.Left(value),\n  swap: () => Right<R, L>(value),\n  toPromise: (): Promise<R> => Promise.reject(value),\n  toValue: () => ({ _tag: \"Left\", value }),\n  pipeEither: <U extends Type>(onLeft: (value: L) => U, _onRight: (value: R) => U) => onLeft(value),\n  pipe: <U extends Type>(f: (value: L | R) => U) => f(value),\n  serialize: () => createSerializer(\"Left\", value),\n  get size() {\n    return 0\n  },\n  get isEmpty() {\n    return true\n  },\n  contains: (_v: R) => false,\n  reduce: (_f: (b: R, a: R) => R) => {\n    throw new Error(\"Cannot reduce a Left\")\n  },\n  reduceRight: (_f: (b: R, a: R) => R) => {\n    throw new Error(\"Cannot reduceRight a Left\")\n  },\n  count: (_p: (x: R) => boolean) => 0,\n  find: (_p: (a: R) => boolean) => None<R>(),\n  exists: (_p: (a: R) => boolean) => false,\n  forEach: (_f: (a: R) => void) => {},\n  // Implement Doable interface for Do-notation\n  doUnwrap(): DoResult<never> {\n    return { ok: false, empty: false, error: value }\n  },\n})\n\nexport const Right = <L extends Type, R extends Type>(value: R): Either<L, R> => RightConstructor(value)\nexport const Left = <L extends Type, R extends Type>(value: L): Either<L, R> => LeftConstructor(value)\n\nexport const isRight = <L extends Type, R extends Type>(either: Either<L, R>): either is Either<L, R> & { value: R } =>\n  either.isRight()\nexport const isLeft = <L extends Type, R extends Type>(either: Either<L, R>): either is Either<L, R> & { value: L } =>\n  either.isLeft()\n\nexport const tryCatch = <L extends Type, R extends Type>(f: () => R, onError: (error: unknown) => L): Either<L, R> => {\n  try {\n    return Right<L, R>(f())\n  } catch (error: unknown) {\n    return Left<L, R>(onError(error))\n  }\n}\n\nexport const TypeCheckRight = <L extends Type, R extends Type>(value: R): TestEither<L, R> => RightConstructor(value)\nconsole.assert(TypeCheckRight)\nexport const TypeCheckLeft = <L extends Type, R extends Type>(value: L): TestEither<L, R> => LeftConstructor(value)\nconsole.assert(TypeCheckLeft)\n\nexport const tryCatchAsync = async <L extends Type, R extends Type>(\n  f: () => Promise<R>,\n  onError: (error: unknown) => L,\n): Promise<Either<L, R>> => {\n  try {\n    const result = await f()\n    return Right<L, R>(result)\n  } catch (error: unknown) {\n    return Left<L, R>(onError(error))\n  }\n}\n\n/**\n * Either constructor that creates Left or Right based on the isRight parameter\n * @param value - The value to wrap\n * @param isRight - If true, creates Right, otherwise creates Left\n * @returns Either instance\n */\nconst EitherConstructor = <L extends Type, R extends Type>(value: R | L, isRight: boolean): Either<L, R> =>\n  isRight ? Right<L, R>(value as R) : Left<L, R>(value as L)\n\nconst EitherCompanion = {\n  /**\n   * Creates a Left instance\n   * @param value - The left value\n   * @returns Left Either\n   */\n  left: <L extends Type, R extends Type>(value: L): Either<L, R> => Left<L, R>(value),\n\n  /**\n   * Creates a Right instance\n   * @param value - The right value\n   * @returns Right Either\n   */\n  right: <L extends Type, R extends Type>(value: R): Either<L, R> => Right<L, R>(value),\n\n  /**\n   * Type guard to check if an Either is Right\n   * @param either - The Either to check\n   * @returns True if Either is Right\n   */\n  isRight: <L extends Type, R extends Type>(either: Either<L, R>): either is Either<L, R> & { value: R } =>\n    either.isRight(),\n\n  /**\n   * Type guard to check if an Either is Left\n   * @param either - The Either to check\n   * @returns True if Either is Left\n   */\n  isLeft: <L extends Type, R extends Type>(either: Either<L, R>): either is Either<L, R> & { value: L } =>\n    either.isLeft(),\n\n  /**\n   * Combines an array of Eithers into a single Either containing an array\n   * @param eithers - Array of Either values\n   * @returns Either with array of values or first Left encountered\n   */\n  sequence: <L extends Type, R extends Type>(eithers: Either<L, R>[]): Either<L, R[]> => {\n    return eithers.reduce<Either<L, R[]>>((acc, either) => {\n      if (acc.isLeft()) return acc\n      if (either.isLeft()) return Left(either.value as L)\n      return acc.map((rights) => [...rights, either.value as R])\n    }, Right<L, R[]>([]))\n  },\n\n  /**\n   * Maps an array through a function that returns Either, then sequences the results\n   * @param arr - Array of values\n   * @param f - Function that returns Either\n   * @returns Either with array of results or first Left encountered\n   */\n  traverse: <L extends Type, R extends Type, U extends Type>(\n    arr: R[],\n    f: (value: R) => Either<L, U>,\n  ): Either<L, U[]> => {\n    return EitherCompanion.sequence(arr.map(f))\n  },\n\n  /**\n   * Creates an Either from a nullable value\n   * @param value - The value that might be null or undefined\n   * @param leftValue - The value to use for Left if value is null/undefined\n   * @returns Right if value is not null/undefined, Left otherwise\n   */\n  fromNullable: <L extends Type, R extends Type>(value: R | null | undefined, leftValue: L): Either<L, R> =>\n    value === null || value === undefined ? Left(leftValue) : Right(value as R),\n\n  /**\n   * Creates an Either based on a predicate\n   * @param value - The value to test\n   * @param predicate - The predicate function\n   * @param leftValue - The value to use for Left if predicate fails\n   * @returns Right if predicate passes, Left otherwise\n   */\n  fromPredicate: <L extends Type, R extends Type>(\n    value: R,\n    predicate: (value: R) => boolean,\n    leftValue: L,\n  ): Either<L, R> => (predicate(value) ? Right(value) : Left(leftValue)),\n\n  /**\n   * Applicative apply - applies a wrapped function to a wrapped value\n   * @param eitherF - Either containing a function\n   * @param eitherV - Either containing a value\n   * @returns Either with function applied to value\n   */\n  ap: <L extends Type, R extends Type, U extends Type>(\n    eitherF: Either<L, (value: R) => U>,\n    eitherV: Either<L, R>,\n  ): Either<L, U> => eitherF.flatMap((f) => eitherV.map(f)),\n\n  /**\n   * Creates an Either from a Promise\n   * @param promise - The Promise to convert\n   * @param onRejected - Function to convert rejection reason to Left value\n   * @returns Promise that resolves to Either\n   */\n  fromPromise: async <L, R>(promise: Promise<R>, onRejected: (reason: unknown) => L): Promise<Either<L, R>> => {\n    try {\n      const result = await promise\n      return Right<L, R>(result)\n    } catch (error) {\n      return Left<L, R>(onRejected(error))\n    }\n  },\n\n  /**\n   * Creates an Either from JSON string\n   * @param json - The JSON string\n   * @returns Either instance\n   */\n  fromJSON: <L extends Type, R extends Type>(json: string): Either<L, R> => {\n    const parsed = JSON.parse(json) as { _tag: string; value: L | R }\n    return parsed._tag === \"Right\" ? Right<L, R>(parsed.value as R) : Left<L, R>(parsed.value as L)\n  },\n\n  /**\n   * Creates an Either from YAML string\n   * @param yaml - The YAML string\n   * @returns Either instance\n   */\n  fromYAML: <L extends Type, R extends Type>(yaml: string): Either<L, R> => {\n    const lines = yaml.split(\"\\n\")\n    const tag = lines[0]?.split(\": \")[1]\n    const valueStr = lines[1]?.split(\": \")[1]\n    if (!tag || !valueStr) {\n      throw new Error(\"Invalid YAML format for Either\")\n    }\n    const value = JSON.parse(valueStr) as L | R\n    return tag === \"Right\" ? Right<L, R>(value as R) : Left<L, R>(value as L)\n  },\n\n  /**\n   * Creates an Either from binary string\n   * @param binary - The binary string\n   * @returns Either instance\n   */\n  fromBinary: <L extends Type, R extends Type>(binary: string): Either<L, R> => {\n    const json = Buffer.from(binary, \"base64\").toString()\n    return EitherCompanion.fromJSON<L, R>(json)\n  },\n}\n\nexport const Either = Companion(EitherConstructor, EitherCompanion)\n","import type { Either } from \"@/either\"\nimport { Left, Right } from \"@/either\"\nimport { Option } from \"@/option\"\n\nimport { Brand } from \"./Brand\"\n\n// ValidatedBrand type that extends Brand with a compile-time validation marker\nexport type ValidatedBrand<K extends string, T> = Brand<K, T> & {\n  readonly __validated: true\n}\n\n// Companion interface for ValidatedBrand factory\nexport interface ValidatedBrandCompanion<K extends string, T> {\n  readonly brand: K\n  readonly validate: (value: T) => boolean\n  readonly of: (value: T) => Option<ValidatedBrand<K, T>>\n  readonly from: (value: T) => Either<string, ValidatedBrand<K, T>>\n  readonly unsafeOf: (value: T) => ValidatedBrand<K, T>\n  readonly is: (value: unknown) => value is ValidatedBrand<K, T>\n  readonly unwrap: (branded: Brand<K, T>) => T\n  readonly refine: <K2 extends string>(\n    brand: K2,\n    validate: (value: Brand<K, T>) => boolean,\n  ) => ValidatedBrandCompanion<K2, Brand<K, T>>\n}\n\n/**\n * Create a validated brand with runtime validation\n * @example\n * const Email = ValidatedBrand(\"Email\", (s: string) => /^[^@]+@[^@]+\\.[^@]+$/.test(s))\n * const email = Email.of(\"user@example.com\") // Some(Brand<\"Email\", string>)\n *\n * @example\n * // With Either for error messages\n * const Port = ValidatedBrand(\"Port\", (n: number) => n >= 1 && n <= 65535)\n * const result = Port.from(8080) // Right(Brand<\"Port\", number>)\n * const error = Port.from(70000) // Left(\"Invalid Port: validation failed\")\n *\n * @example\n * // Type guard usage\n * const value: unknown = \"test@example.com\"\n * if (Email.is(value)) {\n *   // value is Brand<\"Email\", string>\n * }\n *\n * @example\n * // Best Practice: Use same brand name for seamless conversion\n * // ValidatedBrand extends Brand, so when using the same brand name,\n * // no casting is needed for conversion\n * const ValidatedUserId = ValidatedBrand(\"UserId\", (s: string) => s.length > 0)\n * type ValidatedUserId = ReturnType<typeof ValidatedUserId.of> extends Option<infer T> ? T : never\n * type UserId = Brand<\"UserId\", string>\n *\n * const toSimpleUserId = (id: ValidatedUserId): UserId => id // No cast needed!\n *\n * // Avoid different brand names which require casting:\n * // ❌ ValidatedBrand(\"ValidatedUserId\", ...) + Brand<\"UserId\", string>\n * // ✅ ValidatedBrand(\"UserId\", ...) + Brand<\"UserId\", string>\n */\nexport function ValidatedBrand<K extends string, T>(\n  brand: K,\n  validate: (value: T) => boolean,\n): ValidatedBrandCompanion<K, T> {\n  return {\n    brand,\n    validate,\n\n    of: (value: T): Option<ValidatedBrand<K, T>> =>\n      validate(value) ? Option(Brand(brand, value) as ValidatedBrand<K, T>) : Option.none(),\n\n    from: (value: T): Either<string, ValidatedBrand<K, T>> =>\n      validate(value)\n        ? Right(Brand(brand, value) as ValidatedBrand<K, T>)\n        : Left(`Invalid ${brand}: validation failed`),\n\n    unsafeOf: (value: T): ValidatedBrand<K, T> => {\n      if (!validate(value)) {\n        throw new Error(`Invalid ${brand}: validation failed`)\n      }\n      return Brand(brand, value) as ValidatedBrand<K, T>\n    },\n\n    is: (value: unknown): value is ValidatedBrand<K, T> => {\n      try {\n        return validate(value as T)\n      } catch {\n        return false\n      }\n    },\n\n    unwrap: (branded: Brand<K, T>): T => branded as unknown as T,\n\n    refine: <K2 extends string>(\n      newBrand: K2,\n      refineValidate: (value: Brand<K, T>) => boolean,\n    ): ValidatedBrandCompanion<K2, Brand<K, T>> =>\n      ValidatedBrand(newBrand, (value: Brand<K, T>) => validate(value as unknown as T) && refineValidate(value)),\n  }\n}\n\n/**\n * Positive number brand (> 0)\n * @example\n * const price = PositiveNumber.of(19.99) // Some(Brand<\"PositiveNumber\", number>)\n * const invalid = PositiveNumber.of(-5) // None\n * const checked = PositiveNumber.from(0) // Left(\"Invalid PositiveNumber: validation failed\")\n */\nexport const PositiveNumber: ValidatedBrandCompanion<\"PositiveNumber\", number> = ValidatedBrand(\n  \"PositiveNumber\",\n  (n: number) => n > 0,\n)\nexport const NonNegativeNumber: ValidatedBrandCompanion<\"NonNegativeNumber\", number> = ValidatedBrand(\n  \"NonNegativeNumber\",\n  (n: number) => n >= 0,\n)\nexport const IntegerNumber: ValidatedBrandCompanion<\"IntegerNumber\", number> = ValidatedBrand(\n  \"IntegerNumber\",\n  (n: number) => Number.isInteger(n),\n)\nexport const PositiveInteger: ValidatedBrandCompanion<\n  \"PositiveInteger\",\n  Brand<\"PositiveNumber\", number>\n> = PositiveNumber.refine(\"PositiveInteger\", (n) => Number.isInteger(n as number))\n\n/**\n * Non-empty string brand\n * @example\n * const name = NonEmptyString.of(\"John\") // Some(Brand<\"NonEmptyString\", string>)\n * const empty = NonEmptyString.of(\"\") // None\n */\nexport const NonEmptyString: ValidatedBrandCompanion<\"NonEmptyString\", string> = ValidatedBrand(\n  \"NonEmptyString\",\n  (s: string) => s.length > 0,\n)\n/**\n * Email address brand with basic validation\n * @example\n * const email = EmailAddress.of(\"user@example.com\") // Some(Brand<\"EmailAddress\", string>)\n * const invalid = EmailAddress.of(\"not-an-email\") // None\n *\n * @example\n * // Using with forms\n * const processEmail = (input: string) => {\n *   return EmailAddress.from(input)\n *     .map(email => sendWelcomeEmail(email))\n *     .orElse(\"Invalid email address\")\n * }\n */\nexport const EmailAddress: ValidatedBrandCompanion<\"EmailAddress\", string> = ValidatedBrand(\n  \"EmailAddress\",\n  (s: string) => /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(s),\n)\nexport const UrlString: ValidatedBrandCompanion<\"UrlString\", string> = ValidatedBrand(\"UrlString\", (s: string) => {\n  try {\n    new URL(s)\n    return true\n  } catch {\n    return false\n  }\n})\n\n// UUID validation\nexport const UUID: ValidatedBrandCompanion<\"UUID\", string> = ValidatedBrand(\"UUID\", (s: string) =>\n  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(s),\n)\n\n// Date/Time brands\nexport const ISO8601Date: ValidatedBrandCompanion<\"ISO8601Date\", string> = ValidatedBrand(\n  \"ISO8601Date\",\n  (s: string) => !isNaN(Date.parse(s)) && /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}/.test(s),\n)\n\n/**\n * Create a number brand with min/max bounds\n * @example\n * const Percentage = BoundedNumber(\"Percentage\", 0, 100)\n * const valid = Percentage.of(75) // Some(Brand<\"Percentage\", number>)\n * const invalid = Percentage.of(150) // None\n *\n * @example\n * const Port = BoundedNumber(\"Port\", 1, 65535)\n * const httpPort = Port.unsafeOf(80) // Brand<\"Port\", number>\n * // Port.unsafeOf(70000) // throws Error\n */\nexport function BoundedNumber(brand: string, min: number, max: number): ValidatedBrandCompanion<string, number> {\n  return ValidatedBrand(brand, (n: number) => n >= min && n <= max)\n}\n\n/**\n * Create a string brand with length constraints\n * @example\n * const Username = BoundedString(\"Username\", 3, 20)\n * const valid = Username.of(\"johndoe\") // Some(Brand<\"Username\", string>)\n * const tooShort = Username.of(\"jo\") // None\n * const tooLong = Username.of(\"verylongusernamethatexceedslimit\") // None\n */\nexport function BoundedString(\n  brand: string,\n  minLength: number,\n  maxLength: number,\n): ValidatedBrandCompanion<string, string> {\n  return ValidatedBrand(brand, (s: string) => s.length >= minLength && s.length <= maxLength)\n}\n\n/**\n * Create a string brand that matches a regex pattern\n * @example\n * const HexColor = PatternString(\"HexColor\", /^#[0-9a-f]{6}$/i)\n * const red = HexColor.of(\"#ff0000\") // Some(Brand<\"HexColor\", string>)\n * const invalid = HexColor.of(\"red\") // None\n *\n * @example\n * const PhoneNumber = PatternString(\"PhoneNumber\", /^\\+?[1-9]\\d{1,14}$/)\n * const phone = PhoneNumber.from(\"+1234567890\")\n *   .map(p => formatPhoneNumber(p))\n *   .orElse(\"Invalid phone number\")\n */\nexport function PatternString(brand: string, pattern: RegExp): ValidatedBrandCompanion<string, string> {\n  return ValidatedBrand(brand, (s: string) => pattern.test(s))\n}\n","/**\n * Helper types for working with the Companion pattern\n * @module CompanionTypes\n */\n\n/**\n * Extracts the companion methods type from a Companion object\n * @typeParam T - The Companion type\n * @example\n * ```typescript\n * type OptionCompanionMethods = CompanionMethods<typeof Option>\n * // { from: ..., none: ..., fromJSON: ..., etc. }\n * ```\n */\nexport type CompanionMethods<T> = T extends ((...args: never[]) => unknown) & infer C ? C : never\n\n/**\n * Extracts the instance type from a constructor function\n * @typeParam T - The constructor function type\n * @example\n * ```typescript\n * type OptionInstance = InstanceType<typeof Option>\n * // Option<T>\n * ```\n */\nexport type InstanceType<T> = T extends (...args: infer Args) => infer R\n  ? R extends (...args: unknown[]) => unknown\n    ? ReturnType<R>\n    : R\n  : never\n\n/**\n * Type guard to check if a value is a Companion object (has both constructor and companion methods)\n * @param value - The value to check\n * @returns True if value is a Companion object\n */\nexport const isCompanion = (value: unknown): value is ((...args: never[]) => unknown) & Record<string, unknown> =>\n  typeof value === \"function\" && Object.keys(value).length > 0\n","import { Companion } from \"@/companion/Companion\"\nimport type { Type } from \"@/types\"\n\n/**\n * Conditional expression that enforces exhaustive returns without early returns.\n * Similar to Scala's if/else expressions that always return a value.\n *\n * @example\n * const discount = Cond.of<number>()\n *   .when(isPremiumMember, 0.2)\n *   .elseWhen(isRegularMember, 0.1)\n *   .else(0)\n *\n * @example\n * // Chaining multiple conditions\n * const status = Cond.of<string>()\n *   .when(response.status >= 500, \"Server Error\")\n *   .elseWhen(response.status >= 400, \"Client Error\")\n *   .elseWhen(response.status >= 200, \"Success\")\n *   .else(\"Unknown\")\n */\nexport type Cond<T extends Type> = {\n  /**\n   * Add an if condition\n   */\n  when: (condition: boolean, value: T | (() => T)) => Cond<T>\n\n  /**\n   * Add an else-if condition\n   */\n  elseWhen: (condition: boolean, value: T | (() => T)) => Cond<T>\n\n  /**\n   * Terminal else clause - required to get the result\n   */\n  else: (value: T | (() => T)) => T\n\n  /**\n   * Get the result if a condition was met, throws if no condition met\n   */\n  orThrow: () => T\n}\n\ntype CondState<T> = {\n  resolved: boolean\n  value?: T\n}\n\n/** @internal */\ntype LazyCondChain<T> = {\n  when: (condition: () => boolean, value: () => T) => LazyCondChain<T>\n  elseWhen: (condition: () => boolean, value: () => T) => LazyCondChain<T>\n  else: (value: () => T) => T\n}\n\nconst CondObject = <T extends Type>(state: CondState<T>): Cond<T> => {\n  const getValue = (value: T | (() => T)): T => {\n    return typeof value === \"function\" ? (value as () => T)() : value\n  }\n\n  const cond: Cond<T> = {\n    when: (condition: boolean, value: T | (() => T)) => {\n      if (state.resolved) return cond\n      if (condition) {\n        return CondObject({ resolved: true, value: getValue(value) })\n      }\n      return cond\n    },\n\n    elseWhen: (condition: boolean, value: T | (() => T)) => {\n      if (state.resolved) return cond\n      if (condition) {\n        return CondObject({ resolved: true, value: getValue(value) })\n      }\n      return cond\n    },\n\n    else: (value: T | (() => T)) => {\n      if (state.resolved) return state.value as T\n      return getValue(value)\n    },\n\n    orThrow: () => {\n      if (!state.resolved) {\n        throw new Error(\"Conditional expression has no matching condition\")\n      }\n      return state.value as T\n    },\n  }\n\n  return cond\n}\n\n/**\n * Create a new conditional expression\n * @example\n * const message = Cond<string>()\n *   .when(isError, \"Error occurred\")\n *   .when(isWarning, \"Warning\")\n *   .else(\"All good\")\n */\nconst CondConstructor = <T extends Type>(): Cond<T> => {\n  return CondObject({ resolved: false })\n}\n\nconst CondCompanion = {\n  /**\n   * Create a conditional expression that must end with else\n   * @example\n   * const x = 7\n   * const result = Cond.of<string>()\n   *   .when(x > 10, \"large\")\n   *   .elseWhen(x > 5, \"medium\")\n   *   .else(\"small\")\n   * // result = \"medium\"\n   *\n   * @example\n   * // With lazy evaluation\n   * const discount = Cond.of<number>()\n   *   .when(isPremium, () => calculatePremiumDiscount())\n   *   .when(isLoyal, () => calculateLoyaltyDiscount())\n   *   .else(0)\n   */\n  of: <T extends Type>(): Cond<T> => CondConstructor<T>(),\n\n  /**\n   * Pattern matching helper that ensures exhaustiveness\n   * @example\n   * type Status = \"pending\" | \"success\" | \"error\"\n   * const status: Status = \"success\"\n   * const result = Cond.match(status)({\n   *   \"pending\": \"Waiting...\",\n   *   \"success\": \"Done!\",\n   *   \"error\": \"Failed!\"\n   * })\n   * // result = \"Done!\"\n   *\n   * @example\n   * // With function values\n   * const action = \"compute\"\n   * const result = Cond.match(action)({\n   *   \"compute\": () => expensiveComputation(),\n   *   \"cache\": () => getCachedValue(),\n   *   \"skip\": () => defaultValue\n   * })\n   */\n  match: <T extends string | number | symbol>(value: T) => {\n    return <R extends Type>(cases: Record<T, R | (() => R)>): R => {\n      const result = cases[value]\n      if (result === undefined) {\n        throw new Error(`No case defined for value: ${String(value)}`)\n      }\n      return typeof result === \"function\" ? (result as () => R)() : (result as R)\n    }\n  },\n\n  /**\n   * Create a lazy conditional that defers evaluation\n   * @example\n   * // Only evaluates conditions and values when needed\n   * const getMessage = Cond.lazy<string>()\n   *   .when(() => isError(), () => computeErrorMessage())\n   *   .when(() => isWarning(), () => computeWarningMessage())\n   *   .else(() => \"Success\")\n   *\n   * @example\n   * // Complex conditional with expensive checks\n   * const result = Cond.lazy<Action>()\n   *   .when(\n   *     () => user.role === \"admin\" && checkAdminPermissions(),\n   *     () => ({ type: \"admin\", permissions: loadAdminPermissions() })\n   *   )\n   *   .when(\n   *     () => user.role === \"user\" && user.isActive,\n   *     () => ({ type: \"user\", permissions: loadUserPermissions() })\n   *   )\n   *   .else(() => ({ type: \"guest\", permissions: [] }))\n   */\n  lazy: <T extends Type>(): LazyCondChain<T> => {\n    // Note: We use mutable state here for performance reasons.\n    // The state is encapsulated and not exposed externally.\n    const state: CondState<T> = { resolved: false }\n\n    const lazyChain: LazyCondChain<T> = {\n      when: (condition: () => boolean, value: () => T) => {\n        if (state.resolved) return lazyChain\n        if (condition()) {\n          // eslint-disable-next-line functional/immutable-data\n          state.resolved = true\n          // eslint-disable-next-line functional/immutable-data\n          state.value = value()\n        }\n        return lazyChain\n      },\n      elseWhen: (condition: () => boolean, value: () => T) => {\n        if (state.resolved) return lazyChain\n        if (condition()) {\n          // eslint-disable-next-line functional/immutable-data\n          state.resolved = true\n          // eslint-disable-next-line functional/immutable-data\n          state.value = value()\n        }\n        return lazyChain\n      },\n      else: (value: () => T): T => {\n        if (state.resolved) return state.value as T\n        return value()\n      },\n    }\n\n    return lazyChain\n  },\n}\n\n/**\n * Conditional expression builder for functional if/else chains\n * @example\n * // Basic usage\n * const size = Cond.of<string>()\n *   .when(value > 100, \"large\")\n *   .elseWhen(value > 50, \"medium\")\n *   .else(\"small\")\n *\n * @example\n * // Pattern matching\n * const message = Cond.match(errorCode)({\n *   404: \"Not Found\",\n *   500: \"Server Error\",\n *   200: \"OK\"\n * })\n *\n * @example\n * // Lazy evaluation\n * const result = Cond.lazy<string>()\n *   .when(() => checkCondition1(), () => \"Result 1\")\n *   .when(() => checkCondition2(), () => \"Result 2\")\n *   .else(() => \"Default\")\n */\nexport const Cond = Companion(CondConstructor, CondCompanion)\n","import { Companion } from \"@/companion/Companion\"\nimport { Option } from \"@/option/Option\"\nimport type { Type } from \"@/types\"\n\n/**\n * Type-level utilities for exhaustiveness checking\n * @internal\n */\ntype UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never\n\n/** @internal */\ntype IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true\n\n/** @internal */\ntype RequireExhaustive<T, Cases> =\n  IsUnion<T> extends true ? (keyof Cases extends T ? (T extends keyof Cases ? Cases : never) : never) : Cases\n\n/**\n * Pattern types for nested matching\n * @internal\n */\ntype Pattern<T> = T | { [K in keyof T]?: Pattern<T[K]> } | ((value: T) => boolean) | { _: (value: T) => boolean } // Guard pattern\n\n/**\n * Extract result from pattern\n * @internal\n */\ntype PatternResult<T, R> = R | ((matched: T) => R)\n\n/**\n * Pattern matching construct similar to Scala's match expressions.\n * Supports exhaustive matching, nested patterns, and guards.\n *\n * @example\n * // Basic pattern matching\n * const result = Match(value)\n *   .case(x => x > 100, \"large\")\n *   .case(x => x > 50, \"medium\")\n *   .default(\"small\")\n *\n * @example\n * // Matching exact values\n * const message = Match(status)\n *   .caseValue(\"pending\", \"Please wait...\")\n *   .caseValue(\"success\", \"Completed!\")\n *   .caseValue(\"error\", \"Failed\")\n *   .default(\"Unknown\")\n *\n * @example\n * // Nested pattern matching\n * const user = { name: \"John\", age: 30, role: \"admin\" }\n * const msg = Match(user)\n *   .case({ role: \"admin\", age: n => n >= 18 }, \"Adult admin\")\n *   .case({ role: \"user\" }, u => `User: ${u.name}`)\n *   .default(\"Guest\")\n */\nexport type Match<T extends Type, R extends Type> = {\n  /**\n   * Match against a pattern (value, nested object, or predicate)\n   */\n  case: (pattern: Pattern<T>, result: PatternResult<T, R>) => Match<T, R>\n\n  /**\n   * Add a case that matches a specific value (backward compatibility)\n   */\n  caseValue: (match: T, result: R | (() => R)) => Match<T, R>\n\n  /**\n   * Add a case that matches multiple values (backward compatibility)\n   */\n  caseValues: (matches: T[], result: R | (() => R)) => Match<T, R>\n\n  /**\n   * Match with a guard function (alias for readability)\n   */\n  when: (guard: (value: T) => boolean, result: PatternResult<T, R>) => Match<T, R>\n\n  /**\n   * Match multiple patterns (OR operation)\n   */\n  caseAny: (patterns: Pattern<T>[], result: PatternResult<T, R>) => Match<T, R>\n\n  /**\n   * Default case - makes match non-exhaustive\n   */\n  default: (result: PatternResult<T, R>) => R\n\n  /**\n   * Force exhaustive matching (compile-time check for union types)\n   */\n  exhaustive: () => R\n\n  /**\n   * Get result if matched, throws if no match\n   */\n  orThrow: (errorMessage?: string) => R\n\n  /**\n   * Get result wrapped in Option\n   */\n  toOption: () => Option<R>\n}\n\ntype MatchState<T, R> = {\n  value: T\n  resolved: boolean\n  result?: R\n  patterns: Array<{ pattern: Pattern<T>; result: PatternResult<T, R> }>\n}\n\n/**\n * Check if a value matches a pattern\n */\nconst matchesPattern = <T>(value: T, pattern: Pattern<T>): boolean => {\n  // Direct value match\n  if (pattern === value) return true\n\n  // Function predicate\n  if (typeof pattern === \"function\") {\n    return (pattern as (value: T) => boolean)(value)\n  }\n\n  // Guard pattern\n  if (pattern && typeof pattern === \"object\" && \"_\" in pattern) {\n    return (pattern._ as (value: T) => boolean)(value)\n  }\n\n  // Nested object pattern\n  if (typeof pattern === \"object\" && pattern !== null && typeof value === \"object\" && value !== null) {\n    return Object.entries(pattern).every(([key, subPattern]) => {\n      const subValue = (value as Record<string, unknown>)[key]\n      return matchesPattern(subValue, subPattern as Pattern<unknown>)\n    })\n  }\n\n  return false\n}\n\nconst MatchObject = <T extends Type, R extends Type>(state: MatchState<T, R>): Match<T, R> => {\n  const getResult = (result: PatternResult<T, R>, value: T): R => {\n    return typeof result === \"function\" ? (result as (value: T) => R)(value) : result\n  }\n\n  const tryMatch = (): { matched: boolean; result?: R } => {\n    for (const { pattern, result } of state.patterns) {\n      if (matchesPattern(state.value, pattern)) {\n        return { matched: true, result: getResult(result, state.value) }\n      }\n    }\n    return { matched: false }\n  }\n\n  const match: Match<T, R> = {\n    case: (pattern: Pattern<T>, result: PatternResult<T, R>) => {\n      if (state.resolved) return match\n\n      const newState: MatchState<T, R> = {\n        ...state,\n        patterns: [...state.patterns, { pattern, result }],\n      }\n\n      if (matchesPattern(state.value, pattern)) {\n        return MatchObject({\n          ...newState,\n          resolved: true,\n          result: getResult(result, state.value),\n        })\n      }\n\n      return MatchObject(newState)\n    },\n\n    caseValue: (matchValue: T, result: R | (() => R)) => {\n      if (state.resolved) return match\n      if (state.value === matchValue) {\n        const res = typeof result === \"function\" ? (result as () => R)() : result\n        return MatchObject({\n          ...state,\n          resolved: true,\n          result: res,\n        })\n      }\n      return match\n    },\n\n    caseValues: (matches: T[], result: R | (() => R)) => {\n      if (state.resolved) return match\n      if (matches.includes(state.value)) {\n        const res = typeof result === \"function\" ? (result as () => R)() : result\n        return MatchObject({\n          ...state,\n          resolved: true,\n          result: res,\n        })\n      }\n      return match\n    },\n\n    when: (guard: (value: T) => boolean, result: PatternResult<T, R>) => {\n      return match.case(guard, result)\n    },\n\n    caseAny: (patterns: Pattern<T>[], result: PatternResult<T, R>) => {\n      if (state.resolved) return match\n\n      for (const pattern of patterns) {\n        if (matchesPattern(state.value, pattern)) {\n          return MatchObject({\n            ...state,\n            resolved: true,\n            result: getResult(result, state.value),\n            patterns: [...state.patterns, { pattern, result }],\n          })\n        }\n      }\n\n      return MatchObject({\n        ...state,\n        patterns: [...state.patterns, ...patterns.map((pattern) => ({ pattern, result }))],\n      })\n    },\n\n    default: (result: PatternResult<T, R>) => {\n      if (state.resolved) return state.result as R\n      return getResult(result, state.value)\n    },\n\n    exhaustive: () => {\n      const matchResult = tryMatch()\n      if (!matchResult.matched) {\n        throw new Error(`Non-exhaustive match. No pattern matched value: ${JSON.stringify(state.value)}`)\n      }\n      return matchResult.result as R\n    },\n\n    orThrow: (errorMessage?: string) => {\n      const matchResult = tryMatch()\n      if (!matchResult.matched) {\n        throw new Error(errorMessage ?? `No matching pattern for value: ${JSON.stringify(state.value)}`)\n      }\n      return matchResult.result as R\n    },\n\n    toOption: () => {\n      const matchResult = tryMatch()\n      return matchResult.matched ? Option(matchResult.result) : Option.none()\n    },\n  }\n\n  return match\n}\n\n/**\n * Create a new pattern match expression\n * @example\n * const result = Match(httpStatus)\n *   .case(s => s >= 200 && s < 300, \"Success\")\n *   .case(s => s >= 400 && s < 500, \"Client Error\")\n *   .case(s => s >= 500, \"Server Error\")\n *   .default(\"Unknown\")\n */\nconst MatchConstructor = <T extends Type, R extends Type>(value: T): Match<T, R> => {\n  return MatchObject({ value, resolved: false, patterns: [] })\n}\n\nconst MatchCompanion = {\n  /**\n   * Create a type-safe exhaustive match for union types\n   * @example\n   * type Status = \"pending\" | \"success\" | \"error\"\n   * const status: Status = \"success\"\n   * const result = Match.exhaustive<Status, string>({\n   *   pending: \"Waiting...\",\n   *   success: \"Done!\",\n   *   error: \"Failed!\"\n   * })(status)\n   * // result = \"Done!\"\n   *\n   * @example\n   * // For function values, wrap in object to prevent execution\n   * type Operation = \"add\" | \"subtract\" | \"multiply\"\n   * const ops = Match.exhaustive<Operation, { fn: (a: number, b: number) => number }>({\n   *   add: { fn: (a, b) => a + b },\n   *   subtract: { fn: (a, b) => a - b },\n   *   multiply: { fn: (a, b) => a * b }\n   * })\n   * const compute = ops(\"multiply\").fn\n   * const result = compute(4, 5) // 20\n   */\n  exhaustive: <T extends string | number | symbol, R extends Type>(cases: RequireExhaustive<T, Record<T, R>>) => {\n    return (value: T): R => {\n      const result = cases[value]\n      if (result === undefined) {\n        throw new Error(`No case defined for value: ${String(value)}`)\n      }\n      return result\n    }\n  },\n\n  /**\n   * Create a partial match that requires a default\n   * @example\n   * const httpCode = 404\n   * const message = Match.partial<number, string>({\n   *   200: \"OK\",\n   *   201: \"Created\",\n   *   404: \"Not Found\",\n   *   500: \"Server Error\"\n   * }).withDefault(\"Unknown Status\")(httpCode)\n   * // message = \"Not Found\"\n   *\n   * @example\n   * // With function default\n   * const getMessage = Match.partial<number, string>({\n   *   0: \"Zero\",\n   *   1: \"One\",\n   *   2: \"Two\"\n   * }).withDefault((n) => `Number: ${n}`)\n   * getMessage(5) // \"Number: 5\"\n   */\n  partial: <T extends string | number | symbol, R extends Type>(cases: Partial<Record<T, R | ((value: T) => R)>>) => ({\n    withDefault: (defaultValue: R | ((value: T) => R)) => {\n      return (value: T): R => {\n        const result = cases[value]\n        if (result !== undefined) {\n          return typeof result === \"function\" ? (result as (value: T) => R)(value) : (result as R)\n        }\n        return typeof defaultValue === \"function\" ? (defaultValue as (value: T) => R)(value) : (defaultValue as R)\n      }\n    },\n  }),\n\n  /**\n   * Pattern match with guards\n   * @example\n   * const score = 85\n   * const grade = Match.withGuards<number, string>([\n   *   [n => n >= 90, \"A\"],\n   *   [n => n >= 80, \"B\"],\n   *   [n => n >= 70, \"C\"],\n   *   [n => n >= 60, \"D\"]\n   * ]).withDefault(\"F\")(score)\n   * // grade = \"B\"\n   *\n   * @example\n   * // With function results for custom messages\n   * const age = 25\n   * const category = Match.withGuards<number, string>([\n   *   [n => n < 13, n => `Child (${n} years)`],\n   *   [n => n < 20, n => `Teenager (${n} years)`],\n   *   [n => n < 60, n => `Adult (${n} years)`],\n   *   [n => n >= 60, n => `Senior (${n} years)`]\n   * ]).withDefault(\"Unknown\")(age)\n   * // category = \"Adult (25 years)\"\n   */\n  withGuards: <T extends Type, R extends Type>(guards: Array<[(value: T) => boolean, R | ((value: T) => R)]>) => ({\n    withDefault: (defaultValue: R | ((value: T) => R)) => {\n      return (value: T): R => {\n        for (const [guard, result] of guards) {\n          if (guard(value)) {\n            return typeof result === \"function\" ? (result as (value: T) => R)(value) : result\n          }\n        }\n        return typeof defaultValue === \"function\" ? (defaultValue as (value: T) => R)(value) : defaultValue\n      }\n    },\n  }),\n\n  /**\n   * Pattern matching for objects with specific structure\n   * @example\n   * type Event =\n   *   | { type: \"click\"; x: number; y: number }\n   *   | { type: \"keypress\"; key: string }\n   *   | { type: \"hover\"; element: string }\n   *\n   * const handler = Match.struct<Event, void>()\n   *   .case({ type: \"click\" }, (e) => console.log(`Click at ${e.x}, ${e.y}`))\n   *   .case({ type: \"keypress\", key: \"Enter\" }, () => console.log(\"Enter pressed\"))\n   *   .case({ type: \"hover\" }, (e) => console.log(`Hovering over ${e.element}`))\n   *   .build()\n   */\n  struct: <T extends Type, R extends Type>() => {\n    const patterns: Array<{ pattern: Pattern<T>; handler: (value: T) => R }> = []\n\n    const builder = {\n      case: (pattern: Pattern<T>, handler: (value: T) => R) => {\n        patterns.push({ pattern, handler })\n        return builder\n      },\n      build:\n        () =>\n        (value: T): R => {\n          for (const { pattern, handler } of patterns) {\n            if (matchesPattern(value, pattern)) {\n              return handler(value)\n            }\n          }\n          throw new Error(`No matching pattern for value: ${JSON.stringify(value)}`)\n        },\n    }\n\n    return builder\n  },\n\n  /**\n   * Create a pattern matcher with guards and nested patterns\n   * @example\n   * type User = {\n   *   name: string\n   *   age: number\n   *   permissions: string[]\n   * }\n   *\n   * const canAccess = Match.builder<User, boolean>()\n   *   .when(u => u.permissions.includes(\"admin\"), true)\n   *   .case({ age: n => n >= 18, permissions: p => p.length > 0 }, true)\n   *   .default(false)\n   *   .build()\n   */\n  builder: <T extends Type, R extends Type>() => {\n    const patterns: Array<{ pattern: Pattern<T>; result: PatternResult<T, R> }> = []\n    let defaultResult: PatternResult<T, R> | undefined\n\n    const builder = {\n      case: (pattern: Pattern<T>, result: PatternResult<T, R>) => {\n        patterns.push({ pattern, result })\n        return builder\n      },\n      when: (guard: (value: T) => boolean, result: PatternResult<T, R>) => {\n        patterns.push({ pattern: guard, result })\n        return builder\n      },\n      default: (result: PatternResult<T, R>) => {\n        defaultResult = result\n        return {\n          build:\n            () =>\n            (value: T): R => {\n              for (const { pattern, result } of patterns) {\n                if (matchesPattern(value, pattern)) {\n                  return typeof result === \"function\" ? (result as (value: T) => R)(value) : result\n                }\n              }\n              if (defaultResult !== undefined) {\n                return typeof defaultResult === \"function\" ? (defaultResult as (value: T) => R)(value) : defaultResult\n              }\n              throw new Error(`No matching pattern for value: ${JSON.stringify(value)}`)\n            },\n        }\n      },\n    }\n\n    return builder\n  },\n}\n\n/**\n * Pattern matching utility for type-safe conditional logic with exhaustiveness checking,\n * nested patterns, and guard support\n *\n * @example\n * // Basic pattern matching\n * const result = Match(value)\n *   .case(x => x > 0, \"positive\")\n *   .case(x => x < 0, \"negative\")\n *   .default(\"zero\")\n *\n * @example\n * // Exhaustive matching for union types\n * type Color = \"red\" | \"green\" | \"blue\"\n * const hex = Match.exhaustive<Color, string>({\n *   red: \"#FF0000\",\n *   green: \"#00FF00\",\n *   blue: \"#0000FF\"\n * })(color)\n *\n * @example\n * // Nested pattern matching\n * type User = { name: string; age: number; role: \"admin\" | \"user\" }\n * const user: User = { name: \"John\", age: 30, role: \"admin\" }\n *\n * const message = Match<User, string>(user)\n *   .case({ role: \"admin\", age: (n) => n >= 18 }, \"Adult admin\")\n *   .case({ role: \"user\" }, u => `User: ${u.name}`)\n *   .default(\"Unknown\")\n *\n * @example\n * // Using exhaustive() method\n * type Status = \"idle\" | \"loading\" | \"success\" | \"error\"\n * const result = Match<Status, string>(\"success\")\n *   .case(\"idle\", \"Waiting...\")\n *   .case(\"loading\", \"Loading...\")\n *   .case(\"success\", \"Done!\")\n *   .case(\"error\", \"Failed!\")\n *   .exhaustive()\n */\nexport const Match = Companion(MatchConstructor, MatchCompanion)\n","import { type DoResult } from \"@/do/protocol\"\nimport { Typeable } from \"@/typeable/Typeable\"\n\n/**\n * Base Object from which most other objects inherit\n * Now includes automatic Do-notation support via doUnwrap method\n * @param type - The type name for the object\n * @param body - The implementation body\n */\nexport function Base<T extends Record<string, unknown>>(type: string, body: T) {\n  return {\n    ...Typeable({ _tag: type, impl: body }),\n    toString() {\n      return `${type}()`\n    },\n    // Implement Doable interface for Do-notation\n    doUnwrap(): DoResult<unknown> {\n      // Check for Option pattern\n      if (\"isSome\" in body && \"isNone\" in body) {\n        if (typeof body.isSome === \"function\" && body.isSome()) {\n          // It's Some - unwrap the value\n          if (\"get\" in body && typeof body.get === \"function\") {\n            return { ok: true, value: body.get() }\n          }\n        }\n        if (typeof body.isNone === \"function\" && body.isNone()) {\n          // It's None - return error\n          return { ok: false, empty: true }\n        }\n      }\n\n      // Check for Either pattern\n      if (\"isLeft\" in body && \"isRight\" in body) {\n        if (typeof body.isRight === \"function\" && body.isRight()) {\n          // It's Right - unwrap the value\n          if (\"value\" in body) {\n            return { ok: true, value: body.value }\n          }\n        }\n        if (typeof body.isLeft === \"function\" && body.isLeft()) {\n          // It's Left - return the left value as error\n          if (\"value\" in body) {\n            return { ok: false, empty: false, error: body.value }\n          }\n        }\n      }\n\n      // Check for Try pattern\n      if (\"isSuccess\" in body && \"isFailure\" in body) {\n        if (typeof body.isSuccess === \"function\" && body.isSuccess()) {\n          // It's Success - unwrap the value\n          if (\"get\" in body && typeof body.get === \"function\") {\n            return { ok: true, value: body.get() }\n          }\n        }\n        if (typeof body.isFailure === \"function\" && body.isFailure()) {\n          // It's Failure - return the error\n          if (\"getError\" in body && typeof body.getError === \"function\") {\n            return { ok: false, empty: false, error: body.getError() }\n          }\n        }\n      }\n\n      // Check for List pattern\n      if (\"isEmpty\" in body && \"head\" in body) {\n        if (typeof body.isEmpty === \"function\" && body.isEmpty()) {\n          // Empty list - return error\n          return { ok: false, empty: true }\n        }\n        if (typeof body.head === \"function\") {\n          // Non-empty list - return first element\n          return { ok: true, value: body.head() }\n        }\n        // If head is a property, not a function\n        if (\"head\" in body) {\n          return { ok: true, value: body.head }\n        }\n      }\n\n      // Default: pass through the value itself\n      // This allows regular values to be yielded in Do-comprehensions\n      return { ok: true, value: body }\n    },\n  }\n}\n","import type { Typeable } from \"@/typeable/Typeable\"\n\n/**\n * The identifier name for Throwable type\n */\nexport const NAME = \"Throwable\" as const\n\n/**\n * @internal\n */\nexport type ThrowableType = Error &\n  Typeable<typeof NAME> & {\n    readonly data?: unknown\n    readonly cause?: Error\n    readonly taskInfo?: { name: string; description: string }\n  }\n\n// eslint-disable-next-line functional/no-classes -- Must extend Error class\nexport class Throwable extends Error implements ThrowableType {\n  public readonly _tag: typeof NAME = NAME\n  public readonly data?: unknown\n  public readonly cause?: Error\n  public readonly taskInfo?: { name: string; description: string }\n\n  protected constructor(\n    message: string,\n    options?: {\n      data?: unknown | undefined\n      cause?: Error | undefined\n      stack?: string | undefined\n      taskInfo?: { name: string; description: string } | undefined\n    },\n  ) {\n    super(message, { cause: options?.cause })\n\n    // Set name before we capture stack trace\n    this.name = options?.taskInfo?.name ?? NAME\n\n    // Set immutable properties\n    Object.defineProperties(this, {\n      _tag: {\n        value: NAME,\n        writable: false,\n        configurable: false,\n      },\n      data: {\n        value: options?.data,\n        writable: false,\n        configurable: false,\n      },\n      taskInfo: {\n        value: options?.taskInfo,\n        writable: false,\n        configurable: false,\n      },\n      name: {\n        value: options?.taskInfo?.name ?? NAME,\n        writable: false,\n        configurable: false,\n      },\n    })\n\n    // Handle cause separately since it comes from Error\n    if (options?.cause) {\n      Object.defineProperty(this, \"cause\", {\n        value: options.cause,\n        writable: false,\n        configurable: false,\n      })\n    }\n\n    // Handle stack trace\n    if (options?.stack) {\n      // If we have a stack from an original error, use it\n      this.stack = options.stack\n    } else if (Error.captureStackTrace) {\n      // Otherwise capture a new stack trace\n      Error.captureStackTrace(this, this.constructor)\n    }\n  }\n\n  static apply(srcError: unknown, data?: unknown, taskInfo?: { name: string; description: string }): ThrowableType {\n    if (srcError instanceof Error) {\n      // For Error instances, preserve the original stack trace and all properties\n      const throwable = new Throwable(srcError.message, {\n        data,\n        cause: (srcError.cause as Error | undefined) ?? undefined,\n        stack: srcError.stack ?? undefined,\n        taskInfo,\n      })\n\n      // Copy all enumerable properties from the source error\n      for (const key of Object.keys(srcError)) {\n        if (!(key in throwable)) {\n          // Use type assertion with Record instead of any\n          const throwableRecord = throwable as unknown as Record<string, unknown>\n          const srcErrorRecord = srcError as unknown as Record<string, unknown>\n          throwableRecord[key] = srcErrorRecord[key]\n        }\n      }\n\n      return throwable\n    }\n\n    // For non-Error objects (like Supabase error objects), preserve their structure\n    if (srcError && typeof srcError === \"object\") {\n      // Create a properly typed reference to the object\n      const errorObj = srcError as Record<string, unknown>\n\n      // Try to extract a reasonable message\n      const message =\n        typeof errorObj.message === \"string\"\n          ? errorObj.message\n          : typeof errorObj.error === \"string\"\n            ? errorObj.error\n            : `Object error: ${JSON.stringify(\n                errorObj,\n                Object.getOwnPropertyNames(errorObj).filter((key) => errorObj[key] !== undefined),\n              )}`\n\n      const throwable = new Throwable(message, { data: data ?? errorObj, taskInfo })\n\n      // Copy all properties from the source object\n      for (const key of Object.keys(errorObj)) {\n        if (!(key in throwable)) {\n          // Use type assertion with Record instead of any\n          const throwableRecord = throwable as unknown as Record<string, unknown>\n          throwableRecord[key] = errorObj[key]\n        }\n      }\n\n      return throwable\n    }\n\n    // Handle functions\n    if (typeof srcError === \"function\") {\n      const fnName = srcError.name ?? \"anonymous function\"\n      const fnString = srcError.toString().substring(0, 100) + (srcError.toString().length > 100 ? \"...\" : \"\")\n      return new Throwable(`Function error: ${fnName}`, {\n        data: data ?? {\n          functionType: typeof srcError,\n          functionName: fnName,\n          functionString: fnString,\n        },\n        taskInfo,\n      })\n    }\n\n    // Handle primitive types\n    const errorType = typeof srcError\n    const errorValue = srcError === null ? \"null\" : srcError === undefined ? \"undefined\" : String(srcError)\n\n    // Handle specific primitive types more precisely\n    if (errorType === \"number\") {\n      const numValue = srcError as number\n      const message = Number.isNaN(numValue)\n        ? \"Number error: NaN\"\n        : !Number.isFinite(numValue)\n          ? `Number error: ${numValue > 0 ? \"Infinity\" : \"-Infinity\"}`\n          : `Number error: ${numValue}`\n\n      return new Throwable(message, {\n        data: data ?? {\n          errorType,\n          errorValue: numValue,\n          originalError: srcError,\n        },\n        taskInfo,\n      })\n    }\n\n    if (errorType === \"bigint\") {\n      return new Throwable(`BigInt error: ${srcError}n`, {\n        data: data ?? {\n          errorType,\n          errorValue: String(srcError),\n          originalError: srcError,\n        },\n        taskInfo,\n      })\n    }\n\n    if (errorType === \"boolean\") {\n      return new Throwable(`Boolean error: ${srcError}`, {\n        data: data ?? {\n          errorType,\n          errorValue: srcError,\n          originalError: srcError,\n        },\n        taskInfo,\n      })\n    }\n\n    if (errorType === \"symbol\") {\n      const symbolDesc = (srcError as symbol).description ?? \"unnamed symbol\"\n      return new Throwable(`Symbol error: Symbol(${symbolDesc})`, {\n        data: data ?? {\n          errorType,\n          symbolDescription: symbolDesc,\n          originalError: srcError,\n        },\n        taskInfo,\n      })\n    }\n\n    const message =\n      typeof srcError === \"string\"\n        ? srcError\n        : `${errorType.charAt(0).toUpperCase() + errorType.slice(1)} error: ${errorValue}`\n\n    return new Throwable(message, {\n      data: data ?? {\n        errorType,\n        errorValue,\n        originalError: srcError,\n      },\n      taskInfo,\n    })\n  }\n}\n","import { Companion } from \"@/companion/Companion\"\nimport type { Either } from \"@/either/Either\"\nimport { Left, Right } from \"@/either/Either\"\nimport type { Type } from \"@/types\"\n\n/**\n * Error context information that provides additional metadata about errors.\n * This context is passed to error mapping functions to provide more information\n * about the error that occurred.\n *\n * @property originalError - The original error that was thrown\n * @property stack - The stack trace of the error, if available\n * @property timestamp - The timestamp when the error occurred\n */\nexport type ErrorContext = {\n  originalError: unknown\n  stack?: string\n  timestamp: number\n}\n\n/**\n * FPromise is a functional wrapper around JavaScript's Promise with enhanced error handling.\n * It implements the Functor and AsyncFunctor interfaces, providing map and flatMap operations\n * for functional composition.\n *\n * FPromise adds several features not available in standard Promises:\n * - Generic error typing for better type safety\n * - Error recovery mechanisms (recover, recoverWith, recoverWithF)\n * - Error filtering and categorization\n * - Side effect methods (tap, tapError)\n * - Error context preservation\n * - Conversion to/from Either for more functional error handling\n *\n * @template T - The type of the value that the FPromise resolves to\n * @template E - The type of the error that the FPromise may reject with (defaults to unknown)\n */\n/**\n * FPromise type that defines the function signature and methods\n */\nexport type FPromise<T extends Type, E extends Type = unknown> = PromiseLike<T> & {\n  readonly _tag: \"FPromise\"\n\n  // FPromise methods\n  tap: (f: (value: T) => void) => FPromise<T, E>\n  mapError: <E2>(f: (error: E, context: ErrorContext) => E2) => FPromise<T, E2>\n  tapError: (f: (error: E) => void) => FPromise<T, E>\n  recover: (fallback: T) => FPromise<T, never>\n  recoverWith: (f: (error: E) => T) => FPromise<T, never>\n  recoverWithF: <E2>(f: (error: E) => FPromise<T, E2>) => FPromise<T, E2>\n  filterError: <E2 extends E>(\n    predicate: (error: E) => boolean,\n    handler: (error: E) => FPromise<T, E2>,\n  ) => FPromise<T, E>\n  logError: (logger: (error: E, context: ErrorContext) => void) => FPromise<T, E>\n  toPromise: () => Promise<T>\n  toEither: () => Promise<Either<E, T>>\n  fold: <R extends Type>(onError: (error: E) => R, onSuccess: (value: T) => R) => FPromise<R, never>\n\n  // Functor implementation\n  map: <U extends Type>(f: (value: T) => U) => FPromise<U, E>\n\n  // AsyncFunctor implementation\n  flatMap: <U extends Type>(f: (value: T) => FPromise<U, E> | PromiseLike<U>) => FPromise<U, E>\n  flatMapAsync: <U extends Type>(f: (value: T) => PromiseLike<U>) => Promise<U>\n}\n\n/**\n * Creates an FPromise from an executor function.\n *\n * @template T - The type of the value that the FPromise resolves to\n * @template E - The type of the error that the FPromise may reject with\n * @param executor - A function that receives resolve and reject functions\n * @returns An FPromise instance\n *\n * @example\n * const promise = FPromise<number, Error>((resolve, reject) => {\n *   if (Math.random() > 0.5) {\n *     resolve(42);\n *   } else {\n *     reject(new Error(\"Something went wrong\"));\n *   }\n * });\n */\nconst FPromiseImpl = <T extends Type, E = unknown>(\n  executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: E) => void) => void,\n): FPromise<T, E> => {\n  const promise = new Promise<T>((resolve, reject) => {\n    try {\n      executor(resolve, reject as (reason?: E) => void)\n    } catch (error) {\n      reject(error as E)\n    }\n  })\n\n  return {\n    _tag: \"FPromise\",\n\n    /**\n     * Maps the value of this FPromise to a new value using the provided function.\n     * If the mapping function throws an error, the resulting FPromise will be rejected with that error.\n     *\n     * @template U - The type of the mapped value\n     * @param f - The mapping function\n     * @returns A new FPromise with the mapped value\n     *\n     * @example\n     * FPromise.resolve(42)\n     *   .map(x => x * 2)\n     *   .toPromise() // Resolves to 84\n     */\n    map: <U extends Type>(f: (value: T) => U): FPromise<U, E> => {\n      return FPromiseImpl<U, E>((resolve, reject) => {\n        promise\n          .then((value) => {\n            try {\n              resolve(f(value))\n            } catch (error) {\n              reject(error as E)\n            }\n          })\n          .catch(reject)\n      })\n    },\n\n    /**\n     * Chains this FPromise with another FPromise-returning function.\n     * This is equivalent to Promise's then method when the callback returns a Promise.\n     *\n     * @template U - The type of the value that the new FPromise resolves to\n     * @param f - A function that takes the resolved value and returns a new FPromise or PromiseLike\n     * @returns A new FPromise that resolves to the result of the function\n     *\n     * @example\n     * FPromise.resolve(42)\n     *   .flatMap(x => FPromise.resolve(x.toString()))\n     *   .toPromise() // Resolves to \"42\"\n     */\n    flatMap: <U extends Type>(f: (value: T) => FPromise<U, E> | PromiseLike<U>): FPromise<U, E> => {\n      return FPromiseImpl<U, E>((resolve, reject) => {\n        promise\n          .then((value) => {\n            try {\n              const result = f(value)\n              if (\"_tag\" in result && result._tag === \"FPromise\") {\n                // It's an FPromise\n                const fPromiseResult = result as FPromise<U, E>\n                fPromiseResult.then(resolve, reject)\n              } else {\n                // It's a PromiseLike\n                Promise.resolve(result).then(resolve, reject)\n              }\n            } catch (error) {\n              reject(error as E)\n            }\n          })\n          .catch(reject)\n      })\n    },\n\n    /**\n     * Asynchronously maps the value of this FPromise to a Promise.\n     * Unlike flatMap, this method returns a native Promise directly.\n     * This is useful when you need to integrate with code that expects a Promise.\n     *\n     * @template U - The type of the mapped value\n     * @param f - The mapping function that returns a Promise\n     * @returns A native Promise with the mapped value\n     *\n     * @example\n     * const result = await FPromise.resolve(42)\n     *   .flatMapAsync(x => Promise.resolve(x.toString()))\n     * // result is \"42\"\n     */\n    flatMapAsync: async <U extends Type>(f: (value: T) => PromiseLike<U>): Promise<U> => {\n      const value_1 = await promise\n      const result = f(value_1)\n      if (result instanceof Promise) {\n        return result\n      } else {\n        // Convert PromiseLike to Promise\n        return new Promise<U>((resolve, reject) => {\n          result.then(resolve, reject)\n        })\n      }\n    },\n\n    /**\n     * Applies a side effect function to the resolved value without changing it.\n     * This is useful for logging, debugging, or other side effects.\n     * If the side effect function throws an error, the resulting FPromise will be rejected with that error.\n     *\n     * @param f - The side effect function\n     * @returns A new FPromise with the same value\n     *\n     * @example\n     * FPromise.resolve(42)\n     *   .tap(x => console.log(`Value: ${x}`))\n     *   .toPromise() // Logs \"Value: 42\" and resolves to 42\n     */\n    tap: (f: (value: T) => void): FPromise<T, E> => {\n      return FPromiseImpl<T, E>((resolve, reject) => {\n        promise\n          .then((value) => {\n            try {\n              f(value)\n              resolve(value)\n            } catch (error) {\n              reject(error as E)\n            }\n          })\n          .catch(reject)\n      })\n    },\n\n    /**\n     * Transforms the error of this FPromise using the provided function.\n     * This is useful for standardizing errors or adding more context.\n     * The function receives both the error and an ErrorContext object.\n     *\n     * @template E2 - The type of the transformed error\n     * @param f - The error mapping function\n     * @returns A new FPromise with the same value type but transformed error type\n     *\n     * @example\n     * FPromise.reject<number, string>(\"error\")\n     *   .mapError((err, context) => new Error(`Transformed: ${err}`))\n     *   .toPromise() // Rejects with Error(\"Transformed: error\")\n     */\n    mapError: <E2>(f: (error: E, context: ErrorContext) => E2): FPromise<T, E2> => {\n      return FPromiseImpl<T, E2>((resolve, reject) => {\n        promise.then(resolve).catch((error: E) => {\n          try {\n            const context: ErrorContext = {\n              originalError: error,\n              stack: error instanceof Error ? error.stack : undefined,\n              timestamp: Date.now(),\n            }\n            reject(f(error, context))\n          } catch (mappingError) {\n            reject(mappingError as E2)\n          }\n        })\n      })\n    },\n\n    /**\n     * Applies a side effect function to the rejection error without changing it.\n     * This is useful for logging, debugging, or other side effects on the error path.\n     * If the side effect function throws an error, the resulting FPromise will be rejected with that error.\n     *\n     * @param f - The side effect function\n     * @returns A new FPromise with the same error\n     *\n     * @example\n     * FPromise.reject<number, Error>(new Error(\"Something went wrong\"))\n     *   .tapError(err => console.error(`Error occurred: ${err.message}`))\n     *   .toPromise() // Logs \"Error occurred: Something went wrong\" and rejects with the original error\n     */\n    tapError: (f: (error: E) => void): FPromise<T, E> => {\n      return FPromiseImpl<T, E>((resolve, reject) => {\n        promise.then(resolve).catch((error: E) => {\n          try {\n            f(error)\n            reject(error)\n          } catch (sideEffectError) {\n            reject(sideEffectError as E)\n          }\n        })\n      })\n    },\n\n    /**\n     * Recovers from an error by providing a fallback value.\n     * This transforms a rejected FPromise into a resolved one with the fallback value.\n     *\n     * @param fallback - The fallback value to use if this FPromise is rejected\n     * @returns A new FPromise that will never reject\n     *\n     * @example\n     * FPromise.reject<number, Error>(new Error(\"Something went wrong\"))\n     *   .recover(42)\n     *   .toPromise() // Resolves to 42\n     */\n    recover: (fallback: T): FPromise<T, never> => {\n      return FPromiseImpl<T, never>((resolve) => {\n        promise.then(resolve).catch(() => resolve(fallback))\n      })\n    },\n\n    /**\n     * Recovers from an error by transforming the error into a value.\n     * This transforms a rejected FPromise into a resolved one using the provided function.\n     * If the recovery function throws an error, the resulting FPromise will be resolved with null.\n     *\n     * @param f - A function that takes the error and returns a value\n     * @returns A new FPromise that will never reject\n     *\n     * @example\n     * FPromise.reject<number, Error>(new Error(\"Something went wrong\"))\n     *   .recoverWith(err => 42)\n     *   .toPromise() // Resolves to 42\n     */\n    recoverWith: (f: (error: E) => T): FPromise<T, never> => {\n      return FPromiseImpl<T, never>((resolve) => {\n        promise.then(resolve).catch((error: E) => {\n          try {\n            resolve(f(error))\n          } catch (_recoverError) {\n            // If recovery fails, we still need to resolve with something\n            // In this case, we'll use a default value based on the type\n            // This is a design decision - we could also reject with the new error\n            const defaultValue = null as unknown as T // Use null as a fallback\n            resolve(defaultValue)\n          }\n        })\n      })\n    },\n\n    /**\n     * Recovers from an error by transforming the error into another FPromise.\n     * This is similar to recoverWith, but allows for asynchronous recovery.\n     *\n     * @template E2 - The type of the error that the new FPromise may reject with\n     * @param f - A function that takes the error and returns a new FPromise\n     * @returns A new FPromise\n     *\n     * @example\n     * FPromise.reject<number, Error>(new Error(\"Something went wrong\"))\n     *   .recoverWithF(err => FPromise.resolve(42))\n     *   .toPromise() // Resolves to 42\n     */\n    recoverWithF: <E2>(f: (error: E) => FPromise<T, E2>): FPromise<T, E2> => {\n      return FPromiseImpl<T, E2>((resolve, reject) => {\n        promise.then(resolve).catch((error: E) => {\n          try {\n            const recoveryPromise = f(error)\n            recoveryPromise.then(resolve, reject)\n          } catch (_recoverError) {\n            reject(_recoverError as E2)\n          }\n        })\n      })\n    },\n\n    /**\n     * Filters errors based on a predicate and handles matching errors with a handler function.\n     * If the predicate returns true, the error is handled by the handler function.\n     * If the predicate returns false, the error is passed through unchanged.\n     *\n     * @template E2 - The type of the error that the handler may produce\n     * @param predicate - A function that determines whether to handle the error\n     * @param handler - A function that handles the error and returns a new FPromise\n     * @returns A new FPromise\n     *\n     * @example\n     * FPromise.reject<string, Error>(new NetworkError(\"Connection failed\"))\n     *   .filterError(\n     *     err => err instanceof NetworkError,\n     *     err => FPromise.resolve(\"Fallback data\")\n     *   )\n     *   .toPromise() // Resolves to \"Fallback data\"\n     */\n    filterError: <E2 extends E>(\n      predicate: (error: E) => boolean,\n      handler: (error: E) => FPromise<T, E2>,\n    ): FPromise<T, E> => {\n      return FPromiseImpl<T, E>((resolve, reject) => {\n        promise.then(resolve).catch((error: E) => {\n          if (predicate(error)) {\n            try {\n              const handledPromise = handler(error)\n              handledPromise.then(resolve, reject)\n            } catch (handlerError) {\n              reject(handlerError as E)\n            }\n          } else {\n            reject(error)\n          }\n        })\n      })\n    },\n\n    /**\n     * Logs errors without affecting the error flow.\n     * This is useful for logging errors in a chain without handling them.\n     * If the logger function throws an error, it is ignored and the original error is passed through.\n     *\n     * @param logger - A function that logs the error\n     * @returns A new FPromise with the same error\n     *\n     * @example\n     * FPromise.reject<number, Error>(new Error(\"Something went wrong\"))\n     *   .logError((err, context) => console.error(`Error at ${context.timestamp}: ${err.message}`))\n     *   .toPromise() // Logs the error and rejects with the original error\n     */\n    logError: (logger: (error: E, context: ErrorContext) => void): FPromise<T, E> => {\n      return FPromiseImpl<T, E>((resolve, reject) => {\n        promise.then(resolve).catch((error: E) => {\n          try {\n            const context: ErrorContext = {\n              originalError: error,\n              stack: error instanceof Error ? error.stack : undefined,\n              timestamp: Date.now(),\n            }\n            logger(error, context)\n          } catch (_loggerError) {\n            // Ignore errors from logger\n          } finally {\n            reject(error)\n          }\n        })\n      })\n    },\n\n    /**\n     * Makes this FPromise thenable, allowing it to be used with await and Promise.then.\n     * This is part of the PromiseLike interface.\n     *\n     * @template TResult1 - The type of the fulfilled value\n     * @template TResult2 - The type of the rejected value\n     * @param onFulfilled - The callback to execute when the Promise is resolved\n     * @param onRejected - The callback to execute when the Promise is rejected\n     * @returns A Promise with the result of the callback\n     */\n    then: <TResult1 = T, TResult2 = never>(\n      onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,\n      onRejected?: ((reason: E) => TResult2 | PromiseLike<TResult2>) | null,\n    ): PromiseLike<TResult1 | TResult2> => {\n      return promise.then(\n        onFulfilled,\n        onRejected as unknown as ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,\n      )\n    },\n\n    /**\n     * Converts this FPromise to a native Promise.\n     * This is useful when you need to integrate with code that expects a Promise.\n     *\n     * @returns A native Promise that resolves or rejects with the same value or error\n     *\n     * @example\n     * const promise = FPromise.resolve(42).toPromise()\n     * // promise is a native Promise that resolves to 42\n     */\n    toPromise: (): Promise<T> => {\n      return promise\n    },\n\n    /**\n     * Creates a Promise that resolves to an Either regardless of whether this FPromise resolves or rejects.\n     * If this FPromise resolves with a value, the returned Promise resolves with a Right containing that value.\n     * If this FPromise rejects with an error, the returned Promise resolves with a Left containing that error.\n     *\n     * @returns A Promise that resolves to an Either\n     *\n     * @example\n     * const either = await FPromise.reject<number, Error>(new Error(\"Something went wrong\"))\n     *   .toEither()\n     * // either is Left(Error(\"Something went wrong\"))\n     */\n    toEither: async (): Promise<Either<E, T>> => {\n      try {\n        const value = await promise\n        return Right<E, T>(value)\n      } catch (error) {\n        return Left<E, T>(error as E)\n      }\n    },\n\n    /**\n     * Folds the FPromise into a single value by applying one of two functions,\n     * depending on whether the FPromise resolves or rejects.\n     * This allows handling both success and error cases in a single operation.\n     *\n     * @template R - The type of the result\n     * @param onError - The function to apply if the FPromise rejects\n     * @param onSuccess - The function to apply if the FPromise resolves\n     * @returns An FPromise that resolves to the result of applying the appropriate function\n     *\n     * @example\n     * const result = await FPromise.resolve(42)\n     *   .fold(\n     *     error => `Error: ${error}`,\n     *     value => `Success: ${value}`\n     *   )\n     *   .toPromise()\n     * // result is \"Success: 42\"\n     *\n     * const result2 = await FPromise.reject<string, number>(\"Something went wrong\")\n     *   .fold(\n     *     error => `Error: ${error}`,\n     *     value => `Success: ${value}`\n     *   )\n     *   .toPromise()\n     * // result2 is \"Error: Something went wrong\"\n     */\n    fold: <R extends Type>(onError: (error: E) => R, onSuccess: (value: T) => R): FPromise<R, never> => {\n      return FPromiseImpl<R, never>((resolve, reject) => {\n        promise\n          .then((value) => {\n            try {\n              resolve(onSuccess(value))\n            } catch (error) {\n              reject(error as never)\n            }\n          })\n          .catch((error: E) => {\n            try {\n              resolve(onError(error))\n            } catch (error) {\n              reject(error as never)\n            }\n          })\n      })\n    },\n  }\n}\n\n/**\n * Static utility methods for FPromise using the Companion pattern.\n * These methods provide factory functions and utilities for working with FPromises.\n */\nexport const FPromiseCompanion = {\n  /**\n   * Creates an FPromise that resolves to the provided value.\n   *\n   * @template T - The type of the value\n   * @template E - The type of the error (defaults to never since this FPromise won't reject)\n   * @param value - The value to resolve with\n   * @returns An FPromise that resolves to the value\n   *\n   * @example\n   * const promise = FPromise.resolve(42)\n   * // promise resolves to 42\n   */\n  resolve: <T, E = never>(value: T | PromiseLike<T>): FPromise<T, E> => {\n    return FPromiseImpl<T, E>((resolve) => resolve(value))\n  },\n\n  /**\n   * Creates an FPromise that rejects with the provided reason.\n   *\n   * @template T - The type of the value (which will never be produced)\n   * @template E - The type of the error\n   * @param reason - The reason for rejection\n   * @returns An FPromise that rejects with the reason\n   *\n   * @example\n   * const promise = FPromise.reject<number, Error>(new Error(\"Something went wrong\"))\n   * // promise rejects with Error(\"Something went wrong\")\n   */\n  reject: <T, E = unknown>(reason: E): FPromise<T, E> => {\n    return FPromiseImpl<T, E>((_, reject) => reject(reason))\n  },\n\n  /**\n   * Creates an FPromise from a regular Promise.\n   *\n   * @template T - The type of the value\n   * @template E - The type of the error\n   * @param promise - The Promise to convert\n   * @returns An FPromise that resolves or rejects with the same value or error\n   *\n   * @example\n   * const promise = FPromise.from(fetch(\"https://api.example.com/data\"))\n   * // promise is an FPromise that resolves or rejects based on the fetch result\n   */\n  from: <T, E = unknown>(promise: Promise<T>): FPromise<T, E> => {\n    return FPromiseImpl<T, E>((resolve, reject) => {\n      promise.then(resolve).catch(reject)\n    })\n  },\n\n  /**\n   * Creates an FPromise from an Either.\n   * If the Either is a Right, the FPromise resolves with the Right value.\n   * If the Either is a Left, the FPromise rejects with the Left value.\n   *\n   * @template L - The type of the Left value (error)\n   * @template R - The type of the Right value (success)\n   * @param either - The Either to convert\n   * @returns An FPromise that resolves or rejects based on the Either\n   *\n   * @example\n   * const either = Right<Error, number>(42)\n   * const promise = FPromise.fromEither(either)\n   * // promise resolves to 42\n   */\n  fromEither: <L, R>(either: Either<L, R>): FPromise<R, L> => {\n    return either.isRight()\n      ? FPromiseImpl<R, L>((resolve) => resolve(either.value as R))\n      : FPromiseImpl<R, L>((_, reject) => reject(either.value as L))\n  },\n\n  /**\n   * Runs multiple FPromises in parallel and returns an array of results.\n   * Similar to Promise.all, this will reject if any of the promises reject.\n   *\n   * @template T - The type of the values\n   * @template E - The type of the error\n   * @param promises - An array of FPromises, Promises, or values\n   * @returns An FPromise that resolves to an array of results\n   *\n   * @example\n   * const promises = [FPromise.resolve(1), FPromise.resolve(2), 3]\n   * const result = await FPromise.all(promises).toPromise()\n   * // result is [1, 2, 3]\n   */\n  all: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T> | T>): FPromise<T[], E> => {\n    return FPromiseImpl<T[], E>((resolve, reject) => {\n      Promise.all(promises.map((p) => (p instanceof Promise ? p : Promise.resolve(p))))\n        .then(resolve)\n        .catch(reject)\n    })\n  },\n\n  /**\n   * Like Promise.allSettled, returns results of all promises whether they succeed or fail.\n   * This will always resolve, never reject.\n   *\n   * @template T - The type of the values\n   * @template E - The type of the errors\n   * @param promises - An array of FPromises or Promises\n   * @returns An FPromise that resolves to an array of Either results\n   *\n   * @example\n   * const promises = [FPromise.resolve(1), FPromise.reject<number, Error>(new Error(\"Failed\"))]\n   * const result = await FPromise.allSettled(promises).toPromise()\n   * // result is [Right(1), Left(Error(\"Failed\"))]\n   */\n  allSettled: <T, E = unknown>(\n    promises: Array<FPromise<T, E> | PromiseLike<T>>,\n  ): FPromise<Array<Either<E, T>>, never> => {\n    return FPromiseImpl<Array<Either<E, T>>, never>((resolve) => {\n      const results: Array<Either<E, T>> = []\n      let completed = 0\n\n      if (promises.length === 0) {\n        resolve([])\n        return\n      }\n\n      promises.forEach((p, index) => {\n        Promise.resolve(p)\n          .then((value) => {\n            results[index] = Right<E, T>(value)\n            completed++\n            if (completed === promises.length) {\n              resolve(results)\n            }\n          })\n          .catch((error) => {\n            results[index] = Left<E, T>(error as E)\n            completed++\n            if (completed === promises.length) {\n              resolve(results)\n            }\n          })\n      })\n    })\n  },\n\n  /**\n   * Like Promise.race, returns the first promise to settle (either resolve or reject).\n   *\n   * @template T - The type of the values\n   * @template E - The type of the errors\n   * @param promises - An array of FPromises or Promises\n   * @returns An FPromise that resolves or rejects with the result of the first promise to settle\n   *\n   * @example\n   * const slow = FPromise.resolve(1).tap(() => new Promise(r => setTimeout(r, 100)))\n   * const fast = FPromise.resolve(2).tap(() => new Promise(r => setTimeout(r, 50)))\n   * const result = await FPromise.race([slow, fast]).toPromise()\n   * // result is 2\n   */\n  race: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>): FPromise<T, E> => {\n    return FPromiseImpl<T, E>((resolve, reject) => {\n      Promise.race(promises).then(resolve, reject)\n    })\n  },\n\n  /**\n   * Like Promise.any, returns the first promise to fulfill.\n   * This will only reject if all promises reject.\n   *\n   * @template T - The type of the values\n   * @template E - The type of the errors\n   * @param promises - An array of FPromises or Promises\n   * @returns An FPromise that resolves with the first promise to fulfill or rejects if all promises reject\n   *\n   * @example\n   * const promises = [\n   *   FPromise.reject<number, Error>(new Error(\"First failed\")),\n   *   FPromise.resolve(2),\n   *   FPromise.reject<number, Error>(new Error(\"Third failed\"))\n   * ]\n   * const result = await FPromise.any(promises).toPromise()\n   * // result is 2\n   */\n  any: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>): FPromise<T, E> => {\n    return FPromiseImpl<T, E>((resolve, reject) => {\n      if (typeof Promise.any === \"function\") {\n        // Use native Promise.any if available\n        Promise.any(promises).then(resolve, reject)\n      } else {\n        // Fallback implementation\n        let rejectionCount = 0\n        const errors: E[] = []\n\n        if (promises.length === 0) {\n          reject(new AggregateError([], \"All promises were rejected\") as E)\n          return\n        }\n\n        promises.forEach((p, index) => {\n          Promise.resolve(p)\n            .then(resolve)\n            .catch((error) => {\n              errors[index] = error as E\n              rejectionCount++\n              if (rejectionCount === promises.length) {\n                reject(new AggregateError(errors, \"All promises were rejected\") as E)\n              }\n            })\n        })\n      }\n    })\n  },\n\n  /**\n   * Retries an operation with exponential backoff.\n   * This is useful for operations that may fail temporarily, such as network requests.\n   *\n   * @template T - The type of the value\n   * @template E - The type of the error\n   * @param operation - A function that returns an FPromise\n   * @param options - Configuration options for the retry\n   * @param options.maxRetries - Maximum number of retry attempts\n   * @param options.baseDelay - Base delay in milliseconds (default: 100)\n   * @param options.shouldRetry - Function that determines whether to retry based on the error (default: always retry)\n   * @returns An FPromise that resolves when the operation succeeds or rejects after all retries fail\n   *\n   * @example\n   * const operation = () => {\n   *   if (Math.random() > 0.8) {\n   *     return FPromise.resolve(\"Success!\")\n   *   }\n   *   return FPromise.reject<string, Error>(new Error(\"Temporary failure\"))\n   * }\n   *\n   * const result = await FPromise.retryWithBackoff(operation, {\n   *   maxRetries: 3,\n   *   baseDelay: 100,\n   *   shouldRetry: (error) => error.message === \"Temporary failure\"\n   * }).toPromise()\n   */\n  retryWithBackoff: <T, E = unknown>(\n    operation: () => FPromise<T, E>,\n    options: {\n      maxRetries: number\n      baseDelay?: number\n      shouldRetry?: (error: E, attempt: number) => boolean\n    },\n  ): FPromise<T, E> => {\n    const { maxRetries, baseDelay = 100, shouldRetry = () => true } = options\n\n    return FPromiseImpl<T, E>((resolve, reject) => {\n      let attempt = 0\n\n      const tryOperation = () => {\n        operation()\n          .toPromise()\n          .then(resolve)\n          .catch((error: E) => {\n            attempt++\n            if (attempt <= maxRetries && shouldRetry(error, attempt)) {\n              const delay = baseDelay * Math.pow(2, attempt - 1)\n              setTimeout(tryOperation, delay)\n            } else {\n              reject(error)\n            }\n          })\n      }\n\n      tryOperation()\n    })\n  },\n}\n\n/**\n * Creates an FPromise from an executor function.\n *\n * @template T - The type of the value that the FPromise resolves to\n * @template E - The type of the error that the FPromise may reject with\n * @param executor - A function that receives resolve and reject functions\n * @returns An FPromise instance\n */\nexport const FPromise = Companion(FPromiseImpl, FPromiseCompanion)\n","import stringify from \"safe-stable-stringify\"\n\nimport { Companion } from \"@/companion/Companion\"\nimport { Base } from \"@/core\"\nimport { Throwable } from \"@/core/throwable/Throwable\"\nimport type { Doable, DoResult } from \"@/do/protocol\"\nimport type { Either } from \"@/either/Either\"\nimport { Left, Right } from \"@/either/Either\"\nimport type { Extractable } from \"@/extractable/Extractable\"\nimport { FPromise } from \"@/fpromise/FPromise\"\nimport type { FunctypeBase } from \"@/functype\"\nimport { ArrayBuilder } from \"@/internal/mutation-utils\"\nimport { List } from \"@/list/List\"\nimport type { Option } from \"@/option/Option\"\nimport { None, Some } from \"@/option/Option\"\nimport { Ref } from \"@/ref/Ref\"\nimport type { Try } from \"@/try/Try\"\nimport { Try as TryConstructor } from \"@/try/Try\"\nimport type { AsyncMonad, Promisable } from \"@/typeclass\"\n\n/**\n * Type definition for errors with a _tag property that identifies them as Throwables\n */\nexport type TaggedThrowable = Error & {\n  _tag: \"Throwable\"\n  cause?: Error\n  taskInfo?: { name: string; description: string }\n}\n\n/**\n * Type guard to check if an error is a TaggedThrowable\n */\nexport function isTaggedThrowable(error: unknown): error is TaggedThrowable {\n  return (\n    error instanceof Error && typeof error === \"object\" && true && (error as { _tag?: string })._tag === \"Throwable\"\n  )\n}\n\n// Input parameters for tasks (optional)\nexport interface TaskParams {\n  readonly name?: string\n  readonly description?: string\n}\n\n// Resolved metadata for tasks (required)\nexport interface TaskMetadata {\n  readonly name: string\n  readonly description: string\n}\n\n// Standalone TaskOutcome interface - no longer extends Either\nexport interface TaskOutcome<T>\n  extends FunctypeBase<T, \"Ok\" | \"Err\">, Extractable<T>, AsyncMonad<T>, Promisable<T>, Doable<T> {\n  readonly _tag: \"Ok\" | \"Err\"\n  readonly _meta: TaskMetadata\n\n  // Value access\n  readonly value?: T\n  readonly error?: Throwable\n\n  // Functional methods\n  readonly map: <U>(f: (value: T) => U) => TaskOutcome<U>\n  readonly flatMap: <U>(f: (value: T) => TaskOutcome<U> | Either<Throwable, U>) => TaskOutcome<U>\n  readonly ap: <U>(ff: TaskOutcome<(value: T) => U>) => TaskOutcome<U>\n  readonly mapAsync: <U>(f: (value: T) => Promise<U>) => Promise<TaskOutcome<U>>\n  readonly flatMapAsync: <U>(f: (value: T) => Promise<TaskOutcome<U>>) => Promise<TaskOutcome<U>>\n\n  // Error handling methods\n  readonly mapError: (f: (error: Throwable) => Throwable) => TaskOutcome<T>\n  readonly recover: (value: T) => Ok<T>\n  readonly recoverWith: (f: (error: Throwable) => T) => Ok<T>\n\n  // Type guards\n  readonly isSuccess: () => this is Ok<T>\n  readonly isFailure: () => this is Err<T>\n  readonly isOk: () => this is Ok<T>\n  readonly isErr: () => this is Err<T>\n\n  // Conversion methods\n  readonly toEither: () => Either<Throwable, T>\n  readonly toTry: () => Try<T>\n  readonly toOption: () => Option<T>\n  readonly toList: () => List<T>\n\n  // Pattern matching\n  readonly fold: <U>(onErr: (error: Throwable) => U, onOk: (value: T) => U) => U\n  readonly match: <U>(patterns: { Ok: (value: T) => U; Err: (error: Throwable) => U }) => U\n}\n\n// Success case interface - extends TaskOutcome\nexport interface Ok<T> extends TaskOutcome<T> {\n  readonly _tag: \"Ok\"\n  readonly value: T\n  readonly error: undefined\n}\n\n// Failure case interface - extends TaskOutcome\nexport interface Err<T> extends TaskOutcome<T> {\n  readonly _tag: \"Err\"\n  readonly value: undefined\n  readonly error: Throwable\n}\n\n// Legacy type aliases for backwards compatibility\nexport type TaskSuccess<T> = Ok<T>\nexport type TaskFailure<T> = Err<T>\n\n/**\n * Helper function to convert Either to TaskOutcome\n * @param either - The Either to convert\n * @param params - Task parameters to attach\n */\nconst eitherToTaskOutcome = <T>(either: Either<Throwable, T>, params?: TaskParams): TaskOutcome<T> => {\n  if (either.isRight()) {\n    return Ok(either.orThrow(), params)\n  } else if (either.isLeft()) {\n    return Err<T>(\n      either.fold(\n        (left) => left,\n        () => new Error(\"Unexpected right value\"),\n      ),\n      undefined,\n      params,\n    )\n  } else {\n    throw new Error(\"Unrecognized task outcome\")\n  }\n}\n\n/**\n * Err constructor - Creates a failed TaskOutcome\n * @param error - The error object\n * @param data - Additional data related to the error\n * @param params - Task parameters\n */\nexport const Err = <T>(error: unknown, data?: unknown, params?: TaskParams): Err<T> => {\n  const meta: TaskMetadata = {\n    name: params?.name ?? \"Task\",\n    description: params?.description ?? \"\",\n  }\n\n  // Pass metadata to Throwable for error chain tracking\n  const throwable = Throwable.apply(error, data, meta)\n\n  const errResult = {\n    ...Base(\"Err\", { error: throwable, meta }),\n    _tag: \"Err\" as const,\n    _meta: meta,\n    value: undefined,\n    error: throwable,\n\n    // Type guards\n    isSuccess(): this is Ok<T> {\n      return false\n    },\n    isFailure(): this is Err<T> {\n      return true\n    },\n    isOk(): this is Ok<T> {\n      return false\n    },\n    isErr(): this is Err<T> {\n      return true\n    },\n\n    // Functional methods (no-ops for Err)\n    map: <U>(_f: (value: T) => U) => Err<U>(throwable, data, params),\n    flatMap: <U>(_f: (value: T) => TaskOutcome<U> | Either<Throwable, U>) => Err<U>(throwable, data, params),\n    ap: <U>(_ff: TaskOutcome<(value: T) => U>) => Err<U>(throwable, data, params),\n    mapAsync: <U>(_f: (value: T) => Promise<U>) => Promise.resolve(Err<U>(throwable, data, params)),\n    flatMapAsync: <U>(_f: (value: T) => Promise<TaskOutcome<U>>) => Promise.resolve(Err<U>(throwable, data, params)),\n\n    // Error handling methods\n    mapError: (f: (error: Throwable) => Throwable) => Err<T>(f(throwable), data, params),\n    recover: (value: T) => Ok(value, params),\n    recoverWith: (f: (error: Throwable) => T) => Ok(f(throwable), params),\n\n    // Extractable methods\n    orThrow: (error?: Error) => {\n      throw error ?? throwable\n    },\n    orElse: (defaultValue: T) => defaultValue,\n    or: (alternative: TaskOutcome<T>) => alternative,\n    orNull: () => null as T | null,\n    orUndefined: () => undefined as T | undefined,\n\n    // Conversion methods\n    toEither: () => Left<Throwable, T>(throwable),\n    toTry: () =>\n      TryConstructor<T>(() => {\n        throw throwable\n      }),\n    toOption: () => None<T>(),\n    toList: () => List<T>([]),\n\n    // Pattern matching\n    fold: <U>(onErr: (error: Throwable) => U, _onOk: (value: T) => U) => onErr(throwable),\n    match: <U>(patterns: { Ok: (value: T) => U; Err: (error: Throwable) => U }) => patterns.Err(throwable),\n\n    // Foldable methods\n    foldLeft:\n      <B>(z: B) =>\n      (_op: (b: B, a: T) => B) =>\n        z,\n    foldRight:\n      <B>(z: B) =>\n      (_op: (a: T, b: B) => B) =>\n        z,\n\n    // Traversable methods\n    size: 0,\n    isEmpty: true,\n    contains: (_value: T) => false,\n    reduce: (_f: (b: T, a: T) => T) => {\n      throw new Error(\"Cannot reduce empty Err\")\n    },\n    reduceRight: (_f: (b: T, a: T) => T) => {\n      throw new Error(\"Cannot reduceRight empty Err\")\n    },\n    count: (_p: (value: T) => boolean) => 0,\n    find: (_p: (value: T) => boolean) => None<T>(),\n    exists: (_p: (value: T) => boolean) => false,\n    forEach: (_f: (value: T) => void) => {},\n\n    // Promise methods\n    toPromise: () => Promise.reject(throwable),\n\n    // Do-notation support\n    doUnwrap(): DoResult<T> {\n      return { ok: false, empty: false, error: throwable }\n    },\n\n    // Serializable methods\n    serialize: () => ({\n      toJSON: () => stringify({ _tag: \"Err\", error: throwable.message ?? throwable.toString() }) ?? \"{}\",\n      toYAML: () => `_tag: Err\\nerror: ${throwable.message ?? throwable.toString()}`,\n      toBinary: () =>\n        Buffer.from(JSON.stringify({ _tag: \"Err\", error: throwable.message ?? throwable.toString() })).toString(\n          \"base64\",\n        ),\n    }),\n\n    // Pipe method\n    pipe: <U>(f: (value: TaskOutcome<T>) => U) => f(errResult as TaskOutcome<T>),\n  }\n\n  return errResult\n}\n\n/**\n * Ok constructor - Creates a successful TaskOutcome\n * @param data - The successful value\n * @param params - Task parameters\n */\nexport const Ok = <T>(data: T, params?: TaskParams): Ok<T> => {\n  const meta: TaskMetadata = {\n    name: params?.name ?? \"Task\",\n    description: params?.description ?? \"\",\n  }\n\n  const okResult = {\n    ...Base(\"Ok\", { value: data, meta }),\n    _tag: \"Ok\" as const,\n    _meta: meta,\n    value: data,\n    error: undefined,\n\n    // Type guards\n    isSuccess(): this is Ok<T> {\n      return true\n    },\n    isFailure(): this is Err<T> {\n      return false\n    },\n    isOk(): this is Ok<T> {\n      return true\n    },\n    isErr(): this is Err<T> {\n      return false\n    },\n\n    // Functional methods\n    map: <U>(f: (value: T) => U) => Ok<U>(f(data), params),\n    flatMap: <U>(f: (value: T) => TaskOutcome<U> | Either<Throwable, U>) => {\n      const result = f(data)\n      // Check if it's an Either\n      if (result && typeof result === \"object\" && \"isLeft\" in result && \"isRight\" in result) {\n        return eitherToTaskOutcome(result as Either<Throwable, U>, params)\n      }\n      // It's already a TaskOutcome\n      return result as TaskOutcome<U>\n    },\n    ap: <U>(ff: TaskOutcome<(value: T) => U>) =>\n      ff.isOk() ? Ok<U>(ff.value!(data), params) : Err<U>(ff.error!, undefined, params),\n    mapAsync: async <U>(f: (value: T) => Promise<U>) => Ok<U>(await f(data), params),\n    flatMapAsync: async <U>(f: (value: T) => Promise<TaskOutcome<U>>) => await f(data),\n\n    // Error handling methods (no-ops for success)\n    mapError: (_f: (error: Throwable) => Throwable) => Ok(data, params),\n    recover: (_value: T) => Ok(data, params),\n    recoverWith: (_f: (error: Throwable) => T) => Ok(data, params),\n\n    // Extractable methods\n    orThrow: (_error?: Error) => data,\n    orElse: (_defaultValue: T) => data,\n    or: (_alternative: TaskOutcome<T>) => Ok(data, params),\n    orNull: () => data as T | null,\n    orUndefined: () => data as T | undefined,\n\n    // Conversion methods\n    toEither: () => Right<Throwable, T>(data),\n    toTry: () => TryConstructor<T>(() => data),\n    toOption: () => Some(data),\n    toList: () => List<T>([data]),\n\n    // Pattern matching\n    fold: <U>(_onErr: (error: Throwable) => U, onOk: (value: T) => U) => onOk(data),\n    match: <U>(patterns: { Ok: (value: T) => U; Err: (error: Throwable) => U }) => patterns.Ok(data),\n\n    // Foldable methods\n    foldLeft:\n      <B>(z: B) =>\n      (op: (b: B, a: T) => B) =>\n        op(z, data),\n    foldRight:\n      <B>(z: B) =>\n      (op: (a: T, b: B) => B) =>\n        op(data, z),\n\n    // Traversable methods\n    size: 1,\n    isEmpty: false,\n    contains: (value: T) => data === value,\n    reduce: (_f: (b: T, a: T) => T) => data,\n    reduceRight: (_f: (b: T, a: T) => T) => data,\n    count: (p: (value: T) => boolean) => (p(data) ? 1 : 0),\n    find: (p: (value: T) => boolean) => (p(data) ? Some(data) : None<T>()),\n    exists: (p: (value: T) => boolean) => p(data),\n    forEach: (f: (value: T) => void) => f(data),\n\n    // Promise methods\n    toPromise: () => Promise.resolve(data),\n\n    // Do-notation support\n    doUnwrap(): DoResult<T> {\n      return { ok: true, value: data }\n    },\n\n    // Serializable methods\n    serialize: () => ({\n      toJSON: () => stringify({ _tag: \"Ok\", value: data }) ?? \"{}\",\n      toYAML: () => `_tag: Ok\\nvalue: ${stringify(data) ?? \"undefined\"}`,\n      toBinary: () => Buffer.from(JSON.stringify({ _tag: \"Ok\", value: data })).toString(\"base64\"),\n    }),\n\n    // Pipe method\n    pipe: <U>(f: (value: TaskOutcome<T>) => U) => f(okResult as TaskOutcome<T>),\n  }\n\n  return okResult\n}\n\n// Promise wrapper for async operations\nexport type TaskResult<T> = Promise<TaskOutcome<T>>\n\n// Legacy aliases removed - Ok and Err are now the primary constructors\n\n/**\n * The CancellationToken is a control structure that allows long-running tasks to be cancelled\n * Cancellation is cooperative, meaning the task must check the token and respond to cancellation requests\n */\nexport type CancellationToken = {\n  /** Whether the token has been cancelled */\n  readonly isCancelled: boolean\n  /** Signal that can be used with fetch and other abortable APIs */\n  readonly signal: AbortSignal\n  /** Register a callback to be called when cancellation occurs */\n  onCancel(callback: () => void): void\n}\n\n/**\n * Create a cancellation token and controller\n * The controller can be used to cancel operations that use the token\n */\nexport type CancellationTokenSource = {\n  /** The token to be passed to cancellable operations */\n  readonly token: CancellationToken\n  /** Cancel all operations using this token */\n  cancel(): void\n}\n\n/**\n * Create a cancellation token source\n * @returns A CancellationTokenSource that can be used to create and control cancellation tokens\n */\nexport const createCancellationTokenSource = (): CancellationTokenSource => {\n  const controller = new AbortController()\n  const callbacks = ArrayBuilder<() => void>()\n\n  const token: CancellationToken = {\n    get isCancelled() {\n      return controller.signal.aborted\n    },\n    get signal() {\n      return controller.signal\n    },\n    onCancel(callback: () => void) {\n      if (controller.signal.aborted) {\n        // Already cancelled, execute callback immediately\n        callback()\n      } else {\n        callbacks.add(callback)\n      }\n    },\n  }\n\n  return {\n    token,\n    cancel() {\n      if (!controller.signal.aborted) {\n        controller.abort()\n        // Execute all callbacks\n        callbacks.build().forEach((callback) => {\n          try {\n            callback()\n          } catch (e) {\n            // Ignore callback errors\n            console.error(\"Error in cancellation callback:\", e)\n          }\n        })\n      }\n    },\n  }\n}\n\n// Legacy type aliases - can be removed if not needed\nexport type Sync<T> = TaskOutcome<T>\nexport type Async<T> = TaskResult<T>\n\n/**\n * Task adapter for bridging promise-based code with functional error handling patterns\n */\nconst TaskConstructor = <T = unknown>(params?: TaskParams) => {\n  const name = params?.name ?? \"Task\"\n  const description = params?.description ?? \"\"\n  const body = {\n    /**\n     * Run an async operation with explicit try/catch/finally semantics\n     * Returns a raw Promise that can interact with traditional Promise-based code\n     *\n     * @param t - The main operation function that returns a value or Promise\n     * @param e - Optional error handler function\n     * @param f - Optional finally handler function\n     * @param cancellationToken - Optional token for cancellation support\n     */\n    Async: <U = T>(\n      t: () => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>,\n      e: (error: unknown) => unknown | TaskOutcome<U> = (error: unknown) => error,\n      f: () => Promise<void> | void = () => {},\n      cancellationToken?: CancellationToken,\n    ): FPromise<TaskOutcome<U>> => {\n      return FPromise<TaskOutcome<U>>((resolve, _reject) => {\n        // Wrap async logic in IIFE to avoid async executor\n        void (async () => {\n          // Setup cancellation if a token was provided\n          const isCancelled = Ref(false)\n          const cancelError = Ref<Error | null>(null)\n          const cleanupCancellation = Ref<() => void>(() => {})\n\n          if (cancellationToken) {\n            // Check if already cancelled\n            if (cancellationToken.isCancelled) {\n              try {\n                // Always run finally before rejecting\n                await f()\n              } catch (finallyError) {\n                resolve(Err<U>(finallyError, undefined, { name, description }))\n                return\n              }\n\n              resolve(\n                Err<U>(new Error(\"Task was cancelled before execution started\"), undefined, {\n                  name,\n                  description,\n                }),\n              )\n              return\n            }\n\n            // Setup cancellation handler\n            const handleCancellation = () => {\n              isCancelled.set(true)\n              cancelError.set(new Error(\"Task was cancelled during execution\"))\n              // We don't reject immediately to allow the finally block to run\n            }\n\n            cancellationToken.onCancel(handleCancellation)\n            cleanupCancellation.set(() => {\n              // No way to remove the callback, but we can track if cancelled\n            })\n          }\n\n          try {\n            // Run the main operation\n            const result = await t()\n\n            // Always run finally first\n            try {\n              await f()\n            } catch (finallyError) {\n              // Finally errors take precedence\n              resolve(Err<U>(finallyError, undefined, { name, description }))\n              return\n            }\n\n            // Check for cancellation after finally\n            if (isCancelled.get()) {\n              if (cancelError.get()) {\n                resolve(Err<U>(cancelError.get(), undefined, { name, description }))\n              } else {\n                resolve(Err<U>(new Error(\"Task was cancelled during execution\"), undefined, { name, description }))\n              }\n              return\n            }\n\n            // Check if result is already a TaskOutcome\n            if (result && typeof result === \"object\" && \"_tag\" in result) {\n              const outcome = result as TaskOutcome<U>\n              if (outcome._tag === \"Ok\" || outcome._tag === \"Err\") {\n                // Result is already a TaskOutcome, use it directly\n                resolve(outcome)\n              } else {\n                // Not a TaskOutcome, wrap as success\n                resolve(Ok(result as U, { name, description }))\n              }\n            } else {\n              // Raw value, wrap as success\n              resolve(Ok(result as U, { name, description }))\n            }\n          } catch (error) {\n            // Always run finally first, regardless of cancellation\n            try {\n              await f()\n            } catch (finallyError) {\n              // Finally errors take precedence over all other errors\n              resolve(Err<U>(finallyError, undefined, { name, description }))\n              return\n            }\n\n            // Now handle cancellation or regular error\n            if (isCancelled.get()) {\n              // Task was cancelled\n              if (cancelError.get()) {\n                resolve(Err<U>(cancelError.get(), undefined, { name, description }))\n              } else {\n                resolve(Err<U>(new Error(\"Task was cancelled during execution\"), undefined, { name, description }))\n              }\n              return\n            }\n\n            // Process the original error through error handler\n            try {\n              // Check if error is already a Throwable (from an inner task)\n              if (error instanceof Error && isTaggedThrowable(error)) {\n                // Create a new Throwable that wraps the inner error as its cause\n                // This preserves the error chain while adding outer task context\n                const outerError = new Error(`${name}: ${(error as Error).message}`)\n                const enhancedError = Throwable.apply(outerError, undefined, { name, description })\n\n                // Set the original error as the cause\n                Object.defineProperty(enhancedError, \"cause\", {\n                  value: error,\n                  writable: false,\n                  configurable: false,\n                })\n\n                // Call the error handler for logging/side effects but don't use its result\n                // This allows handlers to be called without changing the error propagation logic\n                // Use a non-awaited promise to avoid blocking the error propagation\n                // This improves performance while still ensuring the handler runs\n                void Promise.resolve().then(() => {\n                  try {\n                    e(error)\n                  } catch (handlerError) {\n                    // Ignore errors from the handler when preserving error chain\n                    console.error(\"Error in error handler:\", handlerError)\n                  }\n                })\n\n                // Return the enhanced error as a TaskFailure\n                resolve(Err<U>(enhancedError, undefined, { name, description }))\n              } else {\n                // Regular error handling for non-Throwable errors\n                const errorResult = await e(error)\n\n                // Check if error handler returned a TaskOutcome\n                if (errorResult && typeof errorResult === \"object\" && \"_tag\" in errorResult) {\n                  const outcome = errorResult as TaskOutcome<U>\n                  if (outcome._tag === \"Ok\" || outcome._tag === \"Err\") {\n                    // Error handler returned a TaskOutcome, use it directly\n                    resolve(outcome)\n                  } else {\n                    // Not a TaskOutcome, wrap as failure\n                    resolve(Err<U>(errorResult, undefined, { name, description }))\n                  }\n                } else {\n                  // Regular error, wrap as failure\n                  resolve(Err<U>(errorResult, undefined, { name, description }))\n                }\n              }\n            } catch (handlerError) {\n              // If error handler throws, wrap as failure\n              resolve(Err<U>(handlerError, undefined, { name, description }))\n            }\n          } finally {\n            cleanupCancellation.get()()\n          }\n        })().catch((error) => resolve(Err<U>(error, undefined, { name, description }))) // Handle any errors from the async IIFE\n      })\n    },\n\n    /**\n     * Run a synchronous operation with explicit try/catch/finally semantics\n     * Returns a TaskOutcome for functional error handling\n     *\n     * @param t - The main operation function that returns a value\n     * @param e - Optional error handler function\n     * @param f - Optional finally handler function\n     */\n    Sync: <U = T>(\n      t: () => U,\n      e: (error: unknown) => unknown = (error: unknown) => error,\n      f: () => void = () => {},\n    ): TaskOutcome<U> => {\n      try {\n        return Ok<U>(t(), { name, description })\n      } catch (error) {\n        return Err<U>(e(error), undefined, { name, description })\n      } finally {\n        f()\n      }\n    },\n\n    /**\n     * Run an async operation with progress tracking capabilities\n     * Returns a Promise and provides progress updates via callback\n     *\n     * @param t - The main operation that receives a progress updater function\n     * @param onProgress - Callback that receives progress updates (0-100)\n     * @param e - Optional error handler function\n     * @param f - Optional finally handler function\n     * @param cancellationToken - Optional token for cancellation support\n     */\n    AsyncWithProgress: <U = T>(\n      t: (updateProgress: (percent: number) => void) => U | Promise<U> | TaskOutcome<U> | Promise<TaskOutcome<U>>,\n      onProgress: (percent: number) => void,\n      e: (error: unknown) => unknown | TaskOutcome<U> = (error: unknown) => error,\n      f: () => Promise<void> | void = () => {},\n      cancellationToken?: CancellationToken,\n    ): FPromise<TaskOutcome<U>> => {\n      // Create a progress updater that validates and forwards progress\n      const updateProgress = (percent: number) => {\n        // Validate progress value\n        const validPercent = Math.max(0, Math.min(100, percent))\n        // Only report progress if not already at 100%\n        if (validPercent <= 100) {\n          onProgress(validPercent)\n        }\n      }\n\n      // Use the regular Async method with the progress-enabled function\n      return body.Async<U>(() => t(updateProgress), e, f, cancellationToken)\n    },\n  }\n\n  return {\n    ...Base(\"Task\", body),\n    _type: \"Task\",\n  }\n}\n\nconst TaskCompanion = {\n  /**\n   * Create a successful Task result\n   */\n  success: <T>(data: T, params?: TaskParams): Ok<T> => Ok<T>(data, params),\n\n  /**\n   * Create a failed Task result\n   */\n  fail: <T>(error: unknown, data?: unknown, params?: TaskParams): Err<T> => Err<T>(error, data, params),\n\n  /**\n   * Create a successful Task result (alias for success)\n   * Preferred for new code\n   */\n  ok: <T>(data: T, params?: TaskParams): Ok<T> => Ok<T>(data, params),\n\n  /**\n   * Create a failed Task result (alias for fail)\n   * Preferred for new code\n   */\n  err: <T>(error: unknown, data?: unknown, params?: TaskParams): Err<T> => Err<T>(error, data, params),\n\n  /**\n   * Create TaskOutcome from Either\n   * @param either - Either to convert\n   * @param params - Task parameters\n   */\n  fromEither: <T>(either: Either<Throwable, T>, params?: TaskParams): TaskOutcome<T> =>\n    eitherToTaskOutcome(either, params),\n\n  /**\n   * Create TaskOutcome from Try\n   * @param tryValue - Try to convert\n   * @param params - Task parameters\n   */\n  fromTry: <T>(tryValue: Try<T>, params?: TaskParams): TaskOutcome<T> =>\n    tryValue.isSuccess()\n      ? Ok<T>(tryValue.orThrow(), params)\n      : Err<T>(\n          tryValue.fold(\n            (error) => error,\n            () => new Error(\"Unexpected success\"),\n          ),\n          undefined,\n          params,\n        ),\n\n  /**\n   * Extract the error chain from a Throwable error\n   * Returns an array of errors from outermost to innermost\n   *\n   * @param error - The error to extract the chain from\n   * @returns An array of errors in the chain, from outermost to innermost\n   */\n  getErrorChain: (error: Error | undefined): Error[] => {\n    if (!error) return []\n\n    const chain = ArrayBuilder<Error>()\n    chain.add(error)\n    const current = Ref(error)\n\n    // Traverse the cause chain\n    while (current.get() && (current.get() as TaggedThrowable).cause) {\n      const { cause } = current.get() as TaggedThrowable\n      if (cause) {\n        chain.add(cause)\n        current.set(cause)\n      } else {\n        break\n      }\n\n      // Prevent infinite loops if circular references exist\n      if (chain.size() > 100) break\n    }\n\n    return chain.build()\n  },\n\n  /**\n   * Format the error chain as a string with the option to include task details\n   *\n   * @param error - The error to format\n   * @param options - Formatting options\n   * @returns A formatted string representation of the error chain\n   */\n  formatErrorChain: (\n    error: Error | undefined,\n    options?: {\n      includeTasks?: boolean\n      separator?: string\n      includeStackTrace?: boolean\n    },\n  ): string => {\n    const chain = TaskCompanion.getErrorChain(error)\n    const separator = options?.separator ?? \"\\n\"\n\n    return chain\n      .map((err, index) => {\n        if (!err) {\n          return `${index > 0 ? \"↳ \" : \"\"}Unknown error`\n        }\n\n        const { taskInfo } = err as TaggedThrowable\n        const taskName = options?.includeTasks && taskInfo?.name ? `[${taskInfo.name}] ` : \"\"\n        const message = err.message ?? \"No message\"\n\n        const result = Ref(`${index > 0 ? \"↳ \" : \"\"}${taskName}${message}`)\n\n        // Add stack trace if requested\n        if (options?.includeStackTrace && err.stack) {\n          result.set(`${result.get()}\\n${err.stack.split(\"\\n\").slice(1).join(\"\\n\")}`)\n        }\n\n        return result.get()\n      })\n      .join(separator)\n  },\n\n  /**\n   * Convert a Promise-returning function to a Task-compatible function\n   */\n  fromPromise: <U, Args extends unknown[]>(\n    promiseFn: (...args: Args) => Promise<U>,\n    params?: TaskParams,\n  ): ((...args: Args) => FPromise<TaskOutcome<U>>) => {\n    return (...args: Args) => {\n      const taskParams = params ?? { name: \"PromiseTask\", description: \"Task from Promise\" }\n      return Task(taskParams).Async<U>(\n        () => promiseFn(...args),\n        (error) => error,\n      )\n    }\n  },\n\n  /**\n   * Convert a Task result to a Promise\n   */\n  toPromise: <U>(taskOutcome: TaskOutcome<U>): Promise<U> => {\n    return new Promise((resolve, reject) => {\n      if (taskOutcome.isSuccess()) {\n        // TypeScript now knows this is Ok<U>\n        resolve(taskOutcome.orThrow())\n      } else {\n        // TypeScript now knows this is Err<U>\n        reject((taskOutcome as Err<U>).error)\n      }\n    })\n  },\n\n  /**\n   * Race multiple tasks and return the result of the first one to complete\n   * Optionally specify a timeout after which the race will fail\n   *\n   * @param tasks - Array of tasks to race (as FPromises)\n   * @param timeoutMs - Optional timeout in milliseconds\n   * @param params - Task parameters for the race operation\n   * @returns A promise that resolves with the first task to complete or rejects if all tasks fail\n   */\n  race: <T>(\n    tasks: Array<FPromise<T> | FPromise<TaskOutcome<T>>>,\n    timeoutMs?: number,\n    params?: TaskParams,\n  ): FPromise<TaskOutcome<T>> => {\n    const name = params?.name ?? \"TaskRace\"\n    const description = params?.description ?? \"Race between multiple tasks\"\n    const taskParams = { name, description }\n\n    return Task(taskParams).Async<T>(\n      async () => {\n        // Create the race between all tasks - need to handle both T and TaskOutcome<T>\n        const racePromises = ArrayBuilder<FPromise<T> | FPromise<TaskOutcome<T>>>()\n        tasks.forEach((task) => racePromises.add(task))\n\n        // Add timeout promise if timeoutMs is specified\n        const timeoutId = Ref<NodeJS.Timeout | undefined>(undefined)\n        if (typeof timeoutMs === \"number\" && timeoutMs > 0) {\n          // Create a timeout promise using FPromise to maintain type compatibility\n          const timeoutPromise = FPromise<T>((_, reject) => {\n            timeoutId.set(\n              setTimeout(() => {\n                reject(new Error(`Task race timed out after ${timeoutMs}ms`))\n              }, timeoutMs),\n            )\n          })\n          racePromises.add(timeoutPromise)\n        }\n\n        try {\n          // Create a compatible race implementation for FPromise\n          // We need to handle both T and TaskOutcome<T> types\n          return await new Promise<T>((resolve, reject) => {\n            // Setup promises to handle their own resolution\n            racePromises.build().forEach((promise) => {\n              // Handle promise resolution - need to check if result is TaskOutcome\n              promise.then(\n                // Success handler - check if result is already TaskOutcome\n                (result: T | TaskOutcome<T>) => {\n                  // Check if this is a TaskOutcome\n                  if (result && typeof result === \"object\" && \"_tag\" in result) {\n                    const outcome = result as TaskOutcome<T>\n                    if (outcome._tag === \"Ok\") {\n                      // Extract the value from Ok\n                      resolve(outcome.orThrow())\n                    } else if (outcome._tag === \"Err\") {\n                      // Err - reject with the error\n                      reject((outcome as Err<T>).error)\n                    } else {\n                      // Not a TaskOutcome, treat as raw value\n                      resolve(result as T)\n                    }\n                  } else {\n                    // Raw value\n                    resolve(result as T)\n                  }\n                },\n                // Error handler\n                (error: unknown) => reject(error),\n              )\n            })\n          })\n        } finally {\n          // Clear timeout if it was set\n          if (timeoutId.get()) {\n            clearTimeout(timeoutId.get())\n          }\n        }\n      },\n      (error) => error,\n    )\n  },\n\n  /**\n   * Convert a Node.js style callback function to a Task-compatible function\n   * Node.js callbacks typically have the signature (error, result) => void\n   *\n   * @param nodeFn - Function that accepts a Node.js style callback\n   * @param params - Task parameters\n   * @returns A function that returns an FPromise\n   */\n  fromNodeCallback: <T, Args extends unknown[]>(\n    nodeFn: (...args: [...Args, (error: unknown, result: T) => void]) => void,\n    params?: TaskParams,\n  ): ((...args: Args) => FPromise<TaskOutcome<T>>) => {\n    const name = params?.name ?? \"NodeCallbackTask\"\n    const description = params?.description ?? \"Task from Node.js callback function\"\n    const taskParams = { name, description }\n\n    return (...args: Args) => {\n      return Task(taskParams).Async<T>(\n        () => {\n          return new Promise<T>((resolve, reject) => {\n            try {\n              nodeFn(...args, (error: unknown, result: T) => {\n                if (error) {\n                  reject(error)\n                } else {\n                  resolve(result)\n                }\n              })\n            } catch (syncError) {\n              reject(syncError)\n            }\n          })\n        },\n        (error) => error,\n      )\n    }\n  },\n\n  /**\n   * Create a cancellation token source\n   * @returns A cancellation token source that can be used to control task cancellation\n   */\n  createCancellationTokenSource,\n\n  /**\n   * Create a task that can be cancelled\n   *\n   * @param task - The task function to make cancellable\n   * @param params - Task parameters\n   * @returns An object with the task and a function to cancel it\n   */\n  cancellable: <T>(\n    task: (token: CancellationToken) => Promise<T> | Promise<TaskOutcome<T>>,\n    params?: TaskParams,\n  ): { task: FPromise<TaskOutcome<T>>; cancel: () => void } => {\n    const tokenSource = createCancellationTokenSource()\n    const taskPromise = Task(params).Async<T>(\n      () => task(tokenSource.token),\n      (error) => error,\n      () => {},\n      tokenSource.token,\n    )\n\n    return {\n      task: taskPromise,\n      cancel: () => tokenSource.cancel(),\n    }\n  },\n\n  /**\n   * Creates a task with progress tracking\n   *\n   * @param task - The task function that accepts a progress updater\n   * @param onProgress - Callback function that receives progress updates\n   * @param params - Task parameters\n   * @returns An object with the task, cancel function, and current progress\n   */\n  withProgress: <T>(\n    task: (updateProgress: (percent: number) => void, token: CancellationToken) => Promise<T> | Promise<TaskOutcome<T>>,\n    onProgress: (percent: number) => void = () => {},\n    params?: TaskParams,\n  ): { task: FPromise<TaskOutcome<T>>; cancel: () => void; currentProgress: () => number } => {\n    const tokenSource = createCancellationTokenSource()\n    const currentProgressValue = Ref(0)\n\n    const updateProgress = (percent: number) => {\n      currentProgressValue.set(Math.max(0, Math.min(100, percent)))\n      onProgress(currentProgressValue.get())\n    }\n\n    const taskPromise = Task(params).Async<T>(\n      () => task(updateProgress, tokenSource.token),\n      (error) => error,\n      () => {},\n      tokenSource.token,\n    )\n\n    return {\n      task: taskPromise,\n      cancel: () => tokenSource.cancel(),\n      currentProgress: () => currentProgressValue.get(),\n    }\n  },\n}\n\nexport const Task = Companion(TaskConstructor, TaskCompanion)\n\nexport type Task = ReturnType<typeof Task>\n","/**\n * Generator-based Do-notation for monadic comprehensions\n * Provides Scala-like for-comprehension syntax using JavaScript generators\n *\n * ## Scala Equivalents\n *\n * Functype:  `const x = yield* $(Option(5))`\n * Scala:     `x <- Some(5)`\n *\n * Functype:  `return x + y`\n * Scala:     `yield x + y`\n *\n * ## Core Concepts\n *\n * - **Generators**: Use `yield* $(monad)` to extract values from monads\n * - **Short-circuiting**: None/Left/Failure automatically propagates\n * - **Type inference**: The $ helper provides proper TypeScript types\n * - **First monad wins**: Return type matches the first yielded monad\n * - **Cartesian products**: Multiple List yields create all combinations\n *\n * ## Usage Rules\n *\n * 1. All yielded values MUST be monadic (Option, Either, List, Try)\n * 2. Use the $ helper for type inference: `yield* $(Option(value))`\n * 3. Raw values should be assigned directly without yielding\n * 4. Mixed monad types are supported via Reshapeable interface\n *\n * @example\n * // Basic Option chaining (Scala: for { x <- Some(5); y <- Some(10) } yield x + y)\n * const result = Do(function* () {\n *   const x = yield* $(Option(5))        // Extract from Option\n *   const y = yield* $(Option(10))       // Extract from another Option\n *   return x + y                         // Return final value\n * })\n * // result: Option<number> with value 15\n *\n * @example\n * // List comprehension (Scala: for { x <- List(1,2); y <- List(10,20) } yield (x,y))\n * const pairs = Do(function* () {\n *   const x = yield* $(List([1, 2]))     // Iterates: 1, 2\n *   const y = yield* $(List([10, 20]))   // Iterates: 10, 20\n *   return { x, y }                      // All combinations\n * })\n * // pairs: List([{x:1,y:10}, {x:1,y:20}, {x:2,y:10}, {x:2,y:20}])\n *\n * @example\n * // Error propagation with Either\n * const validate = Do(function* () {\n *   const email = yield* $(validateEmail(input))  // Either<string, Email>\n *   const user = yield* $(fetchUser(email))       // Either<string, User>\n *   const saved = yield* $(saveUser(user))        // Either<string, Result>\n *   return saved\n * })\n * // If any step returns Left, entire chain short-circuits with that error\n *\n * @see {@link https://github.com/jordanburke/functype/blob/main/docs/do-notation.md} Full documentation\n * @module Do\n */\n\nimport { type Either, Left, Right } from \"@/either\"\nimport { List } from \"@/list/List\"\nimport { Option } from \"@/option\"\nimport { Try } from \"@/try\"\n\n// Re-export protocol definitions\nexport { type Doable, type DoResult } from \"./protocol\"\n\nimport type { Reshapeable } from \"@/reshapeable/Reshapeable\"\n\nimport { type Doable } from \"./protocol\"\n\n/**\n * Detects the monad type from the _tag field\n */\nfunction detectMonadType(value: unknown): string {\n  if (!value || typeof value !== \"object\" || !(\"_tag\" in value)) {\n    return \"unknown\"\n  }\n\n  switch (value._tag) {\n    case \"Some\":\n    case \"None\":\n      return \"Option\"\n\n    case \"Left\":\n    case \"Right\":\n      return \"Either\"\n\n    case \"List\":\n      return \"List\"\n\n    case \"Success\":\n    case \"Failure\":\n      return \"Try\"\n\n    default:\n      return \"unknown\"\n  }\n}\n\n/**\n * Type for monad constructors\n */\ntype MonadConstructor = {\n  of: (value: unknown) => unknown\n  empty: (error?: unknown) => unknown\n}\n\n/**\n * Registry of monad constructors for wrapping results\n */\nconst MonadConstructors: Record<string, MonadConstructor> = {\n  Option: {\n    of: <T>(value: T) => Option(value),\n    empty: <T>() => Option.none<T>(),\n  },\n  Either: {\n    of: <L, R>(value: R) => Right<L, R>(value),\n    empty: <L, R>(error?: L) => Left<L, R>(error as L),\n  },\n  List: {\n    of: <T>(value: T) => List([value]),\n    empty: <T>() => List<T>([]),\n  },\n  Try: {\n    of: <T>(value: T) => Try(() => value),\n    empty: (error?: unknown) =>\n      Try(() => {\n        throw error ?? new Error(\"Try failed\")\n      }),\n  },\n}\n\n// Structural types for better overload matching\ntype OptionLike = { _tag: \"Some\" | \"None\"; isSome(): boolean; get(): unknown }\ntype EitherLike = { _tag: \"Left\" | \"Right\"; isLeft(): boolean; isRight(): boolean; value: unknown }\ntype ListLike = { _tag: \"List\"; toArray(): unknown[] }\ntype TryLike = { _tag: \"Success\" | \"Failure\"; isSuccess(): boolean; get(): unknown }\n\n/**\n * Executes a generator-based monadic comprehension\n * Returns the same monad type as the first yielded monad (Scala semantics)\n *\n * - Option comprehensions return Option (None on short-circuit)\n * - Either comprehensions return Either (Left with error on short-circuit)\n * - List comprehensions return List (empty or cartesian product)\n * - Try comprehensions return Try (Failure with error on short-circuit)\n *\n * Type Inference Notes:\n * - TypeScript infers the correct return type for homogeneous comprehensions\n * - For mixed monad types, TypeScript returns a union type\n * - Use DoTyped<T> or type assertions for mixed scenarios\n *\n * @example\n * ```typescript\n * // Option comprehension returns Option:\n * const result = Do(function* () {\n *   const x = yield* $(Option(5));\n *   const y = yield* $(Option(10));\n *   return x + y;\n * });\n * // result: Option(15)\n *\n * // Either comprehension returns Either:\n * const result = Do(function* () {\n *   const x = yield* $(Right(5));\n *   const y = yield* $(Left(\"error\"));\n *   return x + y;\n * });\n * // result: Left(\"error\") - error is preserved\n *\n * // List comprehension returns List with cartesian product:\n * const result = Do(function* () {\n *   const x = yield* $(List([1, 2]));\n *   const y = yield* $(List([3, 4]));\n *   return x + y;\n * });\n * // result: List([4, 5, 5, 6])\n *\n * // Mixed types - use type assertion or DoTyped:\n * const result = Do(function* () {\n *   const x = yield* $(Option(5));\n *   const y = yield* $(Right<string, number>(10));\n *   return x + y;\n * }) as Option<number>;\n * // result: Option(15)\n * ```\n *\n * @param gen - Generator function that yields monads and returns a result\n * @returns The same monad type as the first yield\n */\n// Structural type overloads for better TypeScript inference\nexport function Do<T>(gen: () => Generator<OptionLike, T, unknown>): Option<T>\nexport function Do<L, R>(gen: () => Generator<EitherLike, R, unknown>): Either<L, R>\nexport function Do<T>(gen: () => Generator<ListLike, T, unknown>): List<T>\nexport function Do<T>(gen: () => Generator<TryLike, T, unknown>): Try<T>\n// For mixed types - first monad wins but type inference is limited\nexport function Do<T>(gen: () => Generator<OptionLike | EitherLike | ListLike | TryLike, T, unknown>): Reshapeable<T>\nexport function Do<T>(gen: () => Generator<unknown, T, unknown>): unknown\n// Implementation\nexport function Do<T>(gen: () => Generator<unknown, T, unknown>): unknown {\n  const iter = gen()\n  let firstMonadType: string | null = null\n  let cachedConstructor: MonadConstructor | undefined = undefined\n\n  function step(value?: unknown): unknown {\n    const result = iter.next(value)\n\n    if (result.done) {\n      // Wrap result in detected monad type\n      if (cachedConstructor) {\n        return cachedConstructor.of(result.value)\n      }\n      // Fallback to List for backwards compatibility\n      return List([result.value])\n    }\n\n    const yielded = result.value\n\n    // Optimized: Quick bailout for null/undefined/primitives\n    if (yielded === null || yielded === undefined || typeof yielded !== \"object\") {\n      throw new Error(\n        \"Do-notation error: All yielded values must be monadic. \" +\n          \"Use yield* $(Option(value)), yield* $(Right(value)), etc. \" +\n          \"Raw values should be assigned directly without yielding.\",\n      )\n    }\n\n    // Combined type detection and first yield check\n    if (!firstMonadType && \"_tag\" in yielded) {\n      firstMonadType = detectMonadType(yielded)\n\n      // Cache the constructor for later use\n      if (firstMonadType !== \"unknown\" && firstMonadType in MonadConstructors) {\n        cachedConstructor = MonadConstructors[firstMonadType]\n      }\n\n      // If first yield is a List, switch to List comprehension mode\n      if (firstMonadType === \"List\") {\n        // We need to restart with the List comprehension logic\n        return doListComprehension(gen)\n      }\n    }\n\n    // Optimized: Direct doUnwrap check without helper function overhead\n    if (\"doUnwrap\" in yielded) {\n      const doResult = (yielded as Doable<unknown>).doUnwrap()\n\n      if (!doResult.ok) {\n        // Short-circuit with appropriate empty/error state\n        if (!cachedConstructor) {\n          return List([])\n        }\n\n        // Handle error preservation for Either/Try with single property check\n        if (!doResult.empty && \"error\" in doResult) {\n          if (firstMonadType === \"Either\") {\n            return cachedConstructor.empty(doResult.error)\n          } else if (firstMonadType === \"Try\") {\n            return cachedConstructor.empty(\n              doResult.error instanceof Error ? doResult.error : new Error(String(doResult.error)),\n            )\n          }\n        }\n\n        // Regular empty state (None, empty List)\n        return cachedConstructor.empty()\n      }\n\n      return step(doResult.value)\n    }\n\n    // Reject non-monadic yields - all values must be wrapped with $()\n    throw new Error(\n      \"Do-notation error: All yielded values must be monadic. \" +\n        \"Use yield* $(Option(value)), yield* $(Right(value)), etc. \" +\n        \"Raw values should be assigned directly without yielding.\",\n    )\n  }\n\n  return step()\n}\n\n// Helper for List comprehensions with cartesian products\nfunction doListComprehension<T>(gen: () => Generator<unknown, T, unknown>): List<T> {\n  // Optimized: Inline helper to extract values from a monad\n  function extractValues(monad: unknown): unknown[] {\n    // Quick check for non-objects\n    if (monad === null || monad === undefined || typeof monad !== \"object\") {\n      return [monad]\n    }\n\n    // Optimized: Direct property check without isDoable\n    if (!(\"doUnwrap\" in monad)) {\n      return [monad]\n    }\n\n    const doCapable = monad as Doable<unknown>\n\n    // Check if it's a List (optimized: single property check)\n    if (\"toArray\" in doCapable) {\n      const array = (doCapable as { toArray: () => unknown[] }).toArray()\n      // Optimized: direct length check\n      return array.length === 0 ? [] : array\n    }\n\n    // For Option/Either/Try, extract single value or short-circuit\n    const result = doCapable.doUnwrap()\n    return result.ok ? [result.value] : []\n  }\n\n  // Recursive function to handle cartesian product\n  function runWithValues(previousValues: unknown[]): T[] {\n    const iter = gen()\n    const localResults: T[] = []\n    const accumulatedValues: unknown[] = []\n    let yieldCount = 0\n\n    function step(value: unknown | undefined): void {\n      const result = iter.next(value)\n\n      if (result.done) {\n        localResults.push(result.value)\n        return\n      }\n\n      // Check if we already have a value for this yield from previousValues\n      if (yieldCount < previousValues.length) {\n        const storedValue = previousValues[yieldCount]\n        accumulatedValues.push(storedValue)\n        yieldCount++\n        step(storedValue)\n        return\n      }\n\n      // Extract value(s) from the yielded monad\n      const values = extractValues(result.value)\n\n      // If empty (None/Left/empty List), short-circuit\n      if (values.length === 0) {\n        return // Short-circuit without adding to results\n      }\n\n      if (values.length > 1) {\n        // Multiple values - branch for each (cartesian product)\n        const branchResults = values.flatMap((val) => {\n          const branchValues = [...accumulatedValues, val]\n          return runWithValues(branchValues)\n        })\n        localResults.push(...branchResults)\n      } else {\n        // Single value - continue\n        accumulatedValues.push(values[0])\n        yieldCount++\n        step(values[0])\n      }\n    }\n\n    step(undefined)\n    return localResults\n  }\n\n  const results = runWithValues([])\n  return List(results)\n}\n\n/**\n * Executes an async generator-based monadic comprehension\n * Returns the same monad type as the first yielded monad\n *\n * @example\n * ```typescript\n * const result = await DoAsync(async function* () {\n *   const user = yield* $(await fetchUser(id));       // Promise<Option<User>> → User\n *   const profile = yield* $(await getProfile(user)); // Promise<Either<Error, Profile>> → Profile\n *   return { user, profile };\n * });\n * // result type matches first yield\n * ```\n *\n * @param gen - Async generator function that yields monads/promises and returns a result\n * @returns Promise of the same monad type as first yield\n */\n// Structural type overloads for better TypeScript inference\nexport function DoAsync<T>(gen: () => AsyncGenerator<OptionLike, T, unknown>): Promise<Option<T>>\nexport function DoAsync<L, R>(gen: () => AsyncGenerator<EitherLike, R, unknown>): Promise<Either<L, R>>\nexport function DoAsync<T>(gen: () => AsyncGenerator<ListLike, T, unknown>): Promise<List<T>>\nexport function DoAsync<T>(gen: () => AsyncGenerator<TryLike, T, unknown>): Promise<Try<T>>\n// For mixed types - first monad wins but type inference is limited\nexport function DoAsync<T>(\n  gen: () => AsyncGenerator<OptionLike | EitherLike | ListLike | TryLike, T, unknown>,\n): Promise<Reshapeable<T>>\nexport function DoAsync<T>(gen: () => AsyncGenerator<unknown, T, unknown>): Promise<unknown>\n// Implementation\nexport async function DoAsync<T>(gen: () => AsyncGenerator<unknown, T, unknown>): Promise<unknown> {\n  const iterator = gen()\n  let firstMonadType: string | null = null\n  let cachedConstructor: MonadConstructor | undefined = undefined\n\n  async function step(value?: unknown): Promise<unknown> {\n    const result = await iterator.next(value)\n\n    if (result.done) {\n      // Wrap result in detected monad type\n      if (cachedConstructor) {\n        return cachedConstructor.of(result.value)\n      }\n      // Fallback to List for backwards compatibility\n      return List([result.value])\n    }\n\n    // Await the yielded value in case it's a Promise\n    const yielded = await Promise.resolve(result.value)\n\n    // Optimized: Early bailout for non-objects\n    if (yielded === null || yielded === undefined || typeof yielded !== \"object\") {\n      // Pass through non-monadic values\n      return step(yielded)\n    }\n\n    // Combined type detection and first yield check\n    if (!firstMonadType && \"_tag\" in yielded) {\n      firstMonadType = detectMonadType(yielded)\n\n      // Cache the constructor for later use\n      if (firstMonadType !== \"unknown\" && firstMonadType in MonadConstructors) {\n        cachedConstructor = MonadConstructors[firstMonadType]\n      }\n    }\n\n    // Optimized: Direct doUnwrap check without helper\n    if (\"doUnwrap\" in yielded) {\n      const doResult = (yielded as Doable<unknown>).doUnwrap()\n\n      if (!doResult.ok) {\n        // Short-circuit with appropriate empty/error state\n        if (!cachedConstructor) {\n          return List([])\n        }\n\n        // Handle error preservation with single property check\n        if (!doResult.empty && \"error\" in doResult) {\n          if (firstMonadType === \"Either\") {\n            return cachedConstructor.empty(doResult.error)\n          } else if (firstMonadType === \"Try\") {\n            return cachedConstructor.empty(\n              doResult.error instanceof Error ? doResult.error : new Error(String(doResult.error)),\n            )\n          }\n        }\n\n        return cachedConstructor.empty()\n      }\n\n      return step(doResult.value)\n    }\n\n    // If the value doesn't implement the protocol, pass it through\n    return step(yielded)\n  }\n\n  return step()\n}\n\n/**\n * Helper function to check if a value implements the Doable interface\n * @param value - Value to check\n * @returns True if the value implements Doable\n */\nexport function isDoCapable<T>(value: unknown): value is Doable<T> {\n  return (\n    value !== null &&\n    typeof value === \"object\" &&\n    \"doUnwrap\" in value &&\n    typeof (value as Doable<T>).doUnwrap === \"function\"\n  )\n}\n\n/**\n * Manually unwrap a monad using the Doable interface\n * Useful for testing or when you need to unwrap outside of a Do-comprehension\n *\n * @param monad - Monad to unwrap\n * @returns The unwrapped value\n * @throws Error if the monad cannot be unwrapped\n */\nexport function unwrap<T>(monad: Doable<T>): T {\n  const result = monad.doUnwrap()\n  if (result.ok) {\n    return result.value\n  } else if (\"error\" in result) {\n    throw result.error\n  } else {\n    throw new Error(\"Cannot unwrap empty monad\")\n  }\n}\n\n/**\n * Type helper for Do-notation generators.\n * Provides better type hints in IDEs.\n *\n * @example\n * ```typescript\n * const result = Do(function* (): DoGenerator<number> {\n *   const x = yield* $(List([1, 2]))  // x is still unknown but return type is clear\n *   const y = yield* $(List([3, 4]))\n *   return x + y\n * })\n * ```\n */\nexport type DoGenerator<T, TYield = unknown> = Generator<TYield, T, unknown>\n\n/**\n * Extracts values from monads in Do-notation with type inference.\n * The '$' symbol is the universal extraction operator in functional programming.\n *\n * @example\n * ```typescript\n * const result = Do(function* () {\n *   const x = yield* $(Option(5))        // x: number\n *   const y = yield* $(List([1, 2, 3]))  // y: number (for cartesian product)\n *   const name = yield* $(Right(\"Alice\")) // name: string\n *   return `${name}: ${x + y}`\n * })\n * ```\n *\n * @param monad - Any monad that can be unwrapped (Option, Either, List, Try, etc.)\n * @returns A generator that yields the monad and returns its extracted value\n */\n// Overloads for specific types to improve type inference\nexport function $<T>(monad: Option<T>): Generator<Option<T>, T, T>\nexport function $<L, R>(monad: Either<L, R>): Generator<Either<L, R>, R, R>\nexport function $<T>(monad: List<T>): Generator<List<T>, T, T>\nexport function $<T>(monad: Try<T>): Generator<Try<T>, T, T>\nexport function $<T>(monad: Doable<T>): Generator<Doable<T>, T, T>\nexport function $<M>(monad: M): Generator<M, InferYieldType<M>, InferYieldType<M>>\nexport function* $<M>(monad: M): Generator<M, unknown, unknown> {\n  return (yield monad) as unknown\n}\n\n// Type inference for common monads\ntype InferYieldType<M> = M extends { isSome(): boolean; get(): infer T }\n  ? T // Option\n  : M extends { isRight(): boolean; value: infer R }\n    ? R // Either (Right)\n    : M extends { toArray(): (infer T)[] }\n      ? T // List\n      : M extends { isSuccess(): boolean; get(): infer T }\n        ? T // Try\n        : M extends Doable<infer T>\n          ? T // Generic Doable\n          : unknown\n\n// Legacy error types (kept for backwards compatibility but not used)\nexport const NoneError = (message = \"Cannot unwrap None in Do-notation\"): Error => {\n  const error = new Error(message)\n  const customError = Object.create(Error.prototype)\n  customError.message = error.message\n  customError.stack = error.stack\n  customError.name = \"NoneError\"\n  return customError\n}\n\nexport interface LeftErrorType<L> extends Error {\n  value: L\n}\n\nexport const LeftError = <L>(value: L, message = \"Cannot unwrap Left in Do-notation\"): LeftErrorType<L> => {\n  const error = new Error(message)\n  const customError = Object.create(Error.prototype) as LeftErrorType<L>\n  customError.message = error.message\n  customError.stack = error.stack\n  customError.name = \"LeftError\"\n  customError.value = value\n  return customError\n}\n\nexport const EmptyListError = (message = \"Cannot unwrap empty List in Do-notation\"): Error => {\n  const error = new Error(message)\n  const customError = Object.create(Error.prototype)\n  customError.message = error.message\n  customError.stack = error.stack\n  customError.name = \"EmptyListError\"\n  return customError\n}\n\nexport interface FailureErrorType extends Error {\n  cause: Error\n}\n\nexport const FailureError = (cause: Error, message = \"Cannot unwrap Failure in Do-notation\"): FailureErrorType => {\n  const error = new Error(message)\n  const customError = Object.create(Error.prototype) as FailureErrorType\n  customError.message = error.message\n  customError.stack = error.stack\n  customError.name = \"FailureError\"\n  customError.cause = cause\n  return customError\n}\n","import { Task } from \"@/core\"\nimport { Throwable } from \"@/core/throwable/Throwable\"\n\n/**\n * Type definition for task information that may be attached to errors\n */\nexport type TaskErrorInfo = {\n  name?: string\n  description?: string\n  [key: string]: unknown\n}\n\n/**\n * Type definition for an error with potential task information\n */\nexport type ErrorWithTaskInfo = Error & {\n  taskInfo?: TaskErrorInfo\n  data?: unknown\n}\n\n/**\n * Type definition for a structured error chain element\n */\nexport type ErrorChainElement = {\n  message?: string\n  name?: string\n  taskInfo?: TaskErrorInfo\n  stack?: string\n  [key: string]: unknown\n}\n\n/**\n * Options for formatting error chains\n */\nexport type ErrorFormatterOptions = {\n  /** Include task names in the formatted output */\n  includeTasks?: boolean\n  /** Include stack traces in the formatted output */\n  includeStackTrace?: boolean\n  /** Separator between error lines (default: newline) */\n  separator?: string\n  /** Include detailed error data in the output */\n  includeData?: boolean\n  /** Maximum number of stack frames to include if stack trace is enabled */\n  maxStackFrames?: number\n  /** Title to display at the start of the formatted error */\n  title?: string\n  /** Format the output with colors for console display */\n  colors?: boolean\n}\n\n/**\n * Default options for error formatting\n */\nconst defaultOptions: ErrorFormatterOptions = {\n  includeTasks: true,\n  includeStackTrace: false,\n  separator: \"\\n\",\n  includeData: false,\n  maxStackFrames: 3,\n  title: \"Error\",\n  colors: false,\n}\n\n/**\n * Safely stringify data including BigInt values and circular references\n */\nexport function safeStringify(obj: unknown): string {\n  const seen = new WeakSet()\n  return JSON.stringify(\n    obj,\n    (key, value) => {\n      // Handle BigInt\n      if (typeof value === \"bigint\") {\n        return `${value.toString()}n`\n      }\n\n      // Handle circular references\n      if (typeof value === \"object\" && value !== null) {\n        if (seen.has(value)) {\n          return \"[Circular Reference]\"\n        }\n        seen.add(value)\n      }\n\n      // Format stack traces for better readability\n      if (key === \"stack\" && typeof value === \"string\") {\n        return formatStackTrace(value)\n      }\n\n      return value\n    },\n    2,\n  )\n}\n\n/**\n * Format a stack trace string for better readability\n */\nexport function formatStackTrace(stack: string | undefined): string {\n  if (stack === undefined || stack === \"\") return \"\"\n\n  // Split the stack trace into lines\n  const lines = stack.split(\"\\n\")\n\n  // Process the error message (first line)\n  const errorMessage = lines[0]\n\n  // Process the stack frames (remaining lines)\n  const stackFrames = lines.slice(1).map((line) => line.trim())\n\n  // Return the formatted stack trace\n  return [errorMessage, ...stackFrames].join(\"\\n\")\n}\n\n/**\n * Create a formatted string representation of an error for better logging and display\n *\n * @example\n * ```typescript\n * const error = new Error(\"Something went wrong\");\n * console.error(formatError(error, { colors: true, includeData: true }));\n * ```\n */\nexport function formatError(error: unknown, options?: ErrorFormatterOptions): string {\n  // Merge with default options\n  const opts = { ...defaultOptions, ...options }\n\n  // If it's not an Error object, wrap it with Throwable\n  const throwableError = error instanceof Error ? error : Throwable.apply(error)\n\n  // Try to get the error chain if possible\n  const errorChain = Task?.getErrorChain ? Task.getErrorChain(throwableError as Error) : [throwableError]\n\n  // Format the title\n  const title = opts.colors\n    ? `\\x1b[31m${opts.title}:\\x1b[0m ${throwableError.message}`\n    : `${opts.title}: ${throwableError.message}`\n\n  // Format the error chain\n  const chainFormatted = errorChain\n    .map((err, index) => {\n      // Add indentation for nesting level\n      const indentation = \"  \".repeat(index)\n      const prefix = index > 0 ? \"↳ \" : \"\"\n\n      // Get task information if available\n      const { taskInfo } = err as ErrorWithTaskInfo\n      const taskName =\n        opts.includeTasks && taskInfo?.name\n          ? opts.colors\n            ? `\\x1b[36m[${taskInfo.name}]\\x1b[0m `\n            : `[${taskInfo.name}] `\n          : \"\"\n\n      // Main error line\n      let errorLine = `${indentation}${prefix}${taskName}${err.message}`\n\n      // Add stack trace if requested\n      if (opts.includeStackTrace && err.stack) {\n        // Format the stack trace\n        const formattedStackTrace = formatStackTrace(err.stack)\n        const stackLines = formattedStackTrace.split(\"\\n\").slice(1) // Skip the first line (error message)\n        const maxFrames = opts.maxStackFrames ?? defaultOptions.maxStackFrames ?? 3\n        const limitedStack = stackLines.slice(0, maxFrames)\n\n        // Format the stack frames with indentation\n        const formattedStack = limitedStack\n          .map((line) => {\n            return `${indentation}  ${opts.colors ? \"\\x1b[90m\" : \"\"}${line}${opts.colors ? \"\\x1b[0m\" : \"\"}`\n          })\n          .join(\"\\n\")\n\n        // Add stack trace with a spacer\n        errorLine += `\\n${formattedStack}`\n\n        // Add indicator if stack was truncated\n        if (stackLines.length > maxFrames) {\n          errorLine += `\\n${indentation}  ${opts.colors ? \"\\x1b[90m\" : \"\"}...${stackLines.length - maxFrames} more stack frames${opts.colors ? \"\\x1b[0m\" : \"\"}`\n        }\n      }\n\n      return errorLine\n    })\n    .join(opts.separator)\n\n  // Build the complete output\n  let output = `${title}\\n\\n${chainFormatted}`\n\n  // Add error data if requested and available\n  if (opts.includeData) {\n    const { data } = throwableError as ErrorWithTaskInfo\n    if (data) {\n      const dataFormatted = opts.colors\n        ? `\\n\\n\\x1b[33mContext:\\x1b[0m\\n${safeStringify(data)}`\n        : `\\n\\nContext:\\n${safeStringify(data)}`\n\n      output += dataFormatted\n    }\n  }\n\n  return output\n}\n\n/**\n * Create a serializer function for Pino or other JSON loggers\n * to better represent errors with their full context\n */\nexport function createErrorSerializer() {\n  return function errorSerializer(err: unknown) {\n    if (!err) return err\n\n    // Ensure we're working with an Error object\n    const error = err instanceof Error ? err : new Error(String(err))\n\n    // Basic error properties\n    const serialized: Record<string, unknown> = {\n      message: error.message,\n      name: error.name || \"Error\",\n      stack: error.stack ? formatStackTrace(error.stack) : undefined,\n    }\n\n    // Add taskInfo if available\n    if ((error as ErrorWithTaskInfo).taskInfo) {\n      serialized.taskInfo = (error as ErrorWithTaskInfo).taskInfo\n    }\n\n    // Add custom error data if available\n    if ((error as ErrorWithTaskInfo).data) {\n      serialized.data = (error as ErrorWithTaskInfo).data\n    }\n\n    // Add Error Chain if the error came from a Task\n    if (typeof Task?.getErrorChain === \"function\") {\n      try {\n        const errorChain = Task.getErrorChain(error)\n        if (errorChain.length > 1) {\n          serialized.errorChain = Task.formatErrorChain(error, { includeTasks: true })\n\n          // Also include structured error chain for processing\n          serialized.structuredErrorChain = errorChain.map((e) => ({\n            message: e.message,\n            name: e.name,\n            taskInfo: (e as ErrorWithTaskInfo).taskInfo,\n            // Format stack trace for each error in the chain\n            stack: (e as Error).stack ? formatStackTrace((e as Error).stack) : undefined,\n          }))\n        }\n      } catch (_e) {\n        // If error chain extraction fails, ignore it\n      }\n    }\n\n    // Copy all enumerable properties from the error object\n    // Safely copy own properties from the error object\n    Object.getOwnPropertyNames(error).forEach((key) => {\n      if (!serialized[key]) {\n        // First cast to unknown, then to Record to satisfy TypeScript\n        const value = (error as unknown as Record<string, unknown>)[key]\n        serialized[key] = value\n      }\n    })\n\n    return serialized\n  }\n}\n","export const ParseError = (message?: string): Error & { name: \"ParseError\" } => {\n  const error = new Error(message)\n  error.name = \"ParseError\"\n  return error as Error & { name: \"ParseError\" }\n}\n\nexport type ParseError = Error & { name: \"ParseError\" }\n","import { Throwable } from \"@/core/throwable/Throwable\"\n\n/**\n * Type-safe error codes using template literal types\n */\nexport type ErrorCode =\n  | \"VALIDATION_FAILED\"\n  | \"NETWORK_ERROR\"\n  | \"AUTH_REQUIRED\"\n  | \"NOT_FOUND\"\n  | \"PERMISSION_DENIED\"\n  | \"RATE_LIMITED\"\n  | \"INTERNAL_ERROR\"\n  | \"BAD_REQUEST\"\n  | \"CONFLICT\"\n  | \"TIMEOUT\"\n\n/**\n * Template literal type for error messages based on error code\n */\nexport type ErrorMessage<T extends ErrorCode> = T extends \"VALIDATION_FAILED\"\n  ? `Validation failed: ${string}`\n  : T extends \"NETWORK_ERROR\"\n    ? `Network error: ${string}`\n    : T extends \"AUTH_REQUIRED\"\n      ? `Authentication required: ${string}`\n      : T extends \"NOT_FOUND\"\n        ? `Not found: ${string}`\n        : T extends \"PERMISSION_DENIED\"\n          ? `Permission denied: ${string}`\n          : T extends \"RATE_LIMITED\"\n            ? `Rate limit exceeded: ${string}`\n            : T extends \"INTERNAL_ERROR\"\n              ? `Internal server error: ${string}`\n              : T extends \"BAD_REQUEST\"\n                ? `Bad request: ${string}`\n                : T extends \"CONFLICT\"\n                  ? `Conflict: ${string}`\n                  : T extends \"TIMEOUT\"\n                    ? `Request timeout: ${string}`\n                    : never\n\n/**\n * HTTP status codes mapped to error codes\n */\nexport type ErrorStatus<T extends ErrorCode> = T extends \"VALIDATION_FAILED\" | \"BAD_REQUEST\"\n  ? 400\n  : T extends \"AUTH_REQUIRED\"\n    ? 401\n    : T extends \"PERMISSION_DENIED\"\n      ? 403\n      : T extends \"NOT_FOUND\"\n        ? 404\n        : T extends \"CONFLICT\"\n          ? 409\n          : T extends \"RATE_LIMITED\"\n            ? 429\n            : T extends \"TIMEOUT\"\n              ? 408\n              : T extends \"INTERNAL_ERROR\"\n                ? 500\n                : T extends \"NETWORK_ERROR\"\n                  ? 503\n                  : 500\n\n/**\n * Context type for each error code\n */\nexport type TypedErrorContext<T extends ErrorCode> = T extends \"VALIDATION_FAILED\"\n  ? { field: string; value: unknown; rule: string }\n  : T extends \"NETWORK_ERROR\"\n    ? { url: string; method: string; statusCode?: number }\n    : T extends \"AUTH_REQUIRED\"\n      ? { resource: string; requiredRole?: string }\n      : T extends \"NOT_FOUND\"\n        ? { resource: string; id: string | number }\n        : T extends \"PERMISSION_DENIED\"\n          ? { action: string; resource: string; userId?: string }\n          : T extends \"RATE_LIMITED\"\n            ? { limit: number; window: string; retryAfter?: number }\n            : T extends \"INTERNAL_ERROR\"\n              ? { errorId: string; timestamp: string }\n              : T extends \"BAD_REQUEST\"\n                ? { reason: string; expected?: string }\n                : T extends \"CONFLICT\"\n                  ? { resource: string; conflictingValue: string }\n                  : T extends \"TIMEOUT\"\n                    ? { duration: number; operation: string }\n                    : Record<string, unknown>\n\n/**\n * Type-safe error class with template literal types\n */\nexport interface TypedError<T extends ErrorCode> extends Throwable {\n  readonly code: T\n  readonly message: ErrorMessage<T>\n  readonly status: ErrorStatus<T>\n  readonly context: TypedErrorContext<T>\n  readonly timestamp: string\n  readonly traceId?: string\n}\n\n/**\n * Create a typed error with compile-time type safety\n */\nconst TypedErrorConstructor = <T extends ErrorCode>(\n  code: T,\n  message: ErrorMessage<T>,\n  context: TypedErrorContext<T>,\n  options?: {\n    cause?: unknown\n    traceId?: string\n  },\n): TypedError<T> => {\n  const error = Throwable.apply(message, context, { name: code, description: message }) as TypedError<T>\n\n  return Object.assign(error, {\n    code,\n    message,\n    status: getStatusForCode(code),\n    context,\n    timestamp: new Date().toISOString(),\n    traceId: options?.traceId,\n  })\n}\n\n/**\n * Get HTTP status for error code\n */\nconst getStatusForCode = <T extends ErrorCode>(code: T): ErrorStatus<T> => {\n  const statusMap: Record<ErrorCode, number> = {\n    VALIDATION_FAILED: 400,\n    BAD_REQUEST: 400,\n    AUTH_REQUIRED: 401,\n    PERMISSION_DENIED: 403,\n    NOT_FOUND: 404,\n    TIMEOUT: 408,\n    CONFLICT: 409,\n    RATE_LIMITED: 429,\n    INTERNAL_ERROR: 500,\n    NETWORK_ERROR: 503,\n  }\n  return statusMap[code] as ErrorStatus<T>\n}\n\n/**\n * Type-safe error builders for each error type\n */\nconst TypedErrorCompanion = {\n  /**\n   * Create a validation error\n   * @example\n   * const error = TypedError.validation(\"email\", \"test@\", \"must be valid email\")\n   * // Type: TypedError<\"VALIDATION_FAILED\">\n   * // Message must match: \"Validation failed: ...\"\n   */\n  validation: (field: string, value: unknown, rule: string): TypedError<\"VALIDATION_FAILED\"> =>\n    TypedErrorConstructor(\"VALIDATION_FAILED\", `Validation failed: ${field} ${rule}`, { field, value, rule }),\n\n  /**\n   * Create a network error\n   * @example\n   * const error = TypedError.network(\"https://api.example.com\", \"POST\", 500)\n   * // Type: TypedError<\"NETWORK_ERROR\">\n   */\n  network: (url: string, method: string, statusCode?: number): TypedError<\"NETWORK_ERROR\"> =>\n    TypedErrorConstructor(\"NETWORK_ERROR\", `Network error: ${method} ${url}${statusCode ? ` (${statusCode})` : \"\"}`, {\n      url,\n      method,\n      statusCode,\n    }),\n\n  /**\n   * Create an authentication error\n   * @example\n   * const error = TypedError.auth(\"/api/admin\", \"admin\")\n   * // Type: TypedError<\"AUTH_REQUIRED\">\n   */\n  auth: (resource: string, requiredRole?: string): TypedError<\"AUTH_REQUIRED\"> =>\n    TypedErrorConstructor(\n      \"AUTH_REQUIRED\",\n      `Authentication required: ${resource}${requiredRole ? ` (role: ${requiredRole})` : \"\"}`,\n      { resource, requiredRole },\n    ),\n\n  /**\n   * Create a not found error\n   * @example\n   * const error = TypedError.notFound(\"user\", \"123\")\n   * // Type: TypedError<\"NOT_FOUND\">\n   */\n  notFound: (resource: string, id: string | number): TypedError<\"NOT_FOUND\"> =>\n    TypedErrorConstructor(\"NOT_FOUND\", `Not found: ${resource} with id ${id}`, { resource, id }),\n\n  /**\n   * Create a permission denied error\n   * @example\n   * const error = TypedError.permission(\"delete\", \"post\", \"user123\")\n   * // Type: TypedError<\"PERMISSION_DENIED\">\n   */\n  permission: (action: string, resource: string, userId?: string): TypedError<\"PERMISSION_DENIED\"> =>\n    TypedErrorConstructor(\"PERMISSION_DENIED\", `Permission denied: cannot ${action} ${resource}`, {\n      action,\n      resource,\n      userId,\n    }),\n\n  /**\n   * Create a rate limit error\n   * @example\n   * const error = TypedError.rateLimit(100, \"1h\", 3600)\n   * // Type: TypedError<\"RATE_LIMITED\">\n   */\n  rateLimit: (limit: number, window: string, retryAfter?: number): TypedError<\"RATE_LIMITED\"> =>\n    TypedErrorConstructor(\"RATE_LIMITED\", `Rate limit exceeded: ${limit} requests per ${window}`, {\n      limit,\n      window,\n      retryAfter,\n    }),\n\n  /**\n   * Create an internal error\n   * @example\n   * const error = TypedError.internal(\"ERR-500-ABC123\")\n   * // Type: TypedError<\"INTERNAL_ERROR\">\n   */\n  internal: (errorId: string): TypedError<\"INTERNAL_ERROR\"> =>\n    TypedErrorConstructor(\"INTERNAL_ERROR\", `Internal server error: ${errorId}`, {\n      errorId,\n      timestamp: new Date().toISOString(),\n    }),\n\n  /**\n   * Create a bad request error\n   * @example\n   * const error = TypedError.badRequest(\"Invalid JSON\", \"valid JSON object\")\n   * // Type: TypedError<\"BAD_REQUEST\">\n   */\n  badRequest: (reason: string, expected?: string): TypedError<\"BAD_REQUEST\"> =>\n    TypedErrorConstructor(\"BAD_REQUEST\", `Bad request: ${reason}`, { reason, expected }),\n\n  /**\n   * Create a conflict error\n   * @example\n   * const error = TypedError.conflict(\"email\", \"user@example.com\")\n   * // Type: TypedError<\"CONFLICT\">\n   */\n  conflict: (resource: string, conflictingValue: string): TypedError<\"CONFLICT\"> =>\n    TypedErrorConstructor(\"CONFLICT\", `Conflict: ${resource} already exists with value ${conflictingValue}`, {\n      resource,\n      conflictingValue,\n    }),\n\n  /**\n   * Create a timeout error\n   * @example\n   * const error = TypedError.timeout(30000, \"database query\")\n   * // Type: TypedError<\"TIMEOUT\">\n   */\n  timeout: (duration: number, operation: string): TypedError<\"TIMEOUT\"> =>\n    TypedErrorConstructor(\"TIMEOUT\", `Request timeout: ${operation} exceeded ${duration}ms`, { duration, operation }),\n\n  /**\n   * Check if a value is a TypedError\n   */\n  isTypedError: (value: unknown): value is TypedError<ErrorCode> => {\n    return (\n      typeof value === \"object\" &&\n      value !== null &&\n      \"code\" in value &&\n      \"message\" in value &&\n      \"status\" in value &&\n      \"context\" in value &&\n      \"_tag\" in value &&\n      (value as { _tag: unknown })._tag === \"Throwable\"\n    )\n  },\n\n  /**\n   * Check if a TypedError has a specific code\n   */\n  hasCode: <T extends ErrorCode>(error: TypedError<ErrorCode>, code: T): error is TypedError<T> => {\n    return error.code === code\n  },\n}\n\nexport const TypedError = Object.assign(TypedErrorConstructor, TypedErrorCompanion)\n","import type { Either } from \"@/either\"\nimport { Left, Right } from \"@/either\"\nimport { TypedError } from \"@/error/typed/TypedError\"\nimport { List } from \"@/list\"\nimport type { Type } from \"@/types\"\n\n/**\n * Validation rule types using template literal types\n */\nexport type ValidationRule =\n  | `min:${number}`\n  | `max:${number}`\n  | `minLength:${number}`\n  | `maxLength:${number}`\n  | `pattern:${string}`\n  | `email`\n  | `url`\n  | `uuid`\n  | `required`\n  | `numeric`\n  | `alpha`\n  | `alphanumeric`\n  | `date`\n  | `future`\n  | `past`\n  | `in:${string}`\n  | `notIn:${string}`\n\n/**\n * Validator function type\n */\nexport type Validator<T> = (value: unknown) => Either<TypedError<\"VALIDATION_FAILED\">, T>\n\n/**\n * Field validation result\n */\nexport type FieldValidation<T> = {\n  field: string\n  value: unknown\n  result: Either<TypedError<\"VALIDATION_FAILED\">, T>\n}\n\n/**\n * Form validation result\n */\nexport type FormValidation<T extends Record<string, Type>> = Either<List<TypedError<\"VALIDATION_FAILED\">>, T>\n\n/**\n * Create validators from validation rules\n */\nconst ValidationConstructor = {\n  /**\n   * Create a validator from a rule string\n   * @example\n   * const validator = Validation.rule<number>(\"min:18\")\n   * const result = validator(25) // Right(25)\n   * const error = validator(15) // Left(TypedError)\n   */\n  rule: <T extends Type>(rule: ValidationRule): Validator<T> => {\n    return (value: unknown): Either<TypedError<\"VALIDATION_FAILED\">, T> => {\n      // Email validation\n      if (rule === \"email\") {\n        const emailRegex = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/\n        if (typeof value !== \"string\" || !emailRegex.test(value)) {\n          return Left(TypedError.validation(\"value\", value, \"must be a valid email\"))\n        }\n        return Right(value as T)\n      }\n\n      // URL validation\n      if (rule === \"url\") {\n        try {\n          new URL(String(value))\n          return Right(value as T)\n        } catch {\n          return Left(TypedError.validation(\"value\", value, \"must be a valid URL\"))\n        }\n      }\n\n      // UUID validation\n      if (rule === \"uuid\") {\n        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i\n        if (typeof value !== \"string\" || !uuidRegex.test(value)) {\n          return Left(TypedError.validation(\"value\", value, \"must be a valid UUID\"))\n        }\n        return Right(value as T)\n      }\n\n      // Required validation\n      if (rule === \"required\") {\n        if (value === null || value === undefined || value === \"\") {\n          return Left(TypedError.validation(\"value\", value, \"is required\"))\n        }\n        return Right(value as T)\n      }\n\n      // Numeric validation\n      if (rule === \"numeric\") {\n        if (typeof value !== \"number\" && !/^\\d+$/.test(String(value))) {\n          return Left(TypedError.validation(\"value\", value, \"must be numeric\"))\n        }\n        return Right(value as T)\n      }\n\n      // Alpha validation\n      if (rule === \"alpha\") {\n        if (typeof value !== \"string\" || !/^[a-zA-Z]+$/.test(value)) {\n          return Left(TypedError.validation(\"value\", value, \"must contain only letters\"))\n        }\n        return Right(value as T)\n      }\n\n      // Alphanumeric validation\n      if (rule === \"alphanumeric\") {\n        if (typeof value !== \"string\" || !/^[a-zA-Z0-9]+$/.test(value)) {\n          return Left(TypedError.validation(\"value\", value, \"must be alphanumeric\"))\n        }\n        return Right(value as T)\n      }\n\n      // Min validation\n      if (rule.startsWith(\"min:\")) {\n        const min = Number(rule.split(\":\")[1])\n        const num = Number(value)\n        if (isNaN(num) || num < min) {\n          return Left(TypedError.validation(\"value\", value, `must be at least ${min}`))\n        }\n        return Right(value as T)\n      }\n\n      // Max validation\n      if (rule.startsWith(\"max:\")) {\n        const max = Number(rule.split(\":\")[1])\n        const num = Number(value)\n        if (isNaN(num) || num > max) {\n          return Left(TypedError.validation(\"value\", value, `must be at most ${max}`))\n        }\n        return Right(value as T)\n      }\n\n      // MinLength validation\n      if (rule.startsWith(\"minLength:\")) {\n        const minLength = Number(rule.split(\":\")[1])\n        const str = String(value)\n        if (str.length < minLength) {\n          return Left(TypedError.validation(\"value\", value, `must be at least ${minLength} characters`))\n        }\n        return Right(value as T)\n      }\n\n      // MaxLength validation\n      if (rule.startsWith(\"maxLength:\")) {\n        const maxLength = Number(rule.split(\":\")[1])\n        const str = String(value)\n        if (str.length > maxLength) {\n          return Left(TypedError.validation(\"value\", value, `must be at most ${maxLength} characters`))\n        }\n        return Right(value as T)\n      }\n\n      // Pattern validation\n      if (rule.startsWith(\"pattern:\")) {\n        const pattern = rule.substring(8) // Remove \"pattern:\"\n        const regex = new RegExp(pattern)\n        if (!regex.test(String(value))) {\n          return Left(TypedError.validation(\"value\", value, `must match pattern ${pattern}`))\n        }\n        return Right(value as T)\n      }\n\n      // In validation\n      if (rule.startsWith(\"in:\")) {\n        const allowed = rule.substring(3).split(\",\")\n        if (!allowed.includes(String(value))) {\n          return Left(TypedError.validation(\"value\", value, `must be one of: ${allowed.join(\", \")}`))\n        }\n        return Right(value as T)\n      }\n\n      // NotIn validation\n      if (rule.startsWith(\"notIn:\")) {\n        const disallowed = rule.substring(6).split(\",\")\n        if (disallowed.includes(String(value))) {\n          return Left(TypedError.validation(\"value\", value, `must not be one of: ${disallowed.join(\", \")}`))\n        }\n        return Right(value as T)\n      }\n\n      // Date validations\n      if (rule === \"date\") {\n        const date = new Date(String(value))\n        if (isNaN(date.getTime())) {\n          return Left(TypedError.validation(\"value\", value, \"must be a valid date\"))\n        }\n        return Right(value as T)\n      }\n\n      if (rule === \"future\") {\n        const date = new Date(String(value))\n        if (isNaN(date.getTime()) || date <= new Date()) {\n          return Left(TypedError.validation(\"value\", value, \"must be a future date\"))\n        }\n        return Right(value as T)\n      }\n\n      if (rule === \"past\") {\n        const date = new Date(String(value))\n        if (isNaN(date.getTime()) || date >= new Date()) {\n          return Left(TypedError.validation(\"value\", value, \"must be a past date\"))\n        }\n        return Right(value as T)\n      }\n\n      // Default case\n      return Right(value as T)\n    }\n  },\n\n  /**\n   * Combine multiple validators\n   * @example\n   * const validator = Validation.combine(\n   *   Validation.rule<string>(\"required\"),\n   *   Validation.rule<string>(\"email\"),\n   *   Validation.rule<string>(\"maxLength:100\")\n   * )\n   */\n  combine: <T extends Type>(...validators: Validator<T>[]): Validator<T> => {\n    return (value: unknown): Either<TypedError<\"VALIDATION_FAILED\">, T> => {\n      for (const validator of validators) {\n        const result = validator(value)\n        if (result.isLeft()) {\n          return result\n        }\n      }\n      return Right(value as T)\n    }\n  },\n\n  /**\n   * Create a custom validator\n   * @example\n   * const isEven = Validation.custom<number>(\n   *   (value) => typeof value === \"number\" && value % 2 === 0,\n   *   \"must be an even number\"\n   * )\n   */\n  custom: <T extends Type>(predicate: (value: unknown) => boolean, errorMessage: string): Validator<T> => {\n    return (value: unknown): Either<TypedError<\"VALIDATION_FAILED\">, T> => {\n      if (!predicate(value)) {\n        return Left(TypedError.validation(\"value\", value, errorMessage))\n      }\n      return Right(value as T)\n    }\n  },\n\n  /**\n   * Validate a form with multiple fields\n   * @example\n   * const schema = {\n   *   name: Validation.rule<string>(\"required\"),\n   *   email: Validation.rule<string>(\"email\"),\n   *   age: Validation.rule<number>(\"min:18\")\n   * }\n   * const result = Validation.form(schema, { name: \"John\", email: \"john@example.com\", age: 25 })\n   */\n  form: <T extends Record<string, Type>>(\n    schema: { [K in keyof T]: Validator<T[K]> },\n    data: Record<string, unknown>,\n  ): FormValidation<T> => {\n    const errors: TypedError<\"VALIDATION_FAILED\">[] = []\n    const validated: Partial<T> = {}\n\n    for (const [field, validator] of Object.entries(schema)) {\n      const value = data[field]\n      const result = validator(value)\n\n      if (result.isLeft()) {\n        const error = result.fold(\n          (e: TypedError<\"VALIDATION_FAILED\">) => e,\n          () => {\n            throw new Error(\"Should not be left\")\n          },\n        )\n        // Update the error context with the field name\n        const fieldError = TypedError.validation(field, value, error.context.rule)\n        errors.push(fieldError)\n      } else {\n        validated[field as keyof T] = result.orThrow()\n      }\n    }\n\n    if (errors.length > 0) {\n      return Left(List(errors))\n    }\n\n    return Right(validated as T)\n  },\n}\n\nconst ValidationCompanion = {\n  ...ValidationConstructor,\n\n  /**\n   * Common pre-built validators\n   */\n  validators: {\n    email: ValidationConstructor.rule<string>(\"email\"),\n    url: ValidationConstructor.rule<string>(\"url\"),\n    uuid: ValidationConstructor.rule<string>(\"uuid\"),\n    required: ValidationConstructor.rule<string>(\"required\"),\n    numeric: ValidationConstructor.rule<number>(\"numeric\"),\n    positiveNumber: ValidationConstructor.combine(\n      ValidationConstructor.rule<number>(\"numeric\"),\n      ValidationConstructor.rule<number>(\"min:0\"),\n    ),\n    nonEmptyString: ValidationConstructor.combine(\n      ValidationConstructor.rule<string>(\"required\"),\n      ValidationConstructor.custom<string>(\n        (value) => typeof value === \"string\" && value.trim().length > 0,\n        \"must not be empty\",\n      ),\n    ),\n  },\n}\n\nexport const Validation = Object.assign(ValidationConstructor.rule, ValidationCompanion)\n","import type { Type } from \"@/types\"\n\n/**\n * Interface for operations that can fail with exceptions.\n * These methods should be used with care as they can throw at runtime.\n *\n * @interface Unsafe\n * @template T The type of value that can be extracted\n */\nexport interface Unsafe<T extends Type> {\n  /**\n   * Extract the value or throw an error\n   * @param error Optional custom error to throw. If not provided, uses type-appropriate default error\n   * @throws {Error} The specified error, container's error, or a sensible default\n   * @returns The contained value\n   */\n  orThrow(error?: Error): T\n}\n\n/**\n * Extractable type class for data structures that can extract their values\n * with various fallback strategies.\n *\n * This interface is implemented by Option, Either, and other types that\n * wrap values and need both safe and fallible extraction methods.\n *\n * Extends Unsafe to provide exception-throwing operations alongside safe alternatives.\n */\nexport interface Extractable<T extends Type> extends Unsafe<T> {\n  /**\n   * Returns the contained value or a default value\n   * @param defaultValue - The value to return if extraction fails\n   * @returns The contained value or defaultValue\n   */\n  orElse(defaultValue: T): T\n\n  /**\n   * Returns this container if it has a value, otherwise returns the alternative container\n   * @param alternative - The alternative container\n   * @returns This container or the alternative\n   */\n  or(alternative: Extractable<T>): Extractable<T>\n\n  /**\n   * Returns the contained value or null\n   * @returns The contained value or null\n   */\n  orNull(): T | null\n\n  /**\n   * Returns the contained value or undefined\n   * @returns The contained value or undefined\n   */\n  orUndefined(): T | undefined\n}\n\n/**\n * Type guard to check if a value implements Unsafe\n */\nexport function isUnsafe<T extends Type>(value: unknown): value is Unsafe<T> {\n  return value != null && typeof value === \"object\" && \"orThrow\" in value && typeof value.orThrow === \"function\"\n}\n\n/**\n * Type guard to check if a value implements Extractable\n */\nexport function isExtractable<T extends Type>(value: unknown): value is Extractable<T> {\n  return (\n    isUnsafe<T>(value) &&\n    \"orElse\" in value &&\n    typeof value.orElse === \"function\" &&\n    \"or\" in value &&\n    typeof value.or === \"function\" &&\n    \"orNull\" in value &&\n    typeof value.orNull === \"function\" &&\n    \"orUndefined\" in value &&\n    typeof value.orUndefined === \"function\"\n  )\n}\n","import type { Either } from \"@/either/Either\"\nimport { Left, Right } from \"@/either/Either\"\nimport type { Foldable } from \"@/foldable/Foldable\"\nimport { List } from \"@/list/List\"\nimport type { Option } from \"@/option/Option\"\nimport { None, Some } from \"@/option/Option\"\nimport type { Type } from \"@/types\"\n\n/**\n * Utility functions for working with Foldable data structures\n */\nexport const FoldableUtils = {\n  /**\n   * Converts a Foldable to an Option\n   *\n   * @param foldable - The foldable structure to convert\n   * @returns An Option containing the value, or None if empty\n   */\n  toOption: <A extends Type>(foldable: Foldable<A>): Option<A> => {\n    return foldable.fold(\n      () => None<A>(),\n      (a) => Some<A>(a),\n    )\n  },\n\n  /**\n   * Converts a Foldable to a List\n   *\n   * @param foldable - The foldable structure to convert\n   * @returns A List containing the value(s), or empty List if empty\n   */\n  toList: <A extends Type>(foldable: Foldable<A>): List<A> => {\n    return foldable.fold(\n      () => List<A>([]),\n      (a) => List<A>([a]),\n    )\n  },\n\n  /**\n   * Converts a Foldable to an Either\n   *\n   * @param foldable - The foldable structure to convert\n   * @param left - The value to use for Left if empty\n   * @returns Either.Right with the value if non-empty, or Either.Left with left if empty\n   */\n  toEither: <A extends Type, E>(foldable: Foldable<A>, left: E): Either<E, A> => {\n    return foldable.fold(\n      () => Left<E, A>(left),\n      (a) => Right<E, A>(a),\n    )\n  },\n\n  /**\n   * Checks if the Foldable is empty\n   *\n   * @param foldable - The foldable structure to check\n   * @returns true if empty, false otherwise\n   */\n  isEmpty: <A extends Type>(foldable: Foldable<A>): boolean => {\n    return foldable.fold(\n      () => true,\n      () => false,\n    )\n  },\n\n  /**\n   * Calculates the size of the Foldable\n   *\n   * @param foldable - The foldable structure to measure\n   * @returns The size (number of elements)\n   */\n  size: <A extends Type>(foldable: Foldable<A>): number => {\n    return foldable.fold(\n      () => 0,\n      () => 1,\n    )\n  },\n}\n","// import { Base } from \"@/core/base/Base\" // Temporarily commented to fix circular dependency\nimport type { Either } from \"@/either/Either\"\nimport { List } from \"@/list/List\"\nimport { Option } from \"@/option/Option\"\nimport type { Try } from \"@/try/Try\"\nimport type { Type } from \"@/types\"\n\n// No longer need to export DO_PROTOCOL since we're using Doable interface\n\n/**\n * Type function for representing higher-kinded types\n */\nexport type Kind<F, A> = F extends (arg: infer T) => infer R ? R : never\n\n/**\n * Type constructors for common Functype data types\n */\nexport type OptionKind = <A>(a: A) => Option<A>\nexport type ListKind = <A>(a: A) => List<A>\nexport type EitherKind<E> = <A>(a: A) => Either<E, A>\nexport type TryKind = <A>(a: A) => Try<A>\n\n/**\n * Generic container types for type-safe operations\n * @internal\n */\ntype Mappable<T> = {\n  map<U>(f: (value: T) => U): unknown\n}\n\n/**\n * @internal\n */\ntype Flattenable = {\n  flatten(): unknown\n}\n\n/**\n * @internal\n */\ntype FlatMappable<T> = {\n  flatMap<U>(f: (value: T) => unknown): unknown\n}\n\n/**\n * Type guard to check if a value is an Option\n */\nconst isOption = <T extends Type>(value: unknown): value is Option<T> & Mappable<T> & FlatMappable<T> => {\n  return (\n    value !== null &&\n    typeof value === \"object\" &&\n    ((value as Record<string, unknown>)._tag === \"Some\" || (value as Record<string, unknown>)._tag === \"None\")\n  )\n}\n\n/**\n * Type guard to check if a value is a List\n */\nconst isList = <T extends Type>(value: unknown): value is List<T> & Mappable<T> & Flattenable & FlatMappable<T> => {\n  return value !== null && typeof value === \"object\" && (value as Record<string, unknown>)._tag === \"List\"\n}\n\n/**\n * Type guard to check if a value is an Either\n */\nconst isEither = <E extends Type, A extends Type>(\n  value: unknown,\n): value is Either<E, A> & Mappable<A> & FlatMappable<A> => {\n  return (\n    value !== null &&\n    typeof value === \"object\" &&\n    ((value as Record<string, unknown>)._tag === \"Left\" || (value as Record<string, unknown>)._tag === \"Right\")\n  )\n}\n\n/**\n * Type guard to check if a value is a Try\n */\nconst isTry = <T extends Type>(value: unknown): value is Try<T> & Mappable<T> & FlatMappable<T> => {\n  return (\n    value !== null &&\n    typeof value === \"object\" &&\n    ((value as Record<string, unknown>)._tag === \"Success\" || (value as Record<string, unknown>)._tag === \"Failure\")\n  )\n}\n\n/**\n * Universal type that includes all potential return types from the HKT functions\n * Used to avoid 'any' usage which the linter prohibits\n */\nexport type UniversalContainer = Option<unknown> | List<unknown> | Either<unknown, unknown> | Try<unknown>\n\n/**\n * HKT provides utilities for working with higher-kinded types\n * This allows writing generic code that works across different\n * container types like Option, List, Either, etc.\n */\nexport const HKT = () => {\n  /**\n   * Maps over a value inside a container, using the container's own map function\n   */\n  const map = <F, A, B>(fa: unknown, f: (a: A) => B): unknown => {\n    if (isOption<A & Type>(fa)) {\n      return fa.map((value: A & Type) => f(value))\n    }\n    if (isList<A & Type>(fa)) {\n      return fa.map((value: A & Type) => f(value))\n    }\n    if (isEither<unknown & Type, A & Type>(fa)) {\n      return fa.map((value: A & Type) => f(value))\n    }\n    if (isTry<A & Type>(fa)) {\n      return fa.map((value: A & Type) => f(value))\n    }\n    throw new Error(`Unsupported functor type: ${JSON.stringify(fa)}`)\n  }\n\n  /**\n   * Flattens a nested container (container of container) into a single container\n   */\n  const flatten = <F, A>(ffa: unknown): unknown => {\n    if (isOption<unknown>(ffa)) {\n      return ffa.orThrow()\n    }\n    if (isList<unknown>(ffa)) {\n      // Special case for nested lists - we need to properly flatten them to match the test's expectation\n      const items = ffa.toArray()\n      if (items.length > 0 && isList(items[0])) {\n        const allValues: unknown[] = []\n        for (const item of items) {\n          if (isList(item)) {\n            allValues.push(...(item as List<unknown>).toArray())\n          }\n        }\n        return List(allValues)\n      }\n      return ffa.flatten()\n    }\n    if (isEither<unknown, unknown>(ffa)) {\n      if (ffa.isRight()) {\n        return ffa.fold(\n          () => null,\n          (x) => x,\n        )\n      }\n      return ffa\n    }\n    if (isTry<unknown>(ffa)) {\n      if (ffa.isSuccess()) {\n        return ffa.orThrow()\n      }\n      return ffa\n    }\n    throw new Error(`Unsupported functor type for flatten: ${JSON.stringify(ffa)}`)\n  }\n\n  /**\n   * First applies the function to the value inside the container, then flattens the result\n   */\n  const flatMap = <F, A, B>(fa: unknown, f: (a: A) => unknown): unknown => {\n    if (isOption<A & Type>(fa)) {\n      return fa.flatMap((value: A & Type) => f(value))\n    }\n    if (isList<A & Type>(fa)) {\n      return fa.flatMap((value: A & Type) => f(value))\n    }\n    if (isEither<unknown & Type, A & Type>(fa)) {\n      return fa.flatMap((value: A & Type) => f(value))\n    }\n    if (isTry<A & Type>(fa)) {\n      return fa.flatMap((value: A & Type) => f(value))\n    }\n    throw new Error(`Unsupported functor type for flatMap: ${JSON.stringify(fa)}`)\n  }\n\n  /**\n   * Applies a function inside a container to a value inside another container\n   */\n  const ap = <F, A, B>(ff: unknown, fa: unknown): unknown => {\n    if (isOption<((a: A) => B) & Type>(ff) && isOption<A & Type>(fa)) {\n      return ff.flatMap((f: (a: A) => B) => fa.map((value: A & Type) => f(value)))\n    }\n    if (isList<((a: A) => B) & Type>(ff) && isList<A & Type>(fa)) {\n      return ff.flatMap((f: (a: A) => B) => fa.map((value: A & Type) => f(value)))\n    }\n    if (isEither<unknown & Type, ((a: A) => B) & Type>(ff) && isEither<unknown & Type, A & Type>(fa)) {\n      return ff.flatMap((f: (a: A) => B) => fa.map((value: A & Type) => f(value)))\n    }\n    if (isTry<((a: A) => B) & Type>(ff) && isTry<A & Type>(fa)) {\n      return ff.flatMap((f: (a: A) => B) => fa.map((value: A & Type) => f(value)))\n    }\n    throw new Error(`Unsupported functor type for ap: ${JSON.stringify(ff)}`)\n  }\n\n  /**\n   * Sequences a container of containers into a container of container\n   * (e.g., Option<List<A>> to List<Option<A>>)\n   */\n  const sequence = <F, G, A>(fga: unknown): unknown => {\n    // Handle option of container\n    if (isOption<unknown>(fga)) {\n      const optionValue = fga as Option<unknown>\n\n      // If None, return container with None\n      if (optionValue.isEmpty) {\n        // Testing with list\n        return List([Option.none()])\n      }\n\n      // Option is Some\n      const inner = optionValue.orThrow()\n      if (isList<unknown>(inner)) {\n        return inner.map((a) => Option(a))\n      }\n\n      throw new Error(`Unsupported inner container type for sequence`)\n    }\n\n    // Handle list of containers\n    if (isList<unknown>(fga)) {\n      const listValue = fga as List<unknown>\n      const items = listValue.toArray()\n\n      // Empty list case\n      if (items.length === 0) {\n        return Option.none()\n      }\n\n      const first = items[0]\n      if (isOption<unknown>(first)) {\n        // List of Options\n        // Check if any option is None\n        for (const item of items) {\n          const opt = item as Option<unknown>\n          if (opt.isEmpty) {\n            return Option.none()\n          }\n        }\n\n        // All options are Some, transform to Option of List\n        const values = items.map((item) => {\n          const opt = item as Option<unknown>\n          return opt.orThrow()\n        })\n\n        return Option(List(values))\n      }\n\n      throw new Error(`Unsupported inner container type for sequence`)\n    }\n\n    throw new Error(`Unsupported outer container type for sequence: ${JSON.stringify(fga)}`)\n  }\n\n  /**\n   * Transforms each element in a container and then sequences the results\n   */\n  const traverse = <F, G, A, B>(fa: unknown, f: (a: A) => unknown): unknown => {\n    return sequence(map<F, A, unknown>(fa, (value: A) => f(value)))\n  }\n\n  return {\n    // ...Base(\"HKT\", { // Temporarily replaced to fix circular dependency\n    _tag: \"HKT\",\n    map,\n    flatten,\n    flatMap,\n    ap,\n    sequence,\n    traverse,\n    // }),\n    _type: \"HKT\",\n  }\n}\n\n// Static methods for HKT operations\nconst instance = HKT()\n\nHKT.map = <F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => B): unknown => instance.map(fa, f)\n\nHKT.flatten = <F = unknown, A = unknown>(ffa: unknown): unknown => instance.flatten(ffa)\n\nHKT.flatMap = <F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown =>\n  instance.flatMap(fa, f)\n\nHKT.ap = <F = unknown, A = unknown, B = unknown>(ff: unknown, fa: unknown): unknown => instance.ap(ff, fa)\n\nHKT.sequence = <F = unknown, G = unknown, A = unknown>(fga: unknown): unknown => instance.sequence(fga)\n\nHKT.traverse = <F = unknown, G = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown =>\n  instance.traverse(fa, f)\n\n// Export type guards\nHKT.isOption = isOption\nHKT.isList = isList\nHKT.isEither = isEither\nHKT.isTry = isTry\n","import { Companion } from \"@/companion/Companion\"\n\nexport type Identity<T> = {\n  id: T\n  isSame?: (other: Identity<T>) => boolean\n}\n\nconst IdentityConstructor = <T>(value: T): Identity<T> => {\n  const isSame = (other: Identity<T>): boolean => {\n    return other.id === value\n  }\n  return {\n    id: value,\n    isSame,\n  }\n}\n\nconst IdentityCompanion = {\n  /**\n   * Creates an Identity. Alias for Identity constructor.\n   * @param value - The value to wrap\n   * @returns Identity instance\n   */\n  of: <T>(value: T) => IdentityConstructor(value),\n\n  /**\n   * Creates an Identity. Same as of.\n   * @param value - The value to wrap\n   * @returns Identity instance\n   */\n  pure: <T>(value: T) => IdentityConstructor(value),\n}\n\nexport const Identity = Companion(IdentityConstructor, IdentityCompanion)\n","import type { Option } from \"@/option/Option\"\nimport { None, Some } from \"@/option/Option\"\nimport type { Type } from \"@/types\"\n\nimport type { Tag } from \"./Tag\"\n\n/**\n * Context module - service container for dependency injection.\n * @module Context\n * @category IO\n *\n * Context is an immutable container that holds service implementations\n * identified by their Tags.\n */\n\n/**\n * Context holds service implementations for dependency injection.\n * It's an immutable container that maps Tags to their implementations.\n *\n * @typeParam R - The services contained in this context (intersection type)\n *\n * @example\n * ```typescript\n * const ctx = Context.empty()\n *   .add(Logger, consoleLogger)\n *   .add(Database, pgDatabase)\n *\n * // Access a service\n * const logger = ctx.get(Logger) // Option<Logger>\n * const loggerUnsafe = ctx.unsafeGet(Logger) // Logger (throws if missing)\n * ```\n */\nexport interface Context<R extends Type> {\n  /**\n   * Type brand\n   * @internal\n   */\n  readonly _tag: \"Context\"\n\n  /**\n   * Phantom type for requirements\n   * @internal\n   */\n  readonly _R?: R\n\n  /**\n   * Internal service map\n   * @internal\n   */\n  readonly services: ReadonlyMap<string, Type>\n\n  /**\n   * Gets a service from the context.\n   * @param tag - The tag identifying the service\n   * @returns Some(service) if found, None otherwise\n   */\n  get<S extends Type>(tag: Tag<S>): Option<S>\n\n  /**\n   * Gets a service from the context, throwing if not found.\n   * @param tag - The tag identifying the service\n   * @returns The service\n   * @throws Error if service not found\n   */\n  unsafeGet<S extends Type>(tag: Tag<S>): S\n\n  /**\n   * Checks if a service exists in the context.\n   * @param tag - The tag to check\n   * @returns true if the service exists\n   */\n  has<S extends Type>(tag: Tag<S>): boolean\n\n  /**\n   * Adds a service to the context, returning a new context.\n   * @param tag - The tag for the service\n   * @param service - The service implementation\n   * @returns A new context with the service added\n   */\n  add<S extends Type>(tag: Tag<S>, service: S): Context<R & S>\n\n  /**\n   * Merges another context into this one.\n   * @param other - The context to merge\n   * @returns A new context with all services from both\n   */\n  merge<R2 extends Type>(other: Context<R2>): Context<R & R2>\n\n  /**\n   * Returns the number of services in this context.\n   */\n  readonly size: number\n\n  /**\n   * String representation\n   */\n  toString(): string\n}\n\n/**\n * Creates a Context from a services map\n */\nconst createContext = <R extends Type>(services: ReadonlyMap<string, Type>): Context<R> => ({\n  _tag: \"Context\",\n  services,\n\n  get<S extends Type>(tag: Tag<S>): Option<S> {\n    const service = services.get(tag.id)\n    return service !== undefined ? Some(service as S) : None()\n  },\n\n  unsafeGet<S extends Type>(tag: Tag<S>): S {\n    const service = services.get(tag.id)\n    if (service === undefined) {\n      throw new Error(`Service not found: ${tag.id}`)\n    }\n    return service as S\n  },\n\n  has<S extends Type>(tag: Tag<S>): boolean {\n    return services.has(tag.id)\n  },\n\n  add<S extends Type>(tag: Tag<S>, service: S): Context<R & S> {\n    const newServices = new Map(services)\n    newServices.set(tag.id, service)\n    return createContext(newServices)\n  },\n\n  merge<R2 extends Type>(other: Context<R2>): Context<R & R2> {\n    const newServices = new Map(services)\n    for (const [key, value] of other.services) {\n      newServices.set(key, value)\n    }\n    return createContext(newServices)\n  },\n\n  get size() {\n    return services.size\n  },\n\n  toString() {\n    const keys = Array.from(services.keys()).join(\", \")\n    return `Context(${keys})`\n  },\n})\n\n/**\n * Context companion object with utility methods\n */\nexport const Context = {\n  /**\n   * Creates an empty context with no services.\n   */\n  empty: <R extends Type = never>(): Context<R> => createContext(new Map()),\n\n  /**\n   * Creates a context with a single service.\n   * @param tag - The tag for the service\n   * @param service - The service implementation\n   */\n  make: <S extends Type>(tag: Tag<S>, service: S): Context<S> => {\n    const services = new Map<string, Type>()\n    services.set(tag.id, service)\n    return createContext(services)\n  },\n\n  /**\n   * Checks if a value is a Context.\n   */\n  isContext: <R extends Type>(value: unknown): value is Context<R> =>\n    typeof value === \"object\" && value !== null && (value as Context<R>)._tag === \"Context\",\n}\n\n/**\n * Type helper to extract requirements from a Context\n */\nexport type ContextServices<C> = C extends Context<infer R> ? R : never\n\n/**\n * Type helper to check if a context provides a service\n */\nexport type HasService<C, S> = S extends ContextServices<C> ? true : false\n","import stringify from \"safe-stable-stringify\"\n\nimport { Companion } from \"@/companion/Companion\"\nimport type { Either } from \"@/either/Either\"\nimport { Left, Right } from \"@/either/Either\"\nimport type { Option } from \"@/option/Option\"\nimport { None, Some } from \"@/option/Option\"\nimport type { Type } from \"@/types\"\n\n/**\n * Exit type module - represents the outcome of running an IO effect.\n * @module Exit\n * @category IO\n */\n\n/**\n * Possible outcome types for an Exit\n */\nexport type ExitTag = \"Success\" | \"Failure\" | \"Interrupted\"\n\n/**\n * Exit represents the outcome of running an IO effect.\n * - Success: The effect completed successfully with a value\n * - Failure: The effect failed with a typed error\n * - Interrupted: The effect was cancelled/interrupted\n */\nexport interface Exit<E extends Type, A extends Type> {\n  readonly _tag: ExitTag\n\n  /**\n   * Type guard to check if this is a Success\n   */\n  isSuccess(): this is Exit<E, A> & { readonly _tag: \"Success\"; value: A }\n\n  /**\n   * Type guard to check if this is a Failure\n   */\n  isFailure(): this is Exit<E, A> & { readonly _tag: \"Failure\"; error: E }\n\n  /**\n   * Type guard to check if this is Interrupted\n   */\n  isInterrupted(): this is Exit<E, A> & { readonly _tag: \"Interrupted\"; fiberId: string }\n\n  /**\n   * Maps the success value\n   */\n  map<B extends Type>(f: (a: A) => B): Exit<E, B>\n\n  /**\n   * Maps the error value\n   */\n  mapError<E2 extends Type>(f: (e: E) => E2): Exit<E2, A>\n\n  /**\n   * Maps both error and success values\n   */\n  mapBoth<E2 extends Type, B extends Type>(onError: (e: E) => E2, onSuccess: (a: A) => B): Exit<E2, B>\n\n  /**\n   * Flat maps the success value\n   */\n  flatMap<B extends Type>(f: (a: A) => Exit<E, B>): Exit<E, B>\n\n  /**\n   * Pattern matches over the Exit\n   */\n  fold<T>(onFailure: (e: E) => T, onSuccess: (a: A) => T, onInterrupted?: (fiberId: string) => T): T\n\n  /**\n   * Pattern matches over the Exit with object patterns\n   */\n  match<T>(patterns: { Success: (value: A) => T; Failure: (error: E) => T; Interrupted: (fiberId: string) => T }): T\n\n  /**\n   * Returns the success value or throws\n   */\n  orThrow(): A\n\n  /**\n   * Returns the success value or a default\n   */\n  orElse(defaultValue: A): A\n\n  /**\n   * Converts to Option (Some for Success, None otherwise)\n   */\n  toOption(): Option<A>\n\n  /**\n   * Converts to Either (Right for Success, Left for Failure)\n   * Throws if Interrupted\n   */\n  toEither(): Either<E, A>\n\n  /**\n   * Returns the raw value for inspection\n   */\n  toValue(): { _tag: ExitTag; value?: A; error?: E; fiberId?: string }\n\n  /**\n   * String representation\n   */\n  toString(): string\n\n  /**\n   * JSON serialization\n   */\n  toJSON(): { _tag: ExitTag; value?: A; error?: E; fiberId?: string }\n}\n\n/**\n * Creates a Success Exit\n */\nconst SuccessExit = <E extends Type, A extends Type>(value: A): Exit<E, A> => ({\n  _tag: \"Success\",\n\n  isSuccess(): this is Exit<E, A> & { readonly _tag: \"Success\"; value: A } {\n    return true\n  },\n\n  isFailure(): this is Exit<E, A> & { readonly _tag: \"Failure\"; error: E } {\n    return false\n  },\n\n  isInterrupted(): this is Exit<E, A> & { readonly _tag: \"Interrupted\"; fiberId: string } {\n    return false\n  },\n\n  map<B extends Type>(f: (a: A) => B): Exit<E, B> {\n    return SuccessExit(f(value))\n  },\n\n  mapError<E2 extends Type>(_f: (e: E) => E2): Exit<E2, A> {\n    return SuccessExit(value)\n  },\n\n  mapBoth<E2 extends Type, B extends Type>(_onError: (e: E) => E2, onSuccess: (a: A) => B): Exit<E2, B> {\n    return SuccessExit(onSuccess(value))\n  },\n\n  flatMap<B extends Type>(f: (a: A) => Exit<E, B>): Exit<E, B> {\n    return f(value)\n  },\n\n  fold<T>(_onFailure: (e: E) => T, onSuccess: (a: A) => T, _onInterrupted?: (fiberId: string) => T): T {\n    return onSuccess(value)\n  },\n\n  match<T>(patterns: { Success: (value: A) => T; Failure: (error: E) => T; Interrupted: (fiberId: string) => T }): T {\n    return patterns.Success(value)\n  },\n\n  orThrow(): A {\n    return value\n  },\n\n  orElse(_defaultValue: A): A {\n    return value\n  },\n\n  toOption(): Option<A> {\n    return Some(value)\n  },\n\n  toEither(): Either<E, A> {\n    return Right(value)\n  },\n\n  toValue() {\n    return { _tag: \"Success\" as const, value }\n  },\n\n  toString() {\n    return `Exit.Success(${stringify(value)})`\n  },\n\n  toJSON() {\n    return { _tag: \"Success\" as const, value }\n  },\n})\n\n/**\n * Creates a Failure Exit\n */\nconst FailureExit = <E extends Type, A extends Type>(error: E): Exit<E, A> => ({\n  _tag: \"Failure\",\n\n  isSuccess(): this is Exit<E, A> & { readonly _tag: \"Success\"; value: A } {\n    return false\n  },\n\n  isFailure(): this is Exit<E, A> & { readonly _tag: \"Failure\"; error: E } {\n    return true\n  },\n\n  isInterrupted(): this is Exit<E, A> & { readonly _tag: \"Interrupted\"; fiberId: string } {\n    return false\n  },\n\n  map<B extends Type>(_f: (a: A) => B): Exit<E, B> {\n    return FailureExit(error)\n  },\n\n  mapError<E2 extends Type>(f: (e: E) => E2): Exit<E2, A> {\n    return FailureExit(f(error))\n  },\n\n  mapBoth<E2 extends Type, B extends Type>(onError: (e: E) => E2, _onSuccess: (a: A) => B): Exit<E2, B> {\n    return FailureExit(onError(error))\n  },\n\n  flatMap<B extends Type>(_f: (a: A) => Exit<E, B>): Exit<E, B> {\n    return FailureExit(error)\n  },\n\n  fold<T>(onFailure: (e: E) => T, _onSuccess: (a: A) => T, _onInterrupted?: (fiberId: string) => T): T {\n    return onFailure(error)\n  },\n\n  match<T>(patterns: { Success: (value: A) => T; Failure: (error: E) => T; Interrupted: (fiberId: string) => T }): T {\n    return patterns.Failure(error)\n  },\n\n  orThrow(): A {\n    throw error\n  },\n\n  orElse(defaultValue: A): A {\n    return defaultValue\n  },\n\n  toOption(): Option<A> {\n    return None()\n  },\n\n  toEither(): Either<E, A> {\n    return Left(error)\n  },\n\n  toValue() {\n    return { _tag: \"Failure\" as const, error }\n  },\n\n  toString() {\n    return `Exit.Failure(${stringify(error)})`\n  },\n\n  toJSON() {\n    return { _tag: \"Failure\" as const, error }\n  },\n})\n\n/**\n * Creates an Interrupted Exit\n */\nconst InterruptedExit = <E extends Type, A extends Type>(fiberId: string): Exit<E, A> => ({\n  _tag: \"Interrupted\",\n\n  isSuccess(): this is Exit<E, A> & { readonly _tag: \"Success\"; value: A } {\n    return false\n  },\n\n  isFailure(): this is Exit<E, A> & { readonly _tag: \"Failure\"; error: E } {\n    return false\n  },\n\n  isInterrupted(): this is Exit<E, A> & { readonly _tag: \"Interrupted\"; fiberId: string } {\n    return true\n  },\n\n  map<B extends Type>(_f: (a: A) => B): Exit<E, B> {\n    return InterruptedExit(fiberId)\n  },\n\n  mapError<E2 extends Type>(_f: (e: E) => E2): Exit<E2, A> {\n    return InterruptedExit(fiberId)\n  },\n\n  mapBoth<E2 extends Type, B extends Type>(_onError: (e: E) => E2, _onSuccess: (a: A) => B): Exit<E2, B> {\n    return InterruptedExit(fiberId)\n  },\n\n  flatMap<B extends Type>(_f: (a: A) => Exit<E, B>): Exit<E, B> {\n    return InterruptedExit(fiberId)\n  },\n\n  fold<T>(_onFailure: (e: E) => T, _onSuccess: (a: A) => T, onInterrupted?: (fiberId: string) => T): T {\n    if (onInterrupted) {\n      return onInterrupted(fiberId)\n    }\n    throw new Error(`Effect was interrupted: ${fiberId}`)\n  },\n\n  match<T>(patterns: { Success: (value: A) => T; Failure: (error: E) => T; Interrupted: (fiberId: string) => T }): T {\n    return patterns.Interrupted(fiberId)\n  },\n\n  orThrow(): A {\n    throw new Error(`Effect was interrupted: ${fiberId}`)\n  },\n\n  orElse(defaultValue: A): A {\n    return defaultValue\n  },\n\n  toOption(): Option<A> {\n    return None()\n  },\n\n  toEither(): Either<E, A> {\n    throw new Error(`Cannot convert Interrupted Exit to Either: ${fiberId}`)\n  },\n\n  toValue() {\n    return { _tag: \"Interrupted\" as const, fiberId }\n  },\n\n  toString() {\n    return `Exit.Interrupted(${fiberId})`\n  },\n\n  toJSON() {\n    return { _tag: \"Interrupted\" as const, fiberId }\n  },\n})\n\n/**\n * Exit companion methods\n */\nconst ExitCompanion = {\n  /**\n   * Creates a Success Exit\n   */\n  succeed: <E extends Type, A extends Type>(value: A): Exit<E, A> => SuccessExit(value),\n\n  /**\n   * Creates a Failure Exit\n   */\n  fail: <E extends Type, A extends Type>(error: E): Exit<E, A> => FailureExit(error),\n\n  /**\n   * Creates an Interrupted Exit with a fiber ID\n   */\n  interrupt: <E extends Type, A extends Type>(fiberId: string): Exit<E, A> => InterruptedExit(fiberId),\n\n  /**\n   * Creates an Interrupted Exit with a default fiber ID\n   */\n  interrupted: <E extends Type, A extends Type>(): Exit<E, A> => InterruptedExit(\"interrupted\"),\n\n  /**\n   * Type guard for Success\n   */\n  isSuccess: <E extends Type, A extends Type>(\n    exit: Exit<E, A>,\n  ): exit is Exit<E, A> & { readonly _tag: \"Success\"; value: A } => exit.isSuccess(),\n\n  /**\n   * Type guard for Failure\n   */\n  isFailure: <E extends Type, A extends Type>(\n    exit: Exit<E, A>,\n  ): exit is Exit<E, A> & { readonly _tag: \"Failure\"; error: E } => exit.isFailure(),\n\n  /**\n   * Type guard for Interrupted\n   */\n  isInterrupted: <E extends Type, A extends Type>(\n    exit: Exit<E, A>,\n  ): exit is Exit<E, A> & { readonly _tag: \"Interrupted\"; fiberId: string } => exit.isInterrupted(),\n\n  /**\n   * Creates an Exit from an Either\n   */\n  fromEither: <E extends Type, A extends Type>(either: Either<E, A>): Exit<E, A> =>\n    either.isRight() ? SuccessExit(either.value as A) : FailureExit(either.value as E),\n\n  /**\n   * Creates an Exit from an Option\n   */\n  fromOption: <A extends Type>(option: Option<A>, onNone: () => unknown): Exit<unknown, A> =>\n    option.isSome() ? SuccessExit(option.value) : FailureExit(onNone()),\n\n  /**\n   * Combines two Exits, keeping the first failure or combining successes\n   */\n  zip: <E extends Type, A extends Type, B extends Type>(\n    exitA: Exit<E, A>,\n    exitB: Exit<E, B>,\n  ): Exit<E, readonly [A, B]> => {\n    if (exitA.isInterrupted()) return exitA as unknown as Exit<E, readonly [A, B]>\n    if (exitB.isInterrupted()) return exitB as unknown as Exit<E, readonly [A, B]>\n    if (exitA.isFailure()) return exitA as unknown as Exit<E, readonly [A, B]>\n    if (exitB.isFailure()) return exitB as unknown as Exit<E, readonly [A, B]>\n    return SuccessExit([exitA.orThrow(), exitB.orThrow()] as const)\n  },\n\n  /**\n   * Collects all Exits into an Exit of array\n   */\n  all: <E extends Type, A extends Type>(exits: readonly Exit<E, A>[]): Exit<E, readonly A[]> => {\n    const results: A[] = []\n    for (const exit of exits) {\n      if (exit.isInterrupted()) return exit as unknown as Exit<E, readonly A[]>\n      if (exit.isFailure()) return exit as unknown as Exit<E, readonly A[]>\n      results.push(exit.orThrow())\n    }\n    return SuccessExit(results as readonly A[])\n  },\n}\n\n/**\n * Exit constructor - creates an Exit from a value (defaults to Success)\n */\nconst ExitConstructor = <E extends Type, A extends Type>(value: A): Exit<E, A> => SuccessExit(value)\n\n/**\n * Exit type for representing effect outcomes.\n *\n * @example\n * ```typescript\n * const success = Exit.succeed(42)\n * const failure = Exit.fail(new Error(\"oops\"))\n * const interrupted = Exit.interrupt(\"fiber-123\")\n *\n * success.fold(\n *   (err) => console.error(err),\n *   (value) => console.log(value),\n *   (fiberId) => console.log(\"interrupted:\", fiberId)\n * )\n * ```\n */\nexport const Exit = Companion(ExitConstructor, ExitCompanion)\n","import stringify from \"safe-stable-stringify\"\n\nimport { Companion } from \"@/companion/Companion\"\nimport type { Either } from \"@/either/Either\"\nimport { Left, Right } from \"@/either/Either\"\nimport type { Option } from \"@/option/Option\"\nimport { None, Some } from \"@/option/Option\"\nimport { Try } from \"@/try/Try\"\nimport type { Type } from \"@/types\"\n\nimport type { Context } from \"./Context\"\nimport { Context as ContextCompanion } from \"./Context\"\nimport type { Exit as ExitType } from \"./Exit\"\nimport { Exit } from \"./Exit\"\nimport type { Layer } from \"./Layer\"\nimport type { Tag, TagService } from \"./Tag\"\n\n/**\n * Internal utility for type coercion in the effect interpreter.\n * Used when TypeScript's type system can't express the actual type relationship.\n * This is a common pattern in effect libraries (Effect-TS uses similar internally).\n * @internal\n */\nconst unsafeCoerce = <A, B>(a: A): B => a as unknown as B\n\n/**\n * Error thrown when an effect times out.\n */\n// eslint-disable-next-line functional/no-classes\nexport class TimeoutError extends Error {\n  readonly _tag = \"TimeoutError\" as const\n  constructor(\n    readonly duration: number,\n    message?: string,\n  ) {\n    super(message ?? `Effect timed out after ${duration}ms`)\n    this.name = \"TimeoutError\"\n  }\n}\n\n/**\n * Error thrown when an effect is interrupted.\n */\n// eslint-disable-next-line functional/no-classes\nexport class InterruptedError extends Error {\n  readonly _tag = \"InterruptedError\" as const\n  constructor(message?: string) {\n    super(message ?? \"Effect was interrupted\")\n    this.name = \"InterruptedError\"\n  }\n}\n\n/**\n * IO Effect type module - a lazy, composable effect type with typed errors.\n * @module IO\n * @category IO\n *\n * IO<R, E, A> represents an effectful computation that:\n * - Requires environment R to run\n * - May fail with error E\n * - Produces value A on success\n *\n * Key features:\n * - Lazy execution (nothing runs until explicitly executed)\n * - Unified sync/async API\n * - Typed errors at compile time\n * - Composable via map/flatMap\n */\n\n/**\n * Internal effect representation types\n */\ntype IOEffect<R, E, A> =\n  | { readonly _tag: \"Sync\"; readonly thunk: () => A }\n  | { readonly _tag: \"Async\"; readonly thunk: () => Promise<A> }\n  | { readonly _tag: \"Auto\"; readonly thunk: () => A | Promise<A> }\n  | { readonly _tag: \"Succeed\"; readonly value: A }\n  | { readonly _tag: \"Fail\"; readonly error: E }\n  | { readonly _tag: \"Die\"; readonly defect: unknown }\n  | { readonly _tag: \"Interrupt\" }\n  | { readonly _tag: \"FlatMap\"; readonly effect: IO<R, E, unknown>; readonly f: (a: unknown) => IO<R, E, A> }\n  | { readonly _tag: \"Map\"; readonly effect: IO<R, E, unknown>; readonly f: (a: unknown) => A }\n  | { readonly _tag: \"MapError\"; readonly effect: IO<R, unknown, A>; readonly f: (e: unknown) => E }\n  | { readonly _tag: \"Recover\"; readonly effect: IO<R, E, A>; readonly fallback: A }\n  | { readonly _tag: \"RecoverWith\"; readonly effect: IO<R, E, A>; readonly f: (e: E) => IO<R, E, A> }\n  | {\n      readonly _tag: \"Fold\"\n      readonly effect: IO<R, E, unknown>\n      readonly onFailure: (e: E) => A\n      readonly onSuccess: (a: unknown) => A\n    }\n  | {\n      readonly _tag: \"Bracket\"\n      readonly acquire: IO<R, E, unknown>\n      readonly use: (a: unknown) => IO<R, E, A>\n      readonly release: (a: unknown) => IO<R, never, void>\n    }\n  | {\n      readonly _tag: \"Race\"\n      readonly effects: readonly IO<R, E, A>[]\n    }\n  | {\n      readonly _tag: \"Timeout\"\n      readonly effect: IO<R, E, A>\n      readonly duration: number\n    }\n  | { readonly _tag: \"Service\"; readonly tag: Tag<A> }\n  | { readonly _tag: \"ProvideContext\"; readonly effect: IO<R, E, A>; readonly context: Context<R> }\n\n/**\n * IO<R, E, A> represents a lazy, composable effect.\n *\n * @typeParam R - Requirements (environment/dependencies needed to run)\n * @typeParam E - Error type (typed failures)\n * @typeParam A - Success type (value produced on success)\n */\nexport interface IO<R extends Type, E extends Type, A extends Type> {\n  /**\n   * Internal effect representation\n   * @internal\n   */\n  readonly _effect: IOEffect<R, E, A>\n\n  /**\n   * Phantom type for requirements\n   * @internal\n   */\n  readonly _R?: R\n\n  /**\n   * Phantom type for error\n   * @internal\n   */\n  readonly _E?: E\n\n  /**\n   * Phantom type for success\n   * @internal\n   */\n  readonly _A?: A\n\n  // ============================================\n  // Core Operations\n  // ============================================\n\n  /**\n   * Transforms the success value.\n   * @param f - Function to apply to the success value\n   * @returns New IO with transformed value\n   */\n  map<B extends Type>(f: (a: A) => B): IO<R, E, B>\n\n  /**\n   * Chains another IO effect based on the success value.\n   * @param f - Function returning next IO effect\n   * @returns New IO with combined effects\n   */\n  flatMap<R2 extends Type, E2 extends Type, B extends Type>(f: (a: A) => IO<R2, E2, B>): IO<R | R2, E | E2, B>\n\n  /**\n   * Applies a side effect without changing the value.\n   * @param f - Side effect function\n   * @returns Same IO for chaining\n   */\n  tap(f: (a: A) => void): IO<R, E, A>\n\n  /**\n   * Applies an effectful side effect without changing the value.\n   * @param f - Function returning IO for side effect\n   * @returns Same value after running side effect\n   */\n  tapEffect<R2 extends Type, E2 extends Type, B extends Type>(f: (a: A) => IO<R2, E2, B>): IO<R | R2, E | E2, A>\n\n  // ============================================\n  // Error Handling\n  // ============================================\n\n  /**\n   * Transforms the error value.\n   * @param f - Function to apply to the error\n   * @returns New IO with transformed error\n   */\n  mapError<E2 extends Type>(f: (e: E) => E2): IO<R, E2, A>\n\n  /**\n   * Recovers from any error with a fallback value.\n   * @param fallback - Value to use on error\n   * @returns New IO that never fails\n   */\n  recover<B extends Type>(fallback: B): IO<R, never, A | B>\n\n  /**\n   * Recovers from error by running another effect.\n   * @param f - Function returning recovery effect\n   * @returns New IO with error handling\n   */\n  recoverWith<R2 extends Type, E2 extends Type, B extends Type>(f: (e: E) => IO<R2, E2, B>): IO<R | R2, E2, A | B>\n\n  /**\n   * Pattern matches on success and failure.\n   * @param onFailure - Handler for failures\n   * @param onSuccess - Handler for successes\n   * @returns New IO with handled result\n   */\n  fold<B extends Type>(onFailure: (e: E) => B, onSuccess: (a: A) => B): IO<R, never, B>\n\n  /**\n   * Pattern matches with object pattern syntax.\n   */\n  match<B extends Type>(patterns: { failure: (e: E) => B; success: (a: A) => B }): IO<R, never, B>\n\n  /**\n   * Catches errors with a specific tag and handles them.\n   * @param tag - The error tag to catch\n   * @param handler - Handler for the caught error\n   */\n  catchTag<K extends E extends { _tag: string } ? E[\"_tag\"] : never, R2 extends Type, E2 extends Type, B extends Type>(\n    tag: K,\n    handler: (e: Extract<E, { _tag: K }>) => IO<R2, E2, B>,\n  ): IO<R | R2, Exclude<E, { _tag: K }> | E2, A | B>\n\n  /**\n   * Catches all errors (alias for recoverWith).\n   */\n  catchAll<R2 extends Type, E2 extends Type, B extends Type>(handler: (e: E) => IO<R2, E2, B>): IO<R | R2, E2, A | B>\n\n  /**\n   * Retries the effect up to n times on failure.\n   * @param n - Maximum number of retries\n   */\n  retry(n: number): IO<R, E, A>\n\n  /**\n   * Retries the effect with a delay between attempts.\n   * @param n - Maximum number of retries\n   * @param delayMs - Delay between retries in milliseconds\n   */\n  retryWithDelay(n: number, delayMs: number): IO<R, E, A>\n\n  // ============================================\n  // Combinators\n  // ============================================\n\n  /**\n   * Sequences two IOs, keeping the second value.\n   */\n  zipRight<R2 extends Type, E2 extends Type, B extends Type>(that: IO<R2, E2, B>): IO<R | R2, E | E2, B>\n\n  /**\n   * Sequences two IOs, keeping the first value.\n   */\n  zipLeft<R2 extends Type, E2 extends Type, B extends Type>(that: IO<R2, E2, B>): IO<R | R2, E | E2, A>\n\n  /**\n   * Zips two IOs into a tuple.\n   */\n  zip<R2 extends Type, E2 extends Type, B extends Type>(that: IO<R2, E2, B>): IO<R | R2, E | E2, readonly [A, B]>\n\n  /**\n   * Flattens a nested IO.\n   */\n  flatten<R2 extends Type, E2 extends Type, B extends Type>(this: IO<R, E, IO<R2, E2, B>>): IO<R | R2, E | E2, B>\n\n  // ============================================\n  // Dependency Injection\n  // ============================================\n\n  /**\n   * Provides a context to satisfy the requirements of this effect.\n   * @param context - The context containing required services\n   */\n  provideContext<R2 extends R>(context: Context<R2>): IO<Exclude<R, R2>, E, A>\n\n  /**\n   * Provides a single service to satisfy part of the requirements.\n   * @param tag - The service tag\n   * @param service - The service implementation\n   */\n  provideService<S extends Type>(tag: Tag<S>, service: S): IO<Exclude<R, S>, E, A>\n\n  /**\n   * Provides services using a layer.\n   * @param layer - The layer that provides services\n   */\n  provideLayer<RIn extends Type, E2 extends Type, ROut extends R>(\n    layer: Layer<RIn, E2, ROut>,\n  ): IO<RIn | Exclude<R, ROut>, E | E2, A>\n\n  // ============================================\n  // Execution (R must be never to run)\n  // ============================================\n\n  /**\n   * Runs the effect and returns a Promise of the value.\n   * Throws on error. Requires R = never.\n   */\n  run(this: IO<never, E, A>): Promise<A>\n\n  /**\n   * Runs a sync effect and returns the value.\n   * Throws if the effect is async or has unmet requirements.\n   */\n  runSync(this: IO<never, E, A>): A\n\n  /**\n   * Runs the effect and returns an Either.\n   */\n  runEither(this: IO<never, E, A>): Promise<Either<E, A>>\n\n  /**\n   * Runs the effect and returns an Exit.\n   */\n  runExit(this: IO<never, E, A>): Promise<ExitType<E, A>>\n\n  /**\n   * Runs the effect and returns an Option.\n   * Some(value) on success, None on failure.\n   */\n  runOption(this: IO<never, E, A>): Promise<Option<A>>\n\n  /**\n   * Runs the effect and returns a Try.\n   * Success(value) on success, Failure(error) on failure.\n   */\n  runTry(this: IO<never, E, A>): Promise<ReturnType<typeof Try<A>>>\n\n  // ============================================\n  // Utilities\n  // ============================================\n\n  /**\n   * Pipes the IO through a function.\n   */\n  pipe<B>(f: (self: IO<R, E, A>) => B): B\n\n  /**\n   * Delays execution by the specified milliseconds.\n   */\n  delay(ms: number): IO<R, E, A>\n\n  /**\n   * Fails with TimeoutError if the effect doesn't complete within the specified duration.\n   * @param ms - Maximum time in milliseconds\n   */\n  timeout(ms: number): IO<R, E | TimeoutError, A>\n\n  /**\n   * Returns a fallback value if the effect doesn't complete within the specified duration.\n   * @param ms - Maximum time in milliseconds\n   * @param fallback - Value to return on timeout\n   */\n  timeoutTo<B extends Type>(ms: number, fallback: B): IO<R, E, A | B>\n\n  /**\n   * Converts to string representation.\n   */\n  toString(): string\n\n  /**\n   * Converts to JSON representation.\n   */\n  toJSON(): { _tag: string; effect: unknown }\n\n  /**\n   * Makes IO iterable for generator do-notation (yield* syntax).\n   * Yields the IO itself, allowing IO.gen to extract the value.\n   */\n  [Symbol.iterator](): Generator<IO<R, E, A>, A, A>\n}\n\n// ============================================\n// Internal Implementation\n// ============================================\n\n/**\n * Creates an IO instance from an effect\n */\nconst createIO = <R extends Type, E extends Type, A extends Type>(effect: IOEffect<R, E, A>): IO<R, E, A> => {\n  const io: IO<R, E, A> = {\n    _effect: effect,\n\n    // Core Operations\n    map<B extends Type>(f: (a: A) => B): IO<R, E, B> {\n      return createIO(unsafeCoerce({ _tag: \"Map\", effect: io, f }))\n    },\n\n    flatMap<R2 extends Type, E2 extends Type, B extends Type>(f: (a: A) => IO<R2, E2, B>): IO<R | R2, E | E2, B> {\n      return createIO(unsafeCoerce({ _tag: \"FlatMap\", effect: io, f }))\n    },\n\n    tap(f: (a: A) => void): IO<R, E, A> {\n      return io.map((a) => {\n        f(a)\n        return a\n      })\n    },\n\n    tapEffect<R2 extends Type, E2 extends Type, B extends Type>(f: (a: A) => IO<R2, E2, B>): IO<R | R2, E | E2, A> {\n      return io.flatMap((a) => f(a).map(() => a))\n    },\n\n    // Error Handling\n    mapError<E2 extends Type>(f: (e: E) => E2): IO<R, E2, A> {\n      return createIO(unsafeCoerce({ _tag: \"MapError\", effect: io, f }))\n    },\n\n    recover<B extends Type>(fallback: B): IO<R, never, A | B> {\n      return createIO(unsafeCoerce({ _tag: \"Recover\", effect: io, fallback }))\n    },\n\n    recoverWith<R2 extends Type, E2 extends Type, B extends Type>(f: (e: E) => IO<R2, E2, B>): IO<R | R2, E2, A | B> {\n      return createIO(unsafeCoerce({ _tag: \"RecoverWith\", effect: io, f }))\n    },\n\n    fold<B extends Type>(onFailure: (e: E) => B, onSuccess: (a: A) => B): IO<R, never, B> {\n      return createIO(unsafeCoerce({ _tag: \"Fold\", effect: io, onFailure, onSuccess }))\n    },\n\n    match<B extends Type>(patterns: { failure: (e: E) => B; success: (a: A) => B }): IO<R, never, B> {\n      return io.fold(patterns.failure, patterns.success)\n    },\n\n    catchTag<\n      K extends E extends { _tag: string } ? E[\"_tag\"] : never,\n      R2 extends Type,\n      E2 extends Type,\n      B extends Type,\n    >(tag: K, handler: (e: Extract<E, { _tag: K }>) => IO<R2, E2, B>): IO<R | R2, Exclude<E, { _tag: K }> | E2, A | B> {\n      const f = (e: E): IO<R | R2, Exclude<E, { _tag: K }> | E2, A | B> => {\n        if (typeof e === \"object\" && e !== null && \"_tag\" in e && (e as { _tag: string })._tag === tag) {\n          return unsafeCoerce(handler(e as Extract<E, { _tag: K }>))\n        }\n        return unsafeCoerce(IOCompanion.fail(e))\n      }\n      return createIO(unsafeCoerce({ _tag: \"RecoverWith\", effect: io, f }))\n    },\n\n    catchAll<R2 extends Type, E2 extends Type, B extends Type>(\n      handler: (e: E) => IO<R2, E2, B>,\n    ): IO<R | R2, E2, A | B> {\n      return io.recoverWith(handler)\n    },\n\n    retry(n: number): IO<R, E, A> {\n      if (n <= 0) return io\n      return io.recoverWith(() => io.retry(n - 1))\n    },\n\n    retryWithDelay(n: number, delayMs: number): IO<R, E, A> {\n      if (n <= 0) return io\n      return io.recoverWith(() => IOCompanion.sleep(delayMs).flatMap(() => io.retryWithDelay(n - 1, delayMs)))\n    },\n\n    // Combinators\n    zipRight<R2 extends Type, E2 extends Type, B extends Type>(that: IO<R2, E2, B>): IO<R | R2, E | E2, B> {\n      return io.flatMap(() => that)\n    },\n\n    zipLeft<R2 extends Type, E2 extends Type, B extends Type>(that: IO<R2, E2, B>): IO<R | R2, E | E2, A> {\n      return io.flatMap((a) => that.map(() => a))\n    },\n\n    zip<R2 extends Type, E2 extends Type, B extends Type>(that: IO<R2, E2, B>): IO<R | R2, E | E2, readonly [A, B]> {\n      return io.flatMap((a) => that.map((b) => [a, b] as const))\n    },\n\n    flatten<R2 extends Type, E2 extends Type, B extends Type>(this: IO<R, E, IO<R2, E2, B>>): IO<R | R2, E | E2, B> {\n      return this.flatMap((inner) => inner)\n    },\n\n    // Dependency Injection\n    provideContext<R2 extends R>(context: Context<R2>): IO<Exclude<R, R2>, E, A> {\n      return createIO(unsafeCoerce({ _tag: \"ProvideContext\", effect: io, context }))\n    },\n\n    provideService<S extends Type>(tag: Tag<S>, service: S): IO<Exclude<R, S>, E, A> {\n      const context = ContextCompanion.make(tag, service)\n      return createIO(unsafeCoerce({ _tag: \"ProvideContext\", effect: io, context }))\n    },\n\n    provideLayer<RIn extends Type, E2 extends Type, ROut extends R>(\n      layer: Layer<RIn, E2, ROut>,\n    ): IO<RIn | Exclude<R, ROut>, E | E2, A> {\n      // Build the layer and provide its context\n      const buildIO: IO<RIn, E2, Context<ROut>> = unsafeCoerce(\n        IOCompanion.async(async () => {\n          const inputContext = ContextCompanion.empty()\n          return await layer.build(unsafeCoerce(inputContext))\n        }),\n      )\n      const provideFn = (context: Context<ROut>): IO<Exclude<R, ROut>, E, A> =>\n        createIO(unsafeCoerce({ _tag: \"ProvideContext\", effect: io, context }))\n      return unsafeCoerce(buildIO.flatMap(provideFn))\n    },\n\n    // Execution\n    async run(this: IO<never, E, A>): Promise<A> {\n      const exit = await runEffect(this._effect)\n      if (exit.isSuccess()) {\n        return exit.orThrow()\n      }\n      throw exit.isFailure() ? (exit.toValue() as { error: E }).error : new Error(\"Effect was interrupted\")\n    },\n\n    runSync(this: IO<never, E, A>): A {\n      return runEffectSync(this._effect)\n    },\n\n    async runEither(this: IO<never, E, A>): Promise<Either<E, A>> {\n      const exit = await runEffect(this._effect)\n      if (exit.isSuccess()) {\n        return Right(exit.orThrow())\n      }\n      if (exit.isFailure()) {\n        return Left((exit.toValue() as { error: E }).error)\n      }\n      throw new Error(\"Effect was interrupted\")\n    },\n\n    async runExit(this: IO<never, E, A>): Promise<ExitType<E, A>> {\n      return runEffect(this._effect)\n    },\n\n    async runOption(this: IO<never, E, A>): Promise<Option<A>> {\n      const exit = await runEffect(this._effect)\n      if (exit.isSuccess()) {\n        return Some(exit.orThrow())\n      }\n      return None()\n    },\n\n    async runTry(this: IO<never, E, A>): Promise<ReturnType<typeof Try<A>>> {\n      const exit = await runEffect(this._effect)\n      if (exit.isSuccess()) {\n        return unsafeCoerce(Try(() => exit.orThrow()))\n      }\n      const error = exit.isFailure() ? (exit.toValue() as { error: E }).error : new Error(\"Effect was interrupted\")\n      return unsafeCoerce(\n        Try(() => {\n          throw error\n        }),\n      )\n    },\n\n    // Utilities\n    pipe<B>(f: (self: IO<R, E, A>) => B): B {\n      return f(io)\n    },\n\n    delay(ms: number): IO<R, E, A> {\n      return unsafeCoerce(\n        IOCompanion.async<void>(() => new Promise((resolve) => setTimeout(resolve, ms))).flatMap(() => io),\n      )\n    },\n\n    timeout(ms: number): IO<R, E | TimeoutError, A> {\n      return createIO(unsafeCoerce({ _tag: \"Timeout\", effect: io, duration: ms }))\n    },\n\n    timeoutTo<B extends Type>(ms: number, fallback: B): IO<R, E, A | B> {\n      return unsafeCoerce(io.timeout(ms).recover(unsafeCoerce(fallback)))\n    },\n\n    toString() {\n      return `IO(${stringify(effect._tag)})`\n    },\n\n    toJSON() {\n      return { _tag: \"IO\", effect: effect._tag }\n    },\n\n    *[Symbol.iterator](): Generator<IO<R, E, A>, A, A> {\n      return yield io\n    },\n  }\n\n  return io\n}\n\n/**\n * Interprets and runs an effect synchronously\n */\nconst runEffectSync = <R extends Type, E extends Type, A extends Type>(\n  effect: IOEffect<R, E, A>,\n  context: Context<R> = ContextCompanion.empty() as Context<R>,\n): A => {\n  switch (effect._tag) {\n    case \"Succeed\":\n      return effect.value\n    case \"Fail\":\n      throw effect.error\n    case \"Die\":\n      throw effect.defect\n    case \"Sync\":\n      return effect.thunk()\n    case \"Async\":\n      throw new Error(\"Cannot run async effect synchronously\")\n    case \"Auto\": {\n      const result = effect.thunk()\n      if (result instanceof Promise) {\n        throw new Error(\"Cannot run async effect synchronously\")\n      }\n      return result\n    }\n    case \"Map\": {\n      const a = runEffectSync(effect.effect._effect, context)\n      return effect.f(a)\n    }\n    case \"FlatMap\": {\n      const a = runEffectSync(effect.effect._effect, context)\n      const nextIO = effect.f(a)\n      return runEffectSync(nextIO._effect, context)\n    }\n    case \"MapError\": {\n      try {\n        return runEffectSync(effect.effect._effect, context)\n      } catch (e) {\n        throw effect.f(e)\n      }\n    }\n    case \"Recover\": {\n      try {\n        return runEffectSync(effect.effect._effect, context)\n      } catch {\n        return effect.fallback\n      }\n    }\n    case \"RecoverWith\": {\n      try {\n        return runEffectSync(effect.effect._effect, context)\n      } catch (e) {\n        const recoveryIO = effect.f(e as E)\n        return runEffectSync(recoveryIO._effect, context)\n      }\n    }\n    case \"Fold\": {\n      try {\n        const a = runEffectSync(effect.effect._effect, context)\n        return effect.onSuccess(a)\n      } catch (e) {\n        return effect.onFailure(e as E)\n      }\n    }\n    case \"Service\": {\n      const service = context.get(effect.tag)\n      if (service.isNone()) {\n        throw new Error(`Service not found: ${effect.tag.id}`)\n      }\n      return service.orThrow() as A\n    }\n    case \"ProvideContext\": {\n      const mergedContext = context.merge(effect.context)\n      return runEffectSync(effect.effect._effect, mergedContext as Context<R>)\n    }\n    case \"Interrupt\":\n      throw new InterruptedError()\n    case \"Bracket\": {\n      const resource = runEffectSync(effect.acquire._effect, context)\n      try {\n        return runEffectSync(effect.use(resource)._effect, context)\n      } finally {\n        runEffectSync(effect.release(resource)._effect, context)\n      }\n    }\n    case \"Race\":\n      throw new Error(\"Cannot run race effect synchronously\")\n    case \"Timeout\":\n      throw new Error(\"Cannot run timeout effect synchronously\")\n  }\n}\n\n/**\n * Interprets and runs an effect asynchronously\n */\nconst runEffect = async <R extends Type, E extends Type, A extends Type>(\n  effect: IOEffect<R, E, A>,\n  context: Context<R> = ContextCompanion.empty() as Context<R>,\n): Promise<ExitType<E, A>> => {\n  try {\n    switch (effect._tag) {\n      case \"Succeed\":\n        return unsafeCoerce(Exit.succeed(effect.value))\n      case \"Fail\":\n        return unsafeCoerce(Exit.fail(effect.error))\n      case \"Die\":\n        throw effect.defect\n      case \"Sync\":\n        return unsafeCoerce(Exit.succeed(effect.thunk()))\n      case \"Async\": {\n        const result = await effect.thunk()\n        return unsafeCoerce(Exit.succeed(result))\n      }\n      case \"Auto\": {\n        const result = effect.thunk()\n        if (result instanceof Promise) {\n          return unsafeCoerce(Exit.succeed(await result))\n        } else {\n          return unsafeCoerce(Exit.succeed(result))\n        }\n      }\n      case \"Map\": {\n        const exitA = await runEffect(effect.effect._effect, context)\n        if (!exitA.isSuccess()) {\n          return unsafeCoerce(exitA)\n        }\n        return unsafeCoerce(Exit.succeed(effect.f(exitA.orThrow())))\n      }\n      case \"FlatMap\": {\n        const exitA = await runEffect(effect.effect._effect, context)\n        if (!exitA.isSuccess()) {\n          return unsafeCoerce(exitA)\n        }\n        const nextIO = effect.f(exitA.orThrow())\n        return runEffect(nextIO._effect, context)\n      }\n      case \"MapError\": {\n        const exitA = await runEffect(effect.effect._effect, context)\n        if (exitA.isSuccess()) {\n          return unsafeCoerce(exitA)\n        }\n        if (exitA.isFailure()) {\n          return unsafeCoerce(Exit.fail(effect.f((exitA.toValue() as { error: unknown }).error)))\n        }\n        return unsafeCoerce(exitA)\n      }\n      case \"Recover\": {\n        const exitA = await runEffect(effect.effect._effect, context)\n        if (exitA.isSuccess()) {\n          return exitA\n        }\n        return Exit.succeed(effect.fallback)\n      }\n      case \"RecoverWith\": {\n        const exitA = await runEffect(effect.effect._effect, context)\n        if (exitA.isSuccess()) {\n          return exitA\n        }\n        if (exitA.isFailure()) {\n          const recoveryIO = effect.f((exitA.toValue() as { error: E }).error)\n          return runEffect(recoveryIO._effect, context)\n        }\n        return exitA\n      }\n      case \"Fold\": {\n        const exitA = await runEffect(effect.effect._effect, context)\n        if (exitA.isSuccess()) {\n          return Exit.succeed(effect.onSuccess(exitA.orThrow()))\n        }\n        if (exitA.isFailure()) {\n          return Exit.succeed(effect.onFailure((exitA.toValue() as { error: E }).error))\n        }\n        return exitA as ExitType<E, A>\n      }\n      case \"Service\": {\n        const service = context.get(effect.tag)\n        if (service.isNone()) {\n          return Exit.fail(new Error(`Service not found: ${effect.tag.id}`) as E)\n        }\n        return Exit.succeed(service.orThrow() as A)\n      }\n      case \"ProvideContext\": {\n        const mergedContext = context.merge(effect.context)\n        return runEffect(effect.effect._effect, mergedContext as Context<R>)\n      }\n      case \"Interrupt\":\n        return Exit.interrupted()\n      case \"Bracket\": {\n        const acquireExit = await runEffect(effect.acquire._effect, context)\n        if (!acquireExit.isSuccess()) {\n          return acquireExit as ExitType<E, A>\n        }\n        const resource = acquireExit.orThrow()\n        try {\n          return await runEffect(effect.use(resource)._effect, context)\n        } finally {\n          // Release always runs, even if use fails\n          await runEffect(effect.release(resource)._effect, context)\n        }\n      }\n      case \"Race\": {\n        if (effect.effects.length === 0) {\n          return Exit.fail(new Error(\"No effects to race\") as E)\n        }\n        // Race all effects - first one to complete wins\n        const result = await Promise.race(effect.effects.map((e) => runEffect(e._effect, context)))\n        return result\n      }\n      case \"Timeout\": {\n        const timeoutPromise = new Promise<ExitType<E, A>>((resolve) =>\n          setTimeout(() => resolve(Exit.fail(new TimeoutError(effect.duration) as E)), effect.duration),\n        )\n        const effectPromise = runEffect(effect.effect._effect, context)\n        return Promise.race([effectPromise, timeoutPromise])\n      }\n    }\n  } catch (e) {\n    // Unhandled defects\n    return Exit.fail(e as E)\n  }\n}\n\n// ============================================\n// Companion Object\n// ============================================\n\n/**\n * IO companion methods for constructing effects\n */\nconst IOCompanion = {\n  // ============================================\n  // Constructors\n  // ============================================\n\n  /**\n   * Creates an IO from a synchronous thunk.\n   * The function is not executed until the IO is run.\n   */\n  sync: <A extends Type>(f: () => A): IO<never, never, A> => createIO({ _tag: \"Sync\", thunk: f }),\n\n  /**\n   * Creates an IO that succeeds with the given value.\n   */\n  succeed: <A extends Type>(value: A): IO<never, never, A> => createIO({ _tag: \"Succeed\", value }),\n\n  /**\n   * Creates an IO that fails with the given error.\n   */\n  fail: <E extends Type>(error: E): IO<never, E, never> => createIO({ _tag: \"Fail\", error }),\n\n  /**\n   * Creates an IO that dies with an unrecoverable defect.\n   */\n  die: (defect: unknown): IO<never, never, never> => createIO({ _tag: \"Die\", defect }),\n\n  /**\n   * Creates an IO from an async thunk.\n   * The Promise is not created until the IO is run.\n   */\n  async: <A extends Type>(f: () => Promise<A>): IO<never, unknown, A> =>\n    createIO(unsafeCoerce({ _tag: \"Async\", thunk: f })),\n\n  /**\n   * Creates an IO from a Promise with error handling.\n   */\n  tryPromise: <A extends Type, E extends Type>(opts: {\n    readonly try: () => Promise<A>\n    readonly catch: (error: unknown) => E\n  }): IO<never, E, A> => createIO<never, unknown, A>({ _tag: \"Async\", thunk: opts.try }).mapError(opts.catch),\n\n  /**\n   * Creates an IO from a function that might throw.\n   */\n  tryCatch: <A extends Type, E extends Type>(f: () => A, onError: (error: unknown) => E): IO<never, E, A> =>\n    IOCompanion.sync(() => {\n      try {\n        return f()\n      } catch (e) {\n        throw onError(e)\n      }\n    }) as unknown as IO<never, E, A>,\n\n  // ============================================\n  // Lifting Functions\n  // ============================================\n\n  /**\n   * Lifts a synchronous function into an IO-returning function.\n   */\n  liftSync:\n    <Args extends unknown[], A extends Type>(f: (...args: Args) => A) =>\n    (...args: Args): IO<never, never, A> =>\n      IOCompanion.sync(() => f(...args)),\n\n  /**\n   * Lifts a Promise-returning function into an IO-returning function.\n   */\n  liftPromise:\n    <Args extends unknown[], A extends Type>(f: (...args: Args) => Promise<A>) =>\n    (...args: Args): IO<never, unknown, A> =>\n      IOCompanion.async(() => f(...args)),\n\n  // ============================================\n  // Integration with Other Types\n  // ============================================\n\n  /**\n   * Creates an IO from an Either.\n   */\n  fromEither: <E extends Type, A extends Type>(either: Either<E, A>): IO<never, E, A> =>\n    unsafeCoerce(either.isRight() ? IOCompanion.succeed(either.value as A) : IOCompanion.fail(either.value as E)),\n\n  /**\n   * Creates an IO from an Option.\n   */\n  fromOption: <A extends Type>(option: Option<A>): IO<never, void, A> =>\n    unsafeCoerce(option.isSome() ? IOCompanion.succeed(option.value) : IOCompanion.fail(undefined as void)),\n\n  /**\n   * Creates an IO from an Option with custom error.\n   */\n  fromOptionOrFail: <E extends Type, A extends Type>(option: Option<A>, onNone: () => E): IO<never, E, A> =>\n    unsafeCoerce(option.isSome() ? IOCompanion.succeed(option.value) : IOCompanion.fail(onNone())),\n\n  /**\n   * Creates an IO from a Try.\n   */\n  fromTry: <A extends Type>(t: ReturnType<typeof Try<A>>): IO<never, Error, A> =>\n    unsafeCoerce(t.isSuccess() ? IOCompanion.succeed(t.orThrow()) : IOCompanion.fail(t.error as Error)),\n\n  // ============================================\n  // Dependency Injection\n  // ============================================\n\n  /**\n   * Creates an IO that requires a service identified by the tag.\n   * The service must be provided before the effect can be run.\n   *\n   * @example\n   * ```typescript\n   * interface Logger {\n   *   log(message: string): void\n   * }\n   * const Logger = Tag<Logger>(\"Logger\")\n   *\n   * const program = IO.service(Logger).flatMap(logger =>\n   *   IO.sync(() => logger.log(\"Hello!\"))\n   * )\n   *\n   * // Provide the service to run\n   * program.provideService(Logger, consoleLogger).run()\n   * ```\n   */\n  service: <S extends Type>(tag: Tag<S>): IO<S, never, S> => createIO({ _tag: \"Service\", tag }),\n\n  /**\n   * Accesses a service and applies a function to it.\n   */\n  serviceWith: <S extends Type, A extends Type>(tag: Tag<S>, f: (service: S) => A): IO<S, never, A> =>\n    IOCompanion.service(tag).map(f),\n\n  /**\n   * Accesses a service and applies an effectful function to it.\n   */\n  serviceWithIO: <S extends Type, R extends Type, E extends Type, A extends Type>(\n    tag: Tag<S>,\n    f: (service: S) => IO<R, E, A>,\n  ): IO<S | R, E, A> => IOCompanion.service(tag).flatMap(f),\n\n  /**\n   * Accesses multiple services and applies a function to them.\n   * Provides a convenient way to work with multiple dependencies.\n   *\n   * @example\n   * ```typescript\n   * const program = IO.withServices(\n   *   { logger: Logger, db: Database },\n   *   ({ logger, db }) => {\n   *     logger.log(\"Querying...\")\n   *     return db.query(\"SELECT * FROM users\")\n   *   }\n   * )\n   * ```\n   */\n  withServices: <Services extends Record<string, Tag<Type>>, A extends Type>(\n    services: Services,\n    f: (ctx: { [K in keyof Services]: TagService<Services[K]> }) => A | Promise<A>,\n  ): IO<TagService<Services[keyof Services]>, unknown, A> => {\n    const entries = Object.entries(services) as [string, Tag<Type>][]\n    if (entries.length === 0) {\n      return unsafeCoerce(\n        createIO({ _tag: \"Auto\", thunk: () => f({} as { [K in keyof Services]: TagService<Services[K]> }) }),\n      )\n    }\n\n    // Build up the context by fetching each service\n    type Ctx = { [K in keyof Services]: TagService<Services[K]> }\n    const initial: IO<TagService<Services[keyof Services]>, never, Partial<Ctx>> = unsafeCoerce(IOCompanion.succeed({}))\n    const buildContext = entries.reduce(\n      (acc: IO<TagService<Services[keyof Services]>, never, Partial<Ctx>>, [name, tag]) =>\n        unsafeCoerce(\n          acc.flatMap((ctx: Partial<Ctx>) =>\n            IOCompanion.service(tag).map((service) => ({\n              ...ctx,\n              [name]: service,\n            })),\n          ),\n        ),\n      initial,\n    )\n\n    return unsafeCoerce(\n      buildContext.flatMap((ctx: Partial<Ctx>) => createIO({ _tag: \"Auto\", thunk: () => f(ctx as Ctx) })),\n    )\n  },\n\n  // ============================================\n  // Combinators\n  // ============================================\n\n  /**\n   * Runs all IOs in parallel and collects results.\n   */\n  all: <R extends Type, E extends Type, A extends Type>(effects: readonly IO<R, E, A>[]): IO<R, E, readonly A[]> => {\n    if (effects.length === 0) {\n      return unsafeCoerce(IOCompanion.succeed([]))\n    }\n    const initial: IO<R, E, A[]> = unsafeCoerce(IOCompanion.succeed([]))\n    return unsafeCoerce(\n      effects.reduce(\n        (acc: IO<R, E, A[]>, effect) => acc.flatMap((results: A[]) => effect.map((a) => [...results, a])),\n        initial,\n      ),\n    )\n  },\n\n  /**\n   * Runs IOs in sequence, returning the first success or last failure.\n   */\n  firstSuccessOf: <R extends Type, E extends Type, A extends Type>(effects: readonly IO<R, E, A>[]): IO<R, E, A> => {\n    if (effects.length === 0) {\n      return unsafeCoerce(IOCompanion.fail(new Error(\"No effects provided\")))\n    }\n    return effects.reduce((acc, effect) => acc.recoverWith(() => effect))\n  },\n\n  /**\n   * Creates an IO that sleeps for the specified duration.\n   */\n  sleep: (ms: number): IO<never, never, void> =>\n    unsafeCoerce(IOCompanion.async(() => new Promise((resolve) => setTimeout(resolve, ms)))),\n\n  /**\n   * Creates an IO that never completes.\n   */\n  never: <A extends Type = never>(): IO<never, never, A> =>\n    unsafeCoerce(IOCompanion.async(() => new Promise(() => {}))),\n\n  /**\n   * Creates a unit IO.\n   */\n  get unit(): IO<never, never, void> {\n    return unsafeCoerce(createIO({ _tag: \"Succeed\", value: undefined }))\n  },\n\n  /**\n   * Converts a nullable value to an IO.\n   */\n  fromNullable: <A extends Type>(value: A | null | undefined): IO<never, void, A> =>\n    unsafeCoerce(\n      value === null || value === undefined ? IOCompanion.fail(undefined as void) : IOCompanion.succeed(value),\n    ),\n\n  // ============================================\n  // Structured Concurrency\n  // ============================================\n\n  /**\n   * Creates an IO that is immediately interrupted.\n   */\n  interrupt: (): IO<never, never, never> => createIO({ _tag: \"Interrupt\" }),\n\n  /**\n   * Ensures a resource is properly released after use.\n   * The release function always runs, even if use fails.\n   *\n   * @example\n   * ```typescript\n   * const withFile = IO.bracket(\n   *   IO.sync(() => openFile(\"data.txt\")),   // acquire\n   *   file => IO.async(() => file.read()),    // use\n   *   file => IO.sync(() => file.close())     // release\n   * )\n   * ```\n   */\n  bracket: <R extends Type, E extends Type, A extends Type, B extends Type>(\n    acquire: IO<R, E, A>,\n    use: (a: A) => IO<R, E, B>,\n    release: (a: A) => IO<R, never, void>,\n  ): IO<R, E, B> =>\n    createIO({\n      _tag: \"Bracket\",\n      acquire: acquire as IO<R, E, unknown>,\n      use: use as (a: unknown) => IO<R, E, B>,\n      release: release as (a: unknown) => IO<R, never, void>,\n    }),\n\n  /**\n   * Alias for bracket with a more descriptive name.\n   */\n  acquireRelease: <R extends Type, E extends Type, A extends Type, B extends Type>(\n    acquire: IO<R, E, A>,\n    use: (a: A) => IO<R, E, B>,\n    release: (a: A) => IO<R, never, void>,\n  ): IO<R, E, B> => IOCompanion.bracket(acquire, use, release),\n\n  /**\n   * Races multiple effects, returning the first to complete.\n   * Note: Other effects are NOT cancelled (JS limitation).\n   *\n   * @example\n   * ```typescript\n   * const result = await IO.race([\n   *   IO.sleep(1000).map(() => \"slow\"),\n   *   IO.sleep(100).map(() => \"fast\")\n   * ]).run() // \"fast\"\n   * ```\n   */\n  race: <R extends Type, E extends Type, A extends Type>(effects: readonly IO<R, E, A>[]): IO<R, E, A> =>\n    createIO({ _tag: \"Race\", effects }),\n\n  /**\n   * Returns the first effect to succeed, or fails if all fail.\n   *\n   * @example\n   * ```typescript\n   * const result = await IO.any([\n   *   IO.fail(\"error1\"),\n   *   IO.succeed(\"success\"),\n   *   IO.fail(\"error2\")\n   * ]).run() // \"success\"\n   * ```\n   */\n  any: <R extends Type, E extends Type, A extends Type>(effects: readonly IO<R, E, A>[]): IO<R, E, A> => {\n    if (effects.length === 0) {\n      return unsafeCoerce(IOCompanion.fail(new Error(\"No effects provided\")))\n    }\n    // Try each effect, return first success\n    return effects.reduce((acc, effect) => acc.recoverWith(() => effect))\n  },\n\n  /**\n   * Executes an effect for each element in the array, collecting results.\n   *\n   * @example\n   * ```typescript\n   * const results = await IO.forEach([1, 2, 3], n =>\n   *   IO.sync(() => n * 2)\n   * ).run() // [2, 4, 6]\n   * ```\n   */\n  forEach: <R extends Type, E extends Type, A extends Type, B extends Type>(\n    items: readonly A[],\n    f: (a: A) => IO<R, E, B>,\n  ): IO<R, E, readonly B[]> => {\n    if (items.length === 0) {\n      return unsafeCoerce(IOCompanion.succeed([]))\n    }\n    const initial: IO<R, E, B[]> = unsafeCoerce(IOCompanion.succeed([]))\n    return unsafeCoerce(\n      items.reduce(\n        (acc: IO<R, E, B[]>, item) => acc.flatMap((results: B[]) => f(item).map((b) => [...results, b])),\n        initial,\n      ),\n    )\n  },\n\n  /**\n   * Executes effects for each element in parallel (limited concurrency coming later).\n   * Alias for forEach.\n   */\n  forEachPar: <R extends Type, E extends Type, A extends Type, B extends Type>(\n    items: readonly A[],\n    f: (a: A) => IO<R, E, B>,\n  ): IO<R, E, readonly B[]> => IOCompanion.forEach(items, f),\n\n  /**\n   * Creates a timeout effect that fails with TimeoutError.\n   */\n  timeout: <R extends Type, E extends Type, A extends Type>(\n    effect: IO<R, E, A>,\n    ms: number,\n  ): IO<R, E | TimeoutError, A> => createIO(unsafeCoerce({ _tag: \"Timeout\", effect, duration: ms })),\n\n  // ============================================\n  // Generator Syntax Support (Phase 2 preparation)\n  // ============================================\n\n  /**\n   * Creates an IO from a generator function.\n   * This enables do-notation style programming.\n   *\n   * @example\n   * ```typescript\n   * const program = IO.gen(function* () {\n   *   const a = yield* IO.succeed(1)\n   *   const b = yield* IO.succeed(2)\n   *   return a + b\n   * })\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  gen: <A extends Type>(f: () => Generator<IO<any, any, any>, A, any>): IO<never, any, A> => {\n    return unsafeCoerce(\n      IOCompanion.sync(() => {\n        const iterator = f()\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const runGenerator = (input: unknown): IO<never, any, A> => {\n          const result = iterator.next(input)\n          if (result.done) {\n            return unsafeCoerce(IOCompanion.succeed(result.value))\n          }\n          return unsafeCoerce(result.value.flatMap((value: unknown) => runGenerator(value)))\n        }\n        return runGenerator(undefined)\n      }).flatMap((io) => io),\n    )\n  },\n\n  // ============================================\n  // Do-Builder Pattern\n  // ============================================\n\n  /**\n   * Starts a Do-builder context for binding values.\n   * This enables do-notation style programming without generators.\n   *\n   * @example\n   * ```typescript\n   * const program = IO.Do\n   *   .bind(\"user\", () => getUser(\"123\"))\n   *   .bind(\"posts\", ({ user }) => getPosts(user.id))\n   *   .let(\"count\", ({ posts }) => posts.length)\n   *   .map(({ user, posts, count }) => ({ user, posts, count }))\n   * ```\n   */\n  get Do(): DoBuilder<never, never, Record<never, never>> {\n    return createDoBuilder(IOCompanion.succeed({} as Record<never, never>))\n  },\n}\n\n/**\n * Do-builder interface for chaining binds and maps\n */\ninterface DoBuilder<R extends Type, E extends Type, Ctx extends Record<string, Type>> {\n  /**\n   * The underlying IO effect\n   */\n  readonly effect: IO<R, E, Ctx>\n\n  /**\n   * Binds the result of an effect to a named property in the context.\n   * @param name - The property name to bind to\n   * @param f - Function that returns an IO effect (receives current context)\n   */\n  bind<N extends string, R2 extends Type, E2 extends Type, A extends Type>(\n    name: Exclude<N, keyof Ctx>,\n    f: (ctx: Ctx) => IO<R2, E2, A>,\n  ): DoBuilder<R | R2, E | E2, Ctx & Record<N, A>>\n\n  /**\n   * Binds a pure value to a named property in the context.\n   * @param name - The property name to bind to\n   * @param f - Function that returns a value (receives current context)\n   */\n  let<N extends string, A extends Type>(\n    name: Exclude<N, keyof Ctx>,\n    f: (ctx: Ctx) => A,\n  ): DoBuilder<R, E, Ctx & Record<N, A>>\n\n  /**\n   * Transforms the final context value.\n   * @param f - Function to transform the context\n   */\n  map<B extends Type>(f: (ctx: Ctx) => B): IO<R, E, B>\n\n  /**\n   * Chains to another IO based on the context.\n   * @param f - Function that returns an IO effect\n   */\n  flatMap<R2 extends Type, E2 extends Type, B extends Type>(f: (ctx: Ctx) => IO<R2, E2, B>): IO<R | R2, E | E2, B>\n\n  /**\n   * Executes a side effect without changing the context.\n   * @param f - Side effect function\n   */\n  tap(f: (ctx: Ctx) => void): DoBuilder<R, E, Ctx>\n\n  /**\n   * Executes an effectful side effect without changing the context.\n   * @param f - Function returning an IO for the side effect\n   */\n  tapEffect<R2 extends Type, E2 extends Type, B extends Type>(\n    f: (ctx: Ctx) => IO<R2, E2, B>,\n  ): DoBuilder<R | R2, E | E2, Ctx>\n\n  /**\n   * Returns the final context as is.\n   */\n  done(): IO<R, E, Ctx>\n}\n\n/**\n * Creates a DoBuilder from an IO effect\n */\nconst createDoBuilder = <R extends Type, E extends Type, Ctx extends Record<string, Type>>(\n  effect: IO<R, E, Ctx>,\n): DoBuilder<R, E, Ctx> => ({\n  effect,\n\n  bind<N extends string, R2 extends Type, E2 extends Type, A extends Type>(\n    name: Exclude<N, keyof Ctx>,\n    f: (ctx: Ctx) => IO<R2, E2, A>,\n  ): DoBuilder<R | R2, E | E2, Ctx & Record<N, A>> {\n    const newEffect = effect.flatMap((ctx) => f(ctx).map((a) => ({ ...ctx, [name]: a }) as Ctx & Record<N, A>))\n    return createDoBuilder(newEffect)\n  },\n\n  let<N extends string, A extends Type>(\n    name: Exclude<N, keyof Ctx>,\n    f: (ctx: Ctx) => A,\n  ): DoBuilder<R, E, Ctx & Record<N, A>> {\n    const newEffect = effect.map((ctx) => ({ ...ctx, [name]: f(ctx) }) as Ctx & Record<N, A>)\n    return createDoBuilder(newEffect)\n  },\n\n  map<B extends Type>(f: (ctx: Ctx) => B): IO<R, E, B> {\n    return effect.map(f)\n  },\n\n  flatMap<R2 extends Type, E2 extends Type, B extends Type>(f: (ctx: Ctx) => IO<R2, E2, B>): IO<R | R2, E | E2, B> {\n    return effect.flatMap(f)\n  },\n\n  tap(f: (ctx: Ctx) => void): DoBuilder<R, E, Ctx> {\n    return createDoBuilder(effect.tap(f))\n  },\n\n  tapEffect<R2 extends Type, E2 extends Type, B extends Type>(\n    f: (ctx: Ctx) => IO<R2, E2, B>,\n  ): DoBuilder<R | R2, E | E2, Ctx> {\n    return createDoBuilder(effect.tapEffect(f))\n  },\n\n  done(): IO<R, E, Ctx> {\n    return effect\n  },\n})\n\n/**\n * IO constructor - creates an IO from a function.\n * Automatically detects if the function returns a Promise and handles it appropriately.\n *\n * @example\n * ```typescript\n * // Sync usage\n * const syncIO = IO(() => 42)\n *\n * // Async usage - auto-detected\n * const asyncIO = IO(() => fetch('/api/data'))\n * ```\n */\nconst IOConstructor = <A extends Type>(f: () => A | Promise<A>): IO<never, unknown, A> =>\n  createIO(unsafeCoerce({ _tag: \"Auto\", thunk: f }))\n\n/**\n * IO effect type for lazy, composable effects with typed errors.\n *\n * @example\n * ```typescript\n * // Basic usage\n * const program = IO.sync(() => 42)\n *   .map(x => x * 2)\n *   .flatMap(x => IO.succeed(x + 1))\n *\n * const result = await program.run() // 85\n *\n * // Error handling\n * const safe = IO.tryPromise({\n *   try: () => fetch('/api/data'),\n *   catch: (e) => new NetworkError(e)\n * })\n *   .map(res => res.json())\n *   .recover({ fallback: 'default' })\n *\n * // Composition\n * const composed = IO.all([\n *   IO.succeed(1),\n *   IO.succeed(2),\n *   IO.succeed(3)\n * ]) // IO<never, never, [1, 2, 3]>\n * ```\n */\nexport const IO = Companion(IOConstructor, IOCompanion)\n\n// ============================================\n// Type Aliases for Common Cases\n// ============================================\n\n/**\n * An IO with no requirements and no error\n */\nexport type UIO<A extends Type> = IO<never, never, A>\n\n/**\n * An IO with no requirements\n */\nexport type Task<E extends Type, A extends Type> = IO<never, E, A>\n\n/**\n * An IO with no error\n */\nexport type RIO<R extends Type, A extends Type> = IO<R, never, A>\n","import type { Type } from \"@/types\"\n\nimport type { Context } from \"./Context\"\nimport { Context as ContextCompanion } from \"./Context\"\nimport type { Tag } from \"./Tag\"\n\n/**\n * Layer module - service construction recipes.\n * @module Layer\n * @category IO\n *\n * Layers describe how to construct services, including their dependencies.\n * They can be composed to build complex service graphs.\n */\n\n/**\n * A Layer describes how to build a service or set of services.\n *\n * @typeParam RIn - Required services (dependencies)\n * @typeParam E - Possible errors during construction\n * @typeParam ROut - Services provided by this layer\n *\n * @example\n * ```typescript\n * // A layer that provides a Logger service\n * const LoggerLive = Layer.succeed(Logger, consoleLogger)\n *\n * // A layer that requires Config and provides Database\n * const DatabaseLive = Layer.fromFunction(Database, (config: Config) =>\n *   createDatabase(config.connectionString)\n * )\n * ```\n */\nexport interface Layer<RIn extends Type, E extends Type, ROut extends Type> {\n  /**\n   * Type brand\n   * @internal\n   */\n  readonly _tag: \"Layer\"\n\n  /**\n   * Phantom types\n   * @internal\n   */\n  readonly _RIn?: RIn\n  readonly _E?: E\n  readonly _ROut?: ROut\n\n  /**\n   * The build function that creates the context\n   * @internal\n   */\n  readonly build: (input: Context<RIn>) => Promise<Context<ROut>>\n\n  /**\n   * Composes this layer with another, running them in sequence.\n   * The output of this layer becomes available to the next layer.\n   * @param that - Layer to compose with\n   */\n  provideToAndMerge<RIn2 extends Type, E2 extends Type, ROut2 extends Type>(\n    that: Layer<RIn2 | ROut, E2, ROut2>,\n  ): Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut | ROut2>\n\n  /**\n   * Merges two independent layers.\n   * @param that - Layer to merge with\n   */\n  merge<RIn2 extends Type, E2 extends Type, ROut2 extends Type>(\n    that: Layer<RIn2, E2, ROut2>,\n  ): Layer<RIn | RIn2, E | E2, ROut | ROut2>\n\n  /**\n   * Maps the output of this layer.\n   * @param f - Function to transform the output\n   */\n  map<ROut2 extends Type>(f: (ctx: Context<ROut>) => Context<ROut2>): Layer<RIn, E, ROut2>\n\n  /**\n   * String representation\n   */\n  toString(): string\n}\n\n/**\n * Creates a Layer from a build function\n */\nconst createLayer = <RIn extends Type, E extends Type, ROut extends Type>(\n  build: (input: Context<RIn>) => Promise<Context<ROut>>,\n  name?: string,\n): Layer<RIn, E, ROut> => ({\n  _tag: \"Layer\",\n  build,\n\n  provideToAndMerge<RIn2 extends Type, E2 extends Type, ROut2 extends Type>(\n    that: Layer<RIn2 | ROut, E2, ROut2>,\n  ): Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut | ROut2> {\n    return createLayer(async (input: Context<RIn | Exclude<RIn2, ROut>>) => {\n      const thisOutput = await build(input as Context<RIn>)\n      const mergedInput = (input as Context<Exclude<RIn2, ROut>>).merge(thisOutput)\n      const thatOutput = await that.build(mergedInput as unknown as Context<RIn2 | ROut>)\n      return thisOutput.merge(thatOutput) as Context<ROut | ROut2>\n    })\n  },\n\n  merge<RIn2 extends Type, E2 extends Type, ROut2 extends Type>(\n    that: Layer<RIn2, E2, ROut2>,\n  ): Layer<RIn | RIn2, E | E2, ROut | ROut2> {\n    return createLayer(async (input: Context<RIn | RIn2>) => {\n      const [thisOutput, thatOutput] = await Promise.all([\n        build(input as Context<RIn>),\n        that.build(input as Context<RIn2>),\n      ])\n      return thisOutput.merge(thatOutput) as Context<ROut | ROut2>\n    })\n  },\n\n  map<ROut2 extends Type>(f: (ctx: Context<ROut>) => Context<ROut2>): Layer<RIn, E, ROut2> {\n    return createLayer(async (input: Context<RIn>) => {\n      const output = await build(input)\n      return f(output)\n    })\n  },\n\n  toString() {\n    return `Layer(${name ?? \"anonymous\"})`\n  },\n})\n\n/**\n * Layer companion object with construction methods\n */\nexport const Layer = {\n  /**\n   * Creates a layer that provides a service with a constant value.\n   * @param tag - The service tag\n   * @param service - The service implementation\n   */\n  succeed: <S extends Type>(tag: Tag<S>, service: S): Layer<never, never, S> =>\n    createLayer(() => Promise.resolve(ContextCompanion.make(tag, service)), tag.id),\n\n  /**\n   * Creates a layer from an async function.\n   * @param tag - The service tag\n   * @param f - Async function to create the service\n   */\n  effect: <S extends Type, E extends Type>(tag: Tag<S>, f: () => Promise<S>): Layer<never, E, S> =>\n    createLayer(async () => {\n      const service = await f()\n      return ContextCompanion.make(tag, service)\n    }, tag.id),\n\n  /**\n   * Creates a layer from a sync function.\n   * @param tag - The service tag\n   * @param f - Function to create the service\n   */\n  sync: <S extends Type>(tag: Tag<S>, f: () => S): Layer<never, never, S> =>\n    createLayer(() => Promise.resolve(ContextCompanion.make(tag, f())), tag.id),\n\n  /**\n   * Creates a layer that depends on another service.\n   * @param tag - The service tag to provide\n   * @param depTag - The dependency tag\n   * @param f - Function to create the service from the dependency\n   */\n  fromService: <Dep extends Type, S extends Type>(\n    tag: Tag<S>,\n    depTag: Tag<Dep>,\n    f: (dep: Dep) => S,\n  ): Layer<Dep, never, S> =>\n    createLayer((input: Context<Dep>) => {\n      const dep = input.unsafeGet(depTag)\n      return Promise.resolve(ContextCompanion.make(tag, f(dep)))\n    }, tag.id),\n\n  /**\n   * Creates a layer that depends on another service (async).\n   * @param tag - The service tag to provide\n   * @param depTag - The dependency tag\n   * @param f - Async function to create the service from the dependency\n   */\n  fromServiceEffect: <Dep extends Type, E extends Type, S extends Type>(\n    tag: Tag<S>,\n    depTag: Tag<Dep>,\n    f: (dep: Dep) => Promise<S>,\n  ): Layer<Dep, E, S> =>\n    createLayer(async (input: Context<Dep>) => {\n      const dep = input.unsafeGet(depTag)\n      const service = await f(dep)\n      return ContextCompanion.make(tag, service)\n    }, tag.id),\n\n  /**\n   * Creates a layer from a context.\n   * @param context - The context to use\n   */\n  fromContext: <R extends Type>(context: Context<R>): Layer<never, never, R> =>\n    createLayer(() => Promise.resolve(context)),\n\n  /**\n   * Creates an empty layer that provides nothing.\n   */\n  empty: (): Layer<never, never, never> => createLayer(() => Promise.resolve(ContextCompanion.empty()), \"empty\"),\n\n  /**\n   * Merges multiple layers into one.\n   * @param layers - Layers to merge\n   */\n  mergeAll: <Layers extends Layer<Type, Type, Type>[]>(\n    ...layers: Layers\n  ): Layer<\n    Layers[number] extends Layer<infer RIn, Type, Type> ? RIn : never,\n    Layers[number] extends Layer<Type, infer E, Type> ? E : never,\n    Layers[number] extends Layer<Type, Type, infer ROut> ? ROut : never\n  > =>\n    createLayer(async (input) => {\n      const outputs = await Promise.all(layers.map((l) => l.build(input as Context<Type>)))\n      return outputs.reduce((acc, ctx) => acc.merge(ctx), ContextCompanion.empty()) as Context<Type>\n    }) as Layer<\n      Layers[number] extends Layer<infer RIn, Type, Type> ? RIn : never,\n      Layers[number] extends Layer<Type, infer E, Type> ? E : never,\n      Layers[number] extends Layer<Type, Type, infer ROut> ? ROut : never\n    >,\n}\n\n/**\n * Type helper to extract input requirements from a Layer\n */\nexport type LayerInput<L> = L extends Layer<infer RIn, Type, Type> ? RIn : never\n\n/**\n * Type helper to extract error type from a Layer\n */\nexport type LayerError<L> = L extends Layer<Type, infer E, Type> ? E : never\n\n/**\n * Type helper to extract output services from a Layer\n */\nexport type LayerOutput<L> = L extends Layer<Type, Type, infer ROut> ? ROut : never\n","import type { Type } from \"@/types\"\n\n/**\n * Tag module - service identifiers for dependency injection.\n * @module Tag\n * @category IO\n *\n * Tags are used to identify services in a type-safe way.\n * Each Tag has a unique identifier and carries the type of the service.\n */\n\n/**\n * A Tag identifies a service type and provides a unique identifier.\n * Used for dependency injection with IO effects.\n *\n * @typeParam S - The service type this tag identifies\n *\n * @example\n * ```typescript\n * // Define service interfaces\n * interface UserService {\n *   getUser(id: string): IO<never, Error, User>\n * }\n *\n * // Create a tag for the service\n * const UserService = Tag<UserService>(\"UserService\")\n *\n * // Use in effects\n * const getUser = (id: string) =>\n *   IO.service(UserService).flatMap(svc => svc.getUser(id))\n * ```\n */\nexport interface Tag<S extends Type> {\n  /**\n   * Unique identifier for this tag\n   */\n  readonly id: string\n\n  /**\n   * Phantom type to carry the service type\n   * @internal\n   */\n  readonly _S?: S\n\n  /**\n   * Type brand to distinguish tags\n   * @internal\n   */\n  readonly _tag: \"Tag\"\n\n  /**\n   * String representation\n   */\n  toString(): string\n}\n\n/**\n * Creates a Tag for identifying a service type.\n *\n * @param id - Unique identifier for this tag (usually the service name)\n * @returns A Tag that can be used to request the service\n *\n * @example\n * ```typescript\n * interface Logger {\n *   log(message: string): void\n * }\n *\n * const Logger = Tag<Logger>(\"Logger\")\n *\n * // Now Logger can be used to request the Logger service\n * const program = IO.service(Logger).flatMap(logger =>\n *   IO.sync(() => logger.log(\"Hello!\"))\n * )\n * ```\n */\nexport const Tag = <S extends Type>(id: string): Tag<S> => ({\n  id,\n  _tag: \"Tag\",\n  toString() {\n    return `Tag(${id})`\n  },\n})\n\n/**\n * Type helper to extract the service type from a Tag\n */\nexport type TagService<T> = T extends Tag<infer S> ? S : never\n","import type { Type } from \"@/types\"\n\nimport { Context } from \"./Context\"\nimport type { IO } from \"./IO\"\nimport { IO as IOCompanion } from \"./IO\"\nimport { Tag } from \"./Tag\"\n\n/**\n * TestClock provides controlled time for testing IO effects.\n *\n * Instead of waiting for real time to pass, you can advance the clock manually,\n * making tests for timeouts, delays, and scheduled operations fast and deterministic.\n *\n * @example\n * ```typescript\n * const test = TestClock.test(async (clock) => {\n *   // Start a delayed effect\n *   const fiber = IO.sleep(1000).map(() => \"done\").runExit()\n *\n *   // Advance time by 1 second\n *   await clock.advance(1000)\n *\n *   // Effect should complete\n *   const exit = await fiber\n *   expect(exit.isSuccess()).toBe(true)\n * })\n * ```\n */\n\n/**\n * Scheduled task in the TestClock\n */\ninterface ScheduledTask {\n  readonly time: number\n  readonly resolve: () => void\n}\n\n/**\n * TestClock interface for controlling time in tests\n */\nexport interface TestClock {\n  /**\n   * Current virtual time in milliseconds\n   */\n  readonly currentTime: number\n\n  /**\n   * Advances the clock by the specified duration.\n   * All scheduled tasks with a time <= new current time will be executed.\n   * @param ms - Milliseconds to advance\n   */\n  advance(ms: number): Promise<void>\n\n  /**\n   * Sets the clock to a specific time.\n   * @param ms - The absolute time to set\n   */\n  setTime(ms: number): Promise<void>\n\n  /**\n   * Runs all pending tasks immediately.\n   */\n  runAll(): Promise<void>\n\n  /**\n   * Gets the number of pending scheduled tasks.\n   */\n  readonly pendingCount: number\n\n  /**\n   * Sleeps for the specified duration using virtual time.\n   * @param ms - Milliseconds to sleep\n   */\n  sleep(ms: number): Promise<void>\n}\n\n/**\n * Creates a new TestClock instance\n */\nconst createTestClock = (): TestClock => {\n  let _currentTime = 0\n  const _scheduled: ScheduledTask[] = []\n\n  const processScheduled = async (): Promise<void> => {\n    // Sort by time to process in order\n    _scheduled.sort((a, b) => a.time - b.time)\n\n    // Process all tasks that should have completed\n    while (_scheduled.length > 0 && _scheduled[0] !== undefined && _scheduled[0].time <= _currentTime) {\n      const task = _scheduled.shift()\n      if (task) {\n        task.resolve()\n        // Allow microtasks to run\n        await Promise.resolve()\n      }\n    }\n  }\n\n  return {\n    get currentTime() {\n      return _currentTime\n    },\n\n    async advance(ms: number): Promise<void> {\n      _currentTime += ms\n      await processScheduled()\n    },\n\n    async setTime(ms: number): Promise<void> {\n      _currentTime = ms\n      await processScheduled()\n    },\n\n    async runAll(): Promise<void> {\n      // Set time to the max scheduled time and process all\n      if (_scheduled.length > 0) {\n        const lastTask = _scheduled[_scheduled.length - 1]\n        if (lastTask) {\n          _currentTime = lastTask.time\n        }\n      }\n      await processScheduled()\n    },\n\n    get pendingCount() {\n      return _scheduled.length\n    },\n\n    sleep(ms: number): Promise<void> {\n      return new Promise((resolve) => {\n        _scheduled.push({\n          time: _currentTime + ms,\n          resolve,\n        })\n      })\n    },\n  }\n}\n\n/**\n * Service tag for TestClock\n */\nexport const TestClockTag = Tag<TestClock>(\"TestClock\")\n\n/**\n * TestClock companion object with factory methods\n */\nexport const TestClock = {\n  /**\n   * Creates a new TestClock instance\n   */\n  make: createTestClock,\n\n  /**\n   * Tag for dependency injection\n   */\n  tag: TestClockTag,\n\n  /**\n   * Creates a test environment with a TestClock and runs the test function.\n   *\n   * @example\n   * ```typescript\n   * await TestClock.test(async (clock) => {\n   *   const result = await IO.sleep(100).map(() => \"done\")\n   *     .pipe(clock.runWithClock)\n   *   expect(result).toBe(\"done\")\n   * })\n   * ```\n   */\n  test: async <A>(f: (clock: TestClock) => Promise<A>): Promise<A> => {\n    const clock = createTestClock()\n    return f(clock)\n  },\n\n  /**\n   * Creates an IO that accesses the TestClock from the environment.\n   */\n  get: IOCompanion.service(TestClockTag),\n\n  /**\n   * Creates an IO that advances the TestClock.\n   */\n  advance: (ms: number): IO<TestClock, never, void> =>\n    IOCompanion.serviceWithIO(TestClockTag, (clock) => IOCompanion.async(() => clock.advance(ms))) as unknown as IO<\n      TestClock,\n      never,\n      void\n    >,\n\n  /**\n   * Creates an IO that sets the TestClock time.\n   */\n  setTime: (ms: number): IO<TestClock, never, void> =>\n    IOCompanion.serviceWithIO(TestClockTag, (clock) => IOCompanion.async(() => clock.setTime(ms))) as unknown as IO<\n      TestClock,\n      never,\n      void\n    >,\n\n  /**\n   * Creates an IO that runs all pending tasks.\n   */\n  runAll: IOCompanion.serviceWithIO(TestClockTag, (clock) => IOCompanion.async(() => clock.runAll())),\n\n  /**\n   * Creates a context with a TestClock for testing.\n   */\n  context: (): { clock: TestClock; context: ReturnType<typeof Context.make<TestClock>> } => {\n    const clock = createTestClock()\n    const context = Context.make(TestClockTag, clock)\n    return { clock, context }\n  },\n}\n\n/**\n * TestContext provides a complete test environment with mocked services.\n */\nexport interface TestContext<R extends Type> {\n  /**\n   * The context containing test services\n   */\n  readonly context: ReturnType<typeof Context.empty<R>>\n\n  /**\n   * The TestClock for controlling time\n   */\n  readonly clock: TestClock\n\n  /**\n   * Adds a service to the test context\n   */\n  withService<S extends Type>(tag: Tag<S>, service: S): TestContext<R & S>\n\n  /**\n   * Provides the test context to an IO effect and runs it\n   */\n  run<E extends Type, A extends Type>(effect: IO<R, E, A>): Promise<A>\n}\n\n/**\n * Creates a TestContext for testing IO effects with mocked services.\n *\n * @example\n * ```typescript\n * const ctx = TestContext.make()\n *   .withService(Logger, mockLogger)\n *   .withService(Database, mockDb)\n *\n * const result = await ctx.run(myProgram)\n * ```\n */\nexport const TestContext = {\n  /**\n   * Creates a new empty TestContext\n   */\n  make: <R extends Type = never>(): TestContext<R> => {\n    const clock = createTestClock()\n    let ctx = Context.empty<R>()\n\n    const testContext: TestContext<R> = {\n      get context() {\n        return ctx\n      },\n\n      get clock() {\n        return clock\n      },\n\n      withService<S extends Type>(tag: Tag<S>, service: S): TestContext<R & S> {\n        ctx = ctx.add(tag, service) as ReturnType<typeof Context.empty<R>>\n        return testContext as unknown as TestContext<R & S>\n      },\n\n      async run<E extends Type, A extends Type>(effect: IO<R, E, A>): Promise<A> {\n        return effect.provideContext(ctx).run()\n      },\n    }\n\n    return testContext\n  },\n\n  /**\n   * Creates a TestContext with a TestClock already provided\n   */\n  withClock: (): TestContext<TestClock> => {\n    const clock = createTestClock()\n    return TestContext.make<TestClock>().withService(TestClockTag, clock)\n  },\n}\n","import stringify from \"safe-stable-stringify\"\n\nimport { Companion } from \"@/companion/Companion\"\nimport type { Either } from \"@/either\"\nimport { Left, Right } from \"@/either\"\nimport type { Extractable } from \"@/extractable\"\nimport type { FunctypeBase } from \"@/functype\"\nimport type { Option } from \"@/option\"\nimport { None, Some } from \"@/option\"\nimport type { Pipe } from \"@/pipe\"\nimport { Try } from \"@/try\"\nimport type { Type } from \"@/types\"\n\n/**\n * Lazy type module\n * @module Lazy\n * @category Core\n */\n\n/**\n * The Lazy type represents a computation that is deferred until needed.\n * It provides memoization and safe evaluation with integration to Option, Either, and Try.\n * @typeParam T - The type of the value to be computed\n */\nexport interface Lazy<T extends Type> extends FunctypeBase<T, \"Lazy\">, Extractable<T>, Pipe<T> {\n  /** Tag identifying this as a Lazy type */\n  readonly _tag: \"Lazy\"\n  /** Whether the computation has been evaluated */\n  readonly isEvaluated: boolean\n  /**\n   * Returns the computed value or a default value if computation fails\n   * @param defaultValue - The value to return if computation fails\n   * @returns The computed value or defaultValue\n   */\n  orElse(defaultValue: T): T\n  /**\n   * Returns the computed value or null if computation fails\n   * @returns The computed value or null\n   */\n  orNull(): T | null\n  /**\n   * Returns the computed value or throws an error if computation fails\n   * @param error - Optional custom error to throw. If not provided, throws the computation error or a default error\n   * @returns The computed value\n   * @throws The specified error, computation error, or a default error\n   */\n  orThrow(error?: Error): T\n  /**\n   * Returns this Lazy if computation succeeds, otherwise returns the alternative Lazy\n   * @param alternative - The alternative Lazy to use if computation fails\n   * @returns This Lazy or the alternative\n   */\n  or(alternative: Lazy<T>): Lazy<T>\n  /**\n   * Maps the value inside the Lazy using the provided function\n   * @param f - The mapping function\n   * @returns A new Lazy containing the mapped value\n   */\n  map<U extends Type>(f: (value: T) => U): Lazy<U>\n  /**\n   * Applies a wrapped function to a wrapped value (Applicative pattern)\n   * @param ff - A Lazy containing a function from T to U\n   * @returns A new Lazy containing the result\n   */\n  ap<U extends Type>(ff: Lazy<(value: T) => U>): Lazy<U>\n  /**\n   * Maps the value inside the Lazy using an async function\n   * @param f - The async mapping function\n   * @returns A Promise of a new Lazy containing the mapped value\n   */\n  mapAsync<U extends Type>(f: (value: T) => Promise<U>): Promise<Lazy<U>>\n  /**\n   * Maps the value using a function that returns a Lazy\n   * @param f - The mapping function returning a Lazy\n   * @returns A new Lazy containing the flattened result\n   */\n  flatMap<U extends Type>(f: (value: T) => Lazy<U>): Lazy<U>\n  /**\n   * Maps the value using an async function that returns a Lazy\n   * @param f - The async mapping function returning a Lazy\n   * @returns A Promise of a new Lazy containing the flattened result\n   */\n  flatMapAsync<U extends Type>(f: (value: T) => Promise<Lazy<U>>): Promise<Lazy<U>>\n  /**\n   * Returns a Lazy that filters the value based on a predicate\n   * @param predicate - The predicate function\n   * @returns A Lazy containing an Option of the value\n   */\n  filter(predicate: (value: T) => boolean): Lazy<Option<T>>\n  /**\n   * Recovers from a failed computation by providing an alternative value\n   * @param f - Function that takes the error and returns a recovery value\n   * @returns A new Lazy that will use the recovery function if computation fails\n   */\n  recover(f: (error: unknown) => T): Lazy<T>\n  /**\n   * Recovers from a failed computation by providing an alternative Lazy\n   * @param f - Function that takes the error and returns a recovery Lazy\n   * @returns A new Lazy that will use the recovery Lazy if computation fails\n   */\n  recoverWith(f: (error: unknown) => Lazy<T>): Lazy<T>\n  /**\n   * Evaluates the computation and returns it as an Option\n   * @returns Some containing the value if successful, None if computation fails\n   */\n  toOption(): Option<T>\n  /**\n   * Evaluates the computation and returns it as an Either\n   * @returns Right containing the value if successful, Left containing the error if computation fails\n   */\n  toEither(): Either<unknown, T>\n  /**\n   * Evaluates the computation and returns it as an Either with a mapped error\n   * @param mapError - Function to map the error\n   * @returns Right containing the value if successful, Left containing the mapped error if computation fails\n   */\n  toEitherWith<E>(mapError: (error: unknown) => E): Either<E, T>\n  /**\n   * Evaluates the computation and returns it as a Try\n   * @returns Try containing the result of the computation\n   */\n  toTry(): Try<T>\n  /**\n   * Applies an effect function to the value if computation succeeds\n   * @param f - The effect function\n   * @returns This Lazy for chaining\n   */\n  tap(f: (value: T) => void): Lazy<T>\n  /**\n   * Applies an effect function to the error if computation fails\n   * @param f - The effect function for errors\n   * @returns This Lazy for chaining\n   */\n  tapError(f: (error: unknown) => void): Lazy<T>\n  /**\n   * Pattern matching on the Lazy value\n   * @param f - Function to apply to the computed value\n   * @returns The result of applying f to the computed value\n   */\n  fold<U>(f: (value: T) => U): U\n  /**\n   * Pattern matching with success and failure handlers\n   * @param onFailure - Function to handle computation failure\n   * @param onSuccess - Function to handle successful computation\n   * @returns The result of the appropriate handler\n   */\n  foldWith<U>(onFailure: (error: unknown) => U, onSuccess: (value: T) => U): U\n  /**\n   * Left fold operation\n   * @param z - Initial value\n   * @returns Function that takes an operator and applies it\n   */\n  foldLeft: <B>(z: B) => (op: (b: B, a: T) => B) => B\n  /**\n   * Right fold operation\n   * @param z - Initial value\n   * @returns Function that takes an operator and applies it\n   */\n  foldRight: <B>(z: B) => (op: (a: T, b: B) => B) => B\n  /**\n   * Pattern matching for the Lazy type\n   * @param patterns - Object with handler for Lazy pattern\n   * @returns The result of the matched handler\n   */\n  match<R>(patterns: { Lazy: (value: T) => R }): R\n  /**\n   * Creates a string representation of the Lazy\n   * @returns String representation showing evaluation status\n   */\n  toString(): string\n  /**\n   * Converts the Lazy to a value object\n   * @returns Object representation of the Lazy with evaluation state\n   */\n  toValue(): { _tag: \"Lazy\"; evaluated: boolean; value?: T }\n}\n\n/**\n * Internal constructor for creating Lazy instances\n */\nconst LazyConstructor = <T extends Type>(thunk: () => T): Lazy<T> => {\n  let evaluated = false\n  let value: T | undefined = undefined\n  let error: unknown | undefined = undefined\n  let hasError = false\n\n  const evaluate = (): T => {\n    if (!evaluated) {\n      try {\n        value = thunk()\n        evaluated = true\n      } catch (e) {\n        error = e\n        hasError = true\n        evaluated = true\n        throw e\n      }\n    }\n    if (hasError) {\n      throw error\n    }\n    return value as T\n  }\n\n  const lazy: Lazy<T> = {\n    _tag: \"Lazy\",\n    get isEvaluated() {\n      return evaluated\n    },\n    orElse: (defaultValue: T): T => {\n      try {\n        return evaluate()\n      } catch {\n        return defaultValue\n      }\n    },\n    orNull: (): T | null => {\n      try {\n        return evaluate()\n      } catch {\n        return null\n      }\n    },\n    orThrow: (err?: Error): T => {\n      try {\n        return evaluate()\n      } catch (e) {\n        throw err ?? e\n      }\n    },\n    or: (alternative: Lazy<T>): Lazy<T> =>\n      Lazy(() => {\n        try {\n          return evaluate()\n        } catch {\n          return alternative.orThrow()\n        }\n      }),\n    orUndefined: (): T | undefined => {\n      try {\n        return evaluate()\n      } catch {\n        return undefined\n      }\n    },\n    map: <U extends Type>(f: (value: T) => U): Lazy<U> => Lazy(() => f(evaluate())),\n    ap: <U extends Type>(ff: Lazy<(value: T) => U>): Lazy<U> => Lazy(() => ff.orThrow()(evaluate())),\n    mapAsync: async <U extends Type>(f: (value: T) => Promise<U>): Promise<Lazy<U>> => {\n      const val = evaluate()\n      const result = await f(val)\n      return Lazy(() => result) as Lazy<U>\n    },\n    flatMap: <U extends Type>(f: (value: T) => Lazy<U>): Lazy<U> => Lazy(() => f(evaluate()).orThrow()),\n    flatMapAsync: async <U extends Type>(f: (value: T) => Promise<Lazy<U>>): Promise<Lazy<U>> => {\n      const val = evaluate()\n      const lazyResult = await f(val)\n      return Lazy(() => lazyResult.orThrow()) as Lazy<U>\n    },\n    filter: (predicate: (value: T) => boolean): Lazy<Option<T>> =>\n      Lazy(() => {\n        const val = evaluate()\n        return predicate(val) ? Some(val) : (None as unknown as Option<T>)\n      }),\n    recover: (f: (error: unknown) => T): Lazy<T> =>\n      Lazy(() => {\n        try {\n          return evaluate()\n        } catch (e) {\n          return f(e)\n        }\n      }),\n    recoverWith: (f: (error: unknown) => Lazy<T>): Lazy<T> =>\n      Lazy(() => {\n        try {\n          return evaluate()\n        } catch (e) {\n          return f(e).orThrow()\n        }\n      }),\n    toOption: (): Option<T> => {\n      try {\n        return Some(evaluate())\n      } catch {\n        return None as unknown as Option<T>\n      }\n    },\n    toEither: (): Either<unknown, T> => {\n      try {\n        return Right(evaluate())\n      } catch (e) {\n        return Left(e)\n      }\n    },\n    toEitherWith: <E>(mapError: (error: unknown) => E): Either<E, T> => {\n      try {\n        return Right(evaluate())\n      } catch (e) {\n        return Left(mapError(e))\n      }\n    },\n    toTry: (): Try<T> => Try(() => evaluate()),\n    tap: (f: (value: T) => void): Lazy<T> =>\n      Lazy(() => {\n        const val = evaluate()\n        f(val)\n        return val\n      }),\n    tapError: (f: (error: unknown) => void): Lazy<T> =>\n      Lazy(() => {\n        try {\n          return evaluate()\n        } catch (e) {\n          f(e)\n          throw e\n        }\n      }),\n    fold: <U>(f: (value: T) => U): U => f(evaluate()),\n    foldWith: <U>(onFailure: (error: unknown) => U, onSuccess: (value: T) => U): U => {\n      try {\n        return onSuccess(evaluate())\n      } catch (e) {\n        return onFailure(e)\n      }\n    },\n    foldLeft:\n      <B>(z: B) =>\n      (op: (b: B, a: T) => B) =>\n        op(z, evaluate()),\n    foldRight:\n      <B>(z: B) =>\n      (op: (a: T, b: B) => B) =>\n        op(evaluate(), z),\n    match: <R>(patterns: { Lazy: (value: T) => R }): R => patterns.Lazy(evaluate()),\n    toString: (): string => {\n      if (evaluated && !hasError) {\n        return `Lazy(${stringify(value)})`\n      } else if (evaluated && hasError) {\n        const errorMessage = error instanceof Error ? error.message : String(error)\n        return `Lazy(<error: ${errorMessage}>)`\n      } else {\n        return `Lazy(<not evaluated>)`\n      }\n    },\n    toValue: (): { _tag: \"Lazy\"; evaluated: boolean; value?: T } => {\n      if (evaluated && !hasError) {\n        return { _tag: \"Lazy\" as const, evaluated: true, value: value as T }\n      } else {\n        return { _tag: \"Lazy\" as const, evaluated: false }\n      }\n    },\n    // Traversable\n    get size() {\n      try {\n        evaluate()\n        return 1\n      } catch {\n        return 0\n      }\n    },\n    get isEmpty() {\n      try {\n        evaluate()\n        return false\n      } catch {\n        return true\n      }\n    },\n    contains: (v: T): boolean => {\n      try {\n        return evaluate() === v\n      } catch {\n        return false\n      }\n    },\n    reduce: (_f: (b: T, a: T) => T): T => evaluate(),\n    reduceRight: (_f: (b: T, a: T) => T): T => evaluate(),\n    count: (p: (x: T) => boolean): number => {\n      try {\n        return p(evaluate()) ? 1 : 0\n      } catch {\n        return 0\n      }\n    },\n    find: (p: (a: T) => boolean): Option<T> => {\n      try {\n        const val = evaluate()\n        return p(val) ? Some(val) : (None as unknown as Option<T>)\n      } catch {\n        return None as unknown as Option<T>\n      }\n    },\n    exists: (p: (a: T) => boolean): boolean => {\n      try {\n        return p(evaluate())\n      } catch {\n        return false\n      }\n    },\n    forEach: (f: (a: T) => void): void => {\n      try {\n        f(evaluate())\n      } catch {\n        // Ignore errors in forEach\n      }\n    },\n    // Pipe\n    pipe: <U>(f: (value: T) => U): U => f(evaluate()),\n    // Serializable\n    serialize: () => ({\n      toJSON: () =>\n        JSON.stringify(\n          evaluated && !hasError ? { _tag: \"Lazy\", evaluated: true, value } : { _tag: \"Lazy\", evaluated: false },\n        ),\n      toYAML: () =>\n        evaluated && !hasError\n          ? `_tag: Lazy\\nevaluated: true\\nvalue: ${stringify(value)}`\n          : `_tag: Lazy\\nevaluated: false`,\n      toBinary: () =>\n        Buffer.from(\n          JSON.stringify(\n            evaluated && !hasError ? { _tag: \"Lazy\", evaluated: true, value } : { _tag: \"Lazy\", evaluated: false },\n          ),\n        ).toString(\"base64\"),\n    }),\n    // Typeable\n    typeable: \"Lazy\" as const,\n  } as Lazy<T>\n\n  return lazy\n}\n\n/**\n * Companion object with static methods for Lazy\n */\nconst LazyCompanion = {\n  /**\n   * Creates a Lazy from a thunk (deferred computation)\n   * @param thunk - Function that computes the value\n   * @returns A new Lazy instance\n   */\n  of: <T extends Type>(thunk: () => T): Lazy<T> => LazyConstructor(thunk),\n  /**\n   * Creates a Lazy from an immediate value\n   * @param value - The value to wrap\n   * @returns A new Lazy instance that returns the value\n   */\n  fromValue: <T extends Type>(value: T): Lazy<T> => LazyConstructor(() => value),\n  /**\n   * Creates a Lazy from an Option\n   * @param option - The Option to convert\n   * @param defaultThunk - Thunk to compute default value if Option is None\n   * @returns A new Lazy instance\n   */\n  fromOption: <T extends Type>(option: Option<T>, defaultThunk: () => T): Lazy<T> =>\n    LazyConstructor(() => (option._tag === \"Some\" ? (option.value as T) : defaultThunk())),\n  /**\n   * Creates a Lazy from a Try\n   * @param tryValue - The Try to convert\n   * @returns A new Lazy instance\n   */\n  fromTry: <T extends Type>(tryValue: Try<T>): Lazy<T> => LazyConstructor(() => tryValue.orThrow()),\n  /**\n   * Creates a Lazy from an Either\n   * @param either - The Either to convert\n   * @returns A new Lazy instance\n   */\n  fromEither: <E, T extends Type>(either: Either<E, T>): Lazy<T> =>\n    LazyConstructor(() =>\n      either.fold(\n        (e) => {\n          throw e\n        },\n        (value) => value,\n      ),\n    ),\n  /**\n   * Creates a Lazy that will throw an error since promises need to be awaited first\n   * @param promise - The Promise to convert\n   * @returns A new Lazy instance that throws an error\n   */\n  fromPromise: <T extends Type>(_promise: Promise<T>): Lazy<T> => {\n    const thunk = () => {\n      throw new Error(\"Promise not yet resolved. Use await on the promise before creating Lazy.\")\n    }\n    return LazyConstructor(thunk as () => T) as unknown as Lazy<T>\n  },\n  /**\n   * Creates a failed Lazy that will throw when evaluated\n   * @param error - The error to throw\n   * @returns A new Lazy instance that throws the error\n   */\n  fail: <T extends Type>(error: unknown): Lazy<T> => {\n    const thunk = () => {\n      throw error\n    }\n    return LazyConstructor(thunk as () => T) as unknown as Lazy<T>\n  },\n}\n\n/**\n * Creates a Lazy computation that defers evaluation until needed.\n * Results are memoized after first evaluation.\n *\n * @example\n * // Basic lazy evaluation\n * const expensive = Lazy(() => {\n *   console.log(\"Computing...\")\n *   return 42\n * })\n * // Nothing printed yet\n * const result = expensive.orThrow() // Prints \"Computing...\" and returns 42\n * const cached = expensive.orThrow() // Returns 42 without printing\n *\n * @example\n * // Error handling\n * const risky = Lazy(() => {\n *   if (Math.random() > 0.5) throw new Error(\"Failed\")\n *   return \"Success\"\n * })\n * const safe = risky.orElse(\"Default\") // Returns \"Success\" or \"Default\"\n * const option = risky.toOption() // Some(\"Success\") or None\n * const either = risky.toEither() // Right(\"Success\") or Left(Error)\n *\n * @example\n * // Chaining computations\n * const result = Lazy(() => 10)\n *   .map(x => x * 2)\n *   .flatMap(x => Lazy(() => x + 5))\n *   .recover(err => 0)\n *   .orThrow() // 25\n *\n * @example\n * // Integration with functype\n * const userOption = Option({ id: 1, name: \"Alice\" })\n * const userName = Lazy.fromOption(userOption, () => ({ id: 0, name: \"Anonymous\" }))\n *   .map(user => user.name)\n *   .orThrow() // \"Alice\"\n */\nexport const Lazy = Companion(LazyConstructor, LazyCompanion)\n","/**\n * Type alias for the native JavaScript Map\n * @interface\n * @module Map\n * @category Collections\n */\nexport type ESMapType<K, V> = Map<K, V>\n\n/**\n * Reference to the native JavaScript Map\n * @module Map\n * @category Collections\n */\nexport const ESMap = Map\n","import type { Collection } from \"@/collections\"\nimport type { Typeable } from \"@/index\"\nimport { Companion, type Foldable } from \"@/index\"\nimport { List } from \"@/list/List\"\nimport { Option } from \"@/option/Option\"\nimport type { Pipe } from \"@/pipe\"\nimport type { Serializable } from \"@/serializable/Serializable\"\nimport { createSerializer } from \"@/serialization\"\nimport { Set } from \"@/set/Set\"\nimport type { Traversable } from \"@/traversable/Traversable\"\nimport { Tuple } from \"@/tuple/Tuple\"\nimport type { Type } from \"@/types\"\n\nimport { ESMap, type ESMapType } from \"./shim\"\n\n/**\n * A traversable interface for map that excludes map and flatMap operations\n */\nexport type SafeTraversable<K, V> = Omit<Traversable<Tuple<[K, V]>>, \"map\" | \"flatMap\" | \"flatMapAsync\" | \"ap\">\n\nexport interface Map<K, V>\n  extends\n    SafeTraversable<K, V>,\n    Collection<Tuple<[K, V]>>,\n    Typeable<\"Map\">,\n    Serializable<[K, V][]>,\n    Pipe<[K, V][]>,\n    Foldable<Tuple<[K, V]>>,\n    Iterable<[K, V]> {\n  readonly _tag: \"Map\"\n  add(item: Tuple<[K, V]>): Map<K, V>\n  remove(value: K): Map<K, V>\n  map<U>(f: (value: V) => U): Map<K, U>\n  ap<U>(ff: Map<K, (value: V) => U>): Map<K, U>\n  flatMap<K2, V2>(f: (entry: Tuple<[K, V]>) => Iterable<[K2, V2]>): Map<K2, V2>\n  flatMapAsync<U>(f: (value: V) => PromiseLike<Map<K, U>>): PromiseLike<Map<K, U>>\n  get(key: K): Option<V>\n  getOrElse(key: K, defaultValue: V): V\n  orElse(key: K, alternative: Option<V>): Option<V>\n  fold<U extends Type>(onEmpty: () => U, onValue: (value: Tuple<[K, V]>) => U): U\n  foldLeft<B>(z: B): (op: (b: B, a: Tuple<[K, V]>) => B) => B\n  foldRight<B>(z: B): (op: (a: Tuple<[K, V]>, b: B) => B) => B\n  /**\n   * Pattern matches over the Map, applying a handler function based on whether it's empty\n   * @param patterns - Object with handler functions for Empty and NonEmpty variants\n   * @returns The result of applying the matching handler function\n   */\n  match<R>(patterns: { Empty: () => R; NonEmpty: (entries: Array<Tuple<[K, V]>>) => R }): R\n  toValue(): { _tag: \"Map\"; value: [K, V][] }\n}\n\ntype MapState<K, V> = {\n  values: ESMapType<K, V>\n}\n\nconst MapObject = <K, V>(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null): Map<K, V> => {\n  const _tag = \"Map\"\n  const state: MapState<K, V> = {\n    values: new ESMap<K, V>(entries),\n  }\n\n  const getEntries = () => Array.from(state.values.entries()).map(([key, value]) => Tuple<[K, V]>([key, value]))\n\n  const add = (item: Tuple<[K, V]>): Map<K, V> =>\n    MapObject(new ESMap(state.values).set(item.toArray()[0], item.toArray()[1]).entries())\n\n  const remove = (value: K): Map<K, V> => {\n    const newMap = new ESMap(state.values)\n    return newMap.delete(value) ? MapObject(newMap.entries()) : MapObject(state.values.entries())\n  }\n\n  const contains = (value: Tuple<[K, V]>): boolean => {\n    const tuple = value.toArray()\n    return state.values.get(tuple[0]) === tuple[1]\n  }\n\n  const size = (): number => state.values.size\n\n  const map = <U>(f: (value: V) => U): Map<K, U> =>\n    MapObject(Array.from(state.values.entries()).map(([k, v]) => [k, f(v)]))\n\n  const flatMap = <K2, V2>(f: (entry: Tuple<[K, V]>) => Iterable<[K2, V2]>): Map<K2, V2> => {\n    const list = MapObject(state.values.entries()).toList()\n    return MapObject(list.flatMap(f).toArray())\n  }\n\n  const ap = <U>(ff: Map<K, (value: V) => U>): Map<K, U> => {\n    const newEntries: Array<[K, U]> = []\n    for (const [key, value] of state.values.entries()) {\n      const fn = ff.get(key)\n      if (fn._tag === \"Some\" && fn.value) {\n        newEntries.push([key, fn.value(value)])\n      }\n    }\n    return MapObject(newEntries)\n  }\n\n  const flatMapAsync = async <U>(f: (value: V) => PromiseLike<Map<K, U>>): Promise<Map<K, U>> => {\n    const results = new ESMap<K, U>()\n    for (const [_key, value] of state.values.entries()) {\n      const mappedMap = await f(value)\n      // Merge all entries from the resulting map\n      for (const entry of mappedMap.toList()) {\n        const [k, v] = entry.toArray()\n        results.set(k, v)\n      }\n    }\n    return MapObject(results.entries())\n  }\n\n  const reduce = (f: (acc: Tuple<[K, V]>, value: Tuple<[K, V]>) => Tuple<[K, V]>): Tuple<[K, V]> =>\n    List(getEntries()).reduce(f)\n\n  const reduceRight = (f: (acc: Tuple<[K, V]>, value: Tuple<[K, V]>) => Tuple<[K, V]>): Tuple<[K, V]> =>\n    List(getEntries()).reduceRight(f)\n\n  const foldLeft =\n    <B>(z: B) =>\n    (op: (b: B, a: Tuple<[K, V]>) => B): B =>\n      List(getEntries()).foldLeft(z)(op)\n\n  const foldRight =\n    <B>(z: B) =>\n    (op: (a: Tuple<[K, V]>, b: B) => B): B =>\n      List(getEntries()).foldRight(z)(op)\n\n  const get = (key: K): Option<V> => Option(state.values.get(key))\n\n  const getOrElse = (key: K, defaultValue: V): V => Option(state.values.get(key)).orElse(defaultValue)\n\n  const isEmpty = (): boolean => state.values.size === 0\n\n  const orElse = (key: K, alternative: Option<V>): Option<V> => Option(state.values.get(key)).or(alternative)\n\n  const fold = <U extends Type>(onEmpty: () => U, onValue: (value: Tuple<[K, V]>) => U): U => {\n    if (isEmpty()) return onEmpty()\n\n    // For Map, we'll always return the first entry as the value for fold\n    // This is consistent with how Option and other single-value types work\n    const entries = getEntries()\n    if (entries.length === 0) {\n      return onEmpty()\n    }\n\n    const firstEntry = entries[0]\n    // Make sure we handle potential undefined values\n    if (firstEntry === undefined) {\n      return onEmpty()\n    }\n\n    return onValue(firstEntry)\n  }\n\n  const toList = (): List<Tuple<[K, V]>> => List(getEntries())\n\n  const toSet = (): Set<Tuple<[K, V]>> => Set(getEntries())\n\n  const toString = (): string => `Map(${getEntries().toString()})`\n\n  const match = <R>(patterns: { Empty: () => R; NonEmpty: (entries: Array<Tuple<[K, V]>>) => R }): R => {\n    if (isEmpty()) {\n      return patterns.Empty()\n    }\n    return patterns.NonEmpty(getEntries())\n  }\n\n  return {\n    _tag,\n    [Symbol.iterator]: () => state.values.entries(),\n    add,\n    remove,\n    contains,\n    get size() {\n      return size()\n    },\n    map,\n    ap,\n    flatMap,\n    flatMapAsync,\n    reduce,\n    reduceRight,\n    foldLeft,\n    foldRight,\n    fold,\n    match,\n    get,\n    getOrElse,\n    get isEmpty() {\n      return isEmpty()\n    },\n    orElse,\n    toList,\n    toSet,\n    toString,\n    toValue: () => ({ _tag: \"Map\" as const, value: Array.from(state.values.entries()) }),\n    pipe: <U>(f: (value: [K, V][]) => U) => f(Array.from(state.values.entries())),\n    serialize: () => createSerializer(\"Map\", Array.from(state.values.entries())),\n  }\n}\n\nconst MapConstructor = <K, V>(entries?: readonly (readonly [K, V])[] | IterableIterator<[K, V]> | null): Map<K, V> =>\n  MapObject(entries)\n\nconst MapCompanion = {\n  /**\n   * Creates a Map from JSON string\n   * @param json - The JSON string\n   * @returns Map instance\n   */\n  fromJSON: <K, V>(json: string): Map<K, V> => {\n    const parsed = JSON.parse(json) as { _tag: string; value: Array<[K, V]> }\n    return Map<K, V>(parsed.value)\n  },\n\n  /**\n   * Creates a Map from YAML string\n   * @param yaml - The YAML string\n   * @returns Map instance\n   */\n  fromYAML: <K, V>(yaml: string): Map<K, V> => {\n    const lines = yaml.split(\"\\n\")\n    const valueStr = lines[1]?.split(\": \")[1]\n    if (!valueStr) {\n      return Map<K, V>([])\n    }\n    const value = JSON.parse(valueStr) as Array<[K, V]>\n    return Map<K, V>(value)\n  },\n\n  /**\n   * Creates a Map from binary string\n   * @param binary - The binary string\n   * @returns Map instance\n   */\n  fromBinary: <K, V>(binary: string): Map<K, V> => {\n    const json = Buffer.from(binary, \"base64\").toString()\n    return MapCompanion.fromJSON<K, V>(json)\n  },\n}\n\nexport const Map = Companion(MapConstructor, MapCompanion)\n","/**\n * Pattern matching interface for functional data types.\n *\n * @typeParam A - The type of elements in the data structure\n * @typeParam Tags - The type of tags used for pattern matching\n */\nexport interface Matchable<A, Tags extends string = string> {\n  /**\n   * Pattern matches against this data structure, applying handlers for each variant based on tag.\n   * Similar to fold but with stronger type safety for tag-based variants.\n   *\n   * The return type is inferred from the pattern handlers when not explicitly specified.\n   *\n   * @param patterns - An object containing handler functions for each variant\n   * @returns The result of applying the matching handler function\n   */\n  match<R>(patterns: Record<Tags, (value: A) => R>): R\n}\n\n/**\n * Utility functions for working with Matchable data structures\n */\nexport const MatchableUtils = {\n  /**\n   * Helper function to create a default case for pattern matching\n   *\n   * @param handler - The default handler function to apply\n   * @returns A function that always applies the default handler\n   */\n  default: <A, R>(handler: (value: A) => R) => {\n    return (value: A) => handler(value)\n  },\n\n  /**\n   * Helper function to create a match pattern that guards based on a predicate\n   *\n   * @param predicate - The predicate function for guarding\n   * @param handler - The handler function to apply if the predicate passes\n   * @returns A function that applies the handler only if the predicate passes\n   */\n  when: <A, R>(predicate: (value: A) => boolean, handler: (value: A) => R) => {\n    return (value: A) => (predicate(value) ? handler(value) : undefined)\n  },\n}\n","import { Companion } from \"@/companion/Companion\"\nimport type { Foldable } from \"@/foldable/Foldable\"\nimport { List } from \"@/list/List\"\nimport type { Matchable } from \"@/matchable\"\nimport { Option } from \"@/option/Option\"\nimport type { Pipe } from \"@/pipe\"\nimport type { Serializable } from \"@/serializable/Serializable\"\nimport type { Traversable } from \"@/traversable/Traversable\"\nimport type { Type } from \"@/types\"\nimport type { Valuable } from \"@/valuable/Valuable\"\n\n/**\n * Stack data structure - Last In, First Out (LIFO)\n * Implements the Traversable interface for working with ordered collections\n */\nexport type Stack<A extends Type> = {\n  /**\n   * Push a value onto the top of the stack\n   * @param value - The value to push\n   * @returns A new Stack with the value added\n   */\n  push(value: A): Stack<A>\n\n  /**\n   * Remove and return the top value from the stack\n   * @returns A tuple containing the new Stack and the value\n   */\n  pop(): [Stack<A>, Option<A>]\n\n  /**\n   * Return the top value without removing it\n   * @returns The top value wrapped in an Option\n   */\n  peek(): Option<A>\n\n  /**\n   * Transforms each element in the stack using the provided function\n   * @param f - The mapping function\n   * @returns A new Stack with transformed elements\n   */\n  map<B extends Type>(f: (a: A) => B): Stack<B>\n\n  /**\n   * Maps each element to a Stack and flattens the result\n   * @param f - The mapping function returning a Stack\n   * @returns A new flattened Stack\n   */\n  flatMap<B extends Type>(f: (a: A) => Stack<B>): Stack<B>\n\n  /**\n   * Applies a Stack of functions to this Stack\n   * @param ff - Stack of functions to apply\n   * @returns A new Stack with applied functions\n   */\n  ap<B extends Type>(ff: Stack<(value: A) => B>): Stack<B>\n\n  /**\n   * Maps each element to an async Stack and flattens the result\n   * @param f - The async mapping function returning a Stack\n   * @returns A promise of the new flattened Stack\n   */\n  flatMapAsync<B extends Type>(f: (value: A) => PromiseLike<Stack<B>>): PromiseLike<Stack<B>>\n\n  /**\n   * Convert the stack to a List\n   * @returns A List containing all elements\n   */\n  toList(): List<A>\n\n  /**\n   * Convert the stack to an array\n   * @returns An array of all elements\n   */\n  toArray(): A[]\n\n  /**\n   * Returns a string representation of the stack\n   * @returns A string representation\n   */\n  toString(): string\n\n  /**\n   * Pattern matches over the Stack, applying a handler function based on whether it's empty\n   * @param patterns - Object with handler functions for Empty and NonEmpty variants\n   * @returns The result of applying the matching handler function\n   */\n  match<R>(patterns: { Empty: () => R; NonEmpty: (values: A[]) => R }): R\n} & Traversable<A> &\n  Valuable<\"Stack\", A[]> &\n  Serializable<A> &\n  Pipe<A[]> &\n  Foldable<A> &\n  Matchable<A[], \"Empty\" | \"NonEmpty\">\n\n/**\n * Creates a new Stack instance\n * @param values - Initial values for the stack (last item will be at the top)\n * @returns A new Stack instance\n */\nconst StackObject = <A extends Type>(values: A[] = []): Stack<A> => {\n  const _tag = \"Stack\"\n  const items = [...values] // Create a copy to ensure immutability\n\n  // Implementation of Traversable interface\n  const size = (): number => items.length\n  const isEmpty = (): boolean => items.length === 0\n\n  const contains = (value: A): boolean => items.includes(value)\n\n  const reduce = (f: (prev: A, curr: A) => A): A => {\n    if (items.length === 0) {\n      throw new Error(\"Cannot reduce an empty stack\")\n    }\n    return items.reduce(f)\n  }\n\n  const reduceRight = (f: (prev: A, curr: A) => A): A => {\n    if (items.length === 0) {\n      throw new Error(\"Cannot reduce an empty stack\")\n    }\n    return items.reduceRight(f)\n  }\n\n  // Stack-specific operations\n  const push = (value: A): Stack<A> => {\n    return StackObject<A>([...items, value])\n  }\n\n  const pop = (): [Stack<A>, Option<A>] => {\n    if (isEmpty()) {\n      return [StackObject<A>([]), Option<A>(null)]\n    }\n\n    const newItems = [...items]\n    const popped = newItems.pop()\n    return [StackObject<A>(newItems), Option<A>(popped as A)]\n  }\n\n  const peek = (): Option<A> => {\n    if (isEmpty()) {\n      return Option<A>(null)\n    }\n    return Option<A>(items[items.length - 1])\n  }\n\n  // Functor implementation\n  const map = <B extends Type>(f: (a: A) => B): Stack<B> => {\n    return StackObject<B>(items.map(f))\n  }\n\n  const flatMap = <B extends Type>(f: (a: A) => Stack<B>): Stack<B> => {\n    if (isEmpty()) {\n      return StackObject<B>([])\n    }\n\n    // Process items from bottom to top to maintain the order\n    return items.reduce((acc: Stack<B>, current: A) => {\n      const result = f(current)\n      return result.toArray().reduce((inner, val) => inner.push(val), acc)\n    }, StackObject<B>([]))\n  }\n\n  const ap = <B extends Type>(ff: Stack<(value: A) => B>): Stack<B> => {\n    const result: B[] = []\n    items.forEach((a) => {\n      ff.toArray().forEach((f) => {\n        result.push(f(a))\n      })\n    })\n    return StackObject<B>(result)\n  }\n\n  const flatMapAsync = async <B extends Type>(f: (value: A) => PromiseLike<Stack<B>>): Promise<Stack<B>> => {\n    if (isEmpty()) {\n      return StackObject<B>([])\n    }\n\n    const results = await Promise.all(items.map(async (a) => await f(a)))\n    return results.reduce((acc: Stack<B>, current: Stack<B>) => {\n      return current.toArray().reduce((inner, val) => inner.push(val), acc)\n    }, StackObject<B>([]))\n  }\n\n  // Conversion methods\n  const toList = (): List<A> => List<A>(items)\n\n  const toArray = (): A[] => [...items]\n\n  const toString = (): string => `Stack(${items.join(\", \")})`\n\n  // Fold implementations\n  const fold = <U extends Type>(onEmpty: () => U, onValue: (value: A) => U): U => {\n    if (isEmpty()) {\n      return onEmpty()\n    }\n    const lastItem = items[items.length - 1]\n    // If the last item is undefined, return the empty case to be safe\n    return lastItem !== undefined ? onValue(lastItem) : onEmpty()\n  }\n\n  const foldLeft =\n    <B>(z: B) =>\n    (op: (b: B, a: A) => B): B => {\n      return items.reduce(op, z)\n    }\n\n  const foldRight =\n    <B>(z: B) =>\n    (op: (a: A, b: B) => B): B => {\n      return items.reduceRight((acc, value) => op(value, acc), z)\n    }\n\n  // Pattern matching\n  const match = <R>(patterns: { Empty: () => R; NonEmpty: (values: A[]) => R }): R => {\n    return isEmpty() ? patterns.Empty() : patterns.NonEmpty([...items])\n  }\n\n  return {\n    _tag,\n    get size() {\n      return size()\n    },\n    get isEmpty() {\n      return isEmpty()\n    },\n    contains,\n    reduce,\n    reduceRight,\n    push,\n    pop,\n    peek,\n    map,\n    flatMap,\n    ap,\n    flatMapAsync,\n    toList,\n    toArray,\n    toString,\n    fold,\n    foldLeft,\n    foldRight,\n    match,\n    toValue: () => ({ _tag: \"Stack\", value: items }),\n    pipe: <U>(f: (value: A[]) => U) => f([...items]),\n    serialize: () => {\n      return {\n        toJSON: () => JSON.stringify({ _tag: \"Stack\", value: items }),\n        toYAML: () => `_tag: Stack\\nvalue: ${JSON.stringify(items)}`,\n        toBinary: () => Buffer.from(JSON.stringify({ _tag: \"Stack\", value: items })).toString(\"base64\"),\n      }\n    },\n  }\n}\n\nconst StackConstructor = <A extends Type>(values: A[] = []): Stack<A> => StackObject(values)\n\nconst StackCompanion = {\n  /**\n   * Creates an empty stack\n   * @returns An empty Stack instance\n   */\n  empty: <A extends Type>(): Stack<A> => StackObject<A>([]),\n\n  /**\n   * Creates a Stack from a single value\n   * @param value - The value to create a stack with\n   * @returns A Stack with a single value\n   */\n  of: <A extends Type>(value: A): Stack<A> => StackObject<A>([value]),\n\n  /**\n   * Creates a Stack from JSON string\n   * @param json - The JSON string\n   * @returns Stack instance\n   */\n  fromJSON: <A>(json: string): Stack<A> => {\n    const parsed = JSON.parse(json)\n    return Stack<A>(parsed.value)\n  },\n\n  /**\n   * Creates a Stack from YAML string\n   * @param yaml - The YAML string\n   * @returns Stack instance\n   */\n  fromYAML: <A>(yaml: string): Stack<A> => {\n    const lines = yaml.split(\"\\n\")\n    const valueStr = lines[1]?.split(\": \")[1]\n    if (!valueStr) {\n      return Stack<A>([])\n    }\n    const value = JSON.parse(valueStr)\n    return Stack<A>(value)\n  },\n\n  /**\n   * Creates a Stack from binary string\n   * @param binary - The binary string\n   * @returns Stack instance\n   */\n  fromBinary: <A>(binary: string): Stack<A> => {\n    const json = Buffer.from(binary, \"base64\").toString()\n    return StackCompanion.fromJSON<A>(json)\n  },\n}\n\nexport const Stack = Companion(StackConstructor, StackCompanion)\n","import { Typeable } from \"@/typeable/Typeable\"\n\n/**\n * Parameters for creating a Valuable instance\n */\nexport type ValuableParams<Tag extends string, T, V> = { _tag: Tag; impl: T; value: V }\n\n/**\n * Represents a type that can extract its inner value. Creates a Valuable wrapper that adds value extraction capabilities.\n * @param params - Configuration parameters\n * @module Valuable\n * @category Utilities\n */\nexport function Valuable<Tag extends string, V, T = object>(params: ValuableParams<Tag, T, V>) {\n  const t = Typeable<Tag, T>({ _tag: params._tag, impl: params.impl })\n  return {\n    ...t,\n    toValue: () => ({ _tag: t._tag, value: params.value }),\n  }\n}\n\nexport type Valuable<Tag extends string, V, T = object> = Typeable<Tag, T> & {\n  toValue: () => { _tag: Tag; value: V }\n}\n"],"mappings":"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"}