{"version":3,"file":"index.mjs","names":["serializeCause","tryOrPanic","err","state"],"sources":["../src/dual.ts","../src/core.ts","../src/error.ts","../src/result.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/**\n * Creates data-first/data-last dual function.\n *\n * @template DataLast Curried (data-last) signature.\n * @template DataFirst Uncurried (data-first) signature.\n * @param arity Number of args for data-first form.\n * @param body Implementation function.\n * @returns Function supporting both calling conventions.\n *\n * @example\n * const add: {\n *   (a: number, b: number): number;\n *   (b: number): (a: number) => number;\n * } = dual(2, (a: number, b: number) => a + b);\n *\n * add(1, 2);  // 3 (data-first)\n * add(2)(1);  // 3 (data-last)\n */\nexport function dual<\n  DataLast extends (...args: Array<any>) => any,\n  DataFirst extends (...args: Array<any>) => any,\n>(arity: Parameters<DataFirst>[\"length\"], body: DataFirst): DataLast & DataFirst {\n  if (arity === 2) {\n    return ((...args: Array<any>) => {\n      if (args.length >= 2) {\n        return body(args[0], args[1]);\n      }\n      return (self: any) => body(self, args[0]);\n    }) as DataLast & DataFirst;\n  }\n\n  if (arity === 3) {\n    return ((...args: Array<any>) => {\n      if (args.length >= 3) {\n        return body(args[0], args[1], args[2]);\n      }\n      return (self: any) => body(self, args[0], args[1]);\n    }) as DataLast & DataFirst;\n  }\n\n  if (arity === 4) {\n    return ((...args: Array<any>) => {\n      if (args.length >= 4) {\n        return body(args[0], args[1], args[2], args[3]);\n      }\n      return (self: any) => body(self, args[0], args[1], args[2]);\n    }) as DataLast & DataFirst;\n  }\n\n  return ((...args: Array<any>) => {\n    if (args.length >= arity) {\n      return body(...args);\n    }\n    return (self: any) => body(self, ...args);\n  }) as DataLast & DataFirst;\n}\n","/** Serialize cause for JSON output */\nconst serializeCause = (cause: unknown): unknown => {\n  if (cause instanceof Error) {\n    return { name: cause.name, message: cause.message, stack: cause.stack };\n  }\n  return cause;\n};\n\n/** Prevents inference from a type position while supporting TypeScript 5.0. */\ntype NoInfer<T> = [T][T extends unknown ? 0 : never];\n\n/**\n * Unrecoverable error — user code threw inside Result operations.\n *\n * @example\n * Result.ok(1).map(() => { throw new Error(\"oops\"); });  // Panic!\n */\nexport class Panic extends Error {\n  readonly _tag = \"Panic\" as const;\n\n  static is(value: unknown): value is Panic {\n    return value instanceof Panic;\n  }\n\n  constructor(args: { message: string; cause?: unknown }) {\n    super(args.message, args.cause !== undefined ? { cause: args.cause } : undefined);\n    Object.assign(this, args);\n    Object.setPrototypeOf(this, new.target.prototype);\n    this.name = \"Panic\";\n\n    if (args.cause instanceof Error && args.cause.stack) {\n      const indented = args.cause.stack.replace(/\\n/g, \"\\n  \");\n      this.stack = `${this.stack}\\nCaused by: ${indented}`;\n    }\n  }\n\n  toJSON(): object {\n    return {\n      ...this,\n      _tag: this._tag,\n      name: this.name,\n      message: this.message,\n      cause: serializeCause(this.cause),\n      stack: this.stack,\n    };\n  }\n\n  /** Makes Panic yieldable in Result.gen blocks like other tagged errors. */\n  *[Symbol.iterator](): Generator<Err<never, this>, never, unknown> {\n    yield* err(this);\n    return panic(\"Unreachable: Err yielded in Panic but generator continued\", this);\n  }\n}\n\n/** Type guard for Panic instances. */\nexport const isPanic = (value: unknown): value is Panic => {\n  return value instanceof Panic;\n};\n\n/** Throw an unrecoverable Panic. */\nexport const panic = (message: string, cause?: unknown): never => {\n  throw new Panic({ message, cause });\n};\n\n/** Executes fn, panics if it throws. */\nconst tryOrPanic = <T>(fn: () => T, message: string): T => {\n  try {\n    return fn();\n  } catch (cause) {\n    throw panic(message, cause);\n  }\n};\n\n/** Async version of tryOrPanic. */\nconst tryOrPanicAsync = async <T>(fn: () => Promise<T>, message: string): Promise<T> => {\n  try {\n    return await fn();\n  } catch (cause) {\n    throw panic(message, cause);\n  }\n};\n\nexport type TapBothHandlers<A, E> = {\n  ok: (a: A) => void;\n  err: (e: E) => void;\n};\n\nexport type TapBothOkHandlers<A> = {\n  ok: (a: A) => void;\n  err: (e: never) => void;\n};\n\nexport type TapBothErrHandlers<E> = {\n  ok: (a: never) => void;\n  err: (e: E) => void;\n};\n\nexport type TapBothAsyncHandlers<A, E> = {\n  ok: (a: A) => Promise<void>;\n  err: (e: E) => Promise<void>;\n};\n\nexport type TapBothAsyncOkHandlers<A> = {\n  ok: (a: A) => Promise<void>;\n  err: (e: never) => Promise<void>;\n};\n\nexport type TapBothAsyncErrHandlers<E> = {\n  ok: (a: never) => Promise<void>;\n  err: (e: E) => Promise<void>;\n};\n\n/** Extracts the success type carried by either Result variant, including Err's phantom T. */\ntype InferSuccess<R> =\n  R extends Ok<infer T, unknown> ? T : R extends Err<infer T, unknown> ? T : never;\n\n/** Detects whether a type is a union. */\ntype IsUnion<T, U = T> = T extends unknown ? ([U] extends [T] ? false : true) : never;\n\n/** Return type for map that preserves concrete variants but prints public Result for Result unions. */\ntype MapReturn<R, B> =\n  IsUnion<R> extends true\n    ? Result<B, InferErr<R>>\n    : R extends Ok<unknown, infer E>\n      ? Ok<B, E>\n      : R extends Err<unknown, infer E>\n        ? Err<B, E>\n        : never;\n\n/** Return type for mapError that preserves concrete variants but prints public Result for Result unions. */\ntype MapErrorReturn<R, E2> =\n  IsUnion<R> extends true\n    ? Result<InferOk<R>, E2>\n    : R extends Ok<infer A, unknown>\n      ? Ok<A, E2>\n      : R extends Err<infer T, unknown>\n        ? Err<T, E2>\n        : never;\n\n/** Return type for recovery that preserves concrete variants but prints public Result for Result unions. */\ntype TryRecoverReturn<R, E2> =\n  IsUnion<R> extends true\n    ? Result<InferOk<R>, E2>\n    : R extends Ok<infer A, unknown>\n      ? Ok<A, E2>\n      : R extends Err<infer T, unknown>\n        ? Result<T, E2>\n        : never;\n\n/** Return type for andThen that preserves concrete variants but prints public Result for Result unions. */\ntype AndThenReturn<R, B, E2> =\n  IsUnion<R> extends true\n    ? Result<B, InferErr<R> | E2>\n    : R extends Ok<unknown, infer E>\n      ? Result<B, E | E2>\n      : R extends Err<unknown, infer E>\n        ? Err<B, E | E2>\n        : never;\n\ntype TapBothHandlersFor<R> = {\n  ok: (a: InferOk<R>) => void;\n  err: (e: InferErr<R>) => void;\n};\n\ntype TapBothAsyncHandlersFor<R> = {\n  ok: (a: InferOk<R>) => Promise<void>;\n  err: (e: InferErr<R>) => Promise<void>;\n};\n\n/**\n * Successful result variant.\n *\n * @template A Success value type.\n * @template E Error type (phantom - for type unification).\n *\n * @example\n * const result = new Ok(42);\n * result.value // 42\n * result.status // \"ok\"\n */\nexport class Ok<A, E = never> {\n  readonly status = \"ok\" as const;\n  constructor(readonly value: A) {}\n\n  /** Returns true, narrowing Result to Ok. */\n  isOk(): this is Ok<A, E> {\n    return true;\n  }\n\n  /** Returns false, narrowing Result to Err. */\n  isErr(): this is Err<A, E> {\n    return false;\n  }\n\n  /**\n   * Transforms success value.\n   *\n   * @template B Transformed type.\n   * @param fn Transformation function.\n   * @returns Ok with transformed value.\n   * @throws {Panic} If fn throws.\n   *\n   * @example\n   * ok(2).map(x => x * 2) // Ok(4)\n   */\n  map<B>(this: Ok<A, E>, fn: (a: A) => B): Ok<B, E>;\n  map<B, R extends AnyResult = Result<A, E>>(this: R, fn: (a: InferOk<R>) => B): MapReturn<R, B>;\n  map<B>(fn: (a: A) => B): Ok<B, E> {\n    return tryOrPanic(() => new Ok<B, E>(fn(this.value)), \"map callback threw\");\n  }\n\n  /**\n   * No-op on Ok, returns self with new phantom error type.\n   *\n   * @template E2 New error type.\n   * @param _fn Ignored.\n   * @returns Self with updated phantom E type.\n   */\n  mapError<E2>(this: Ok<A, E>, _fn: (e: never) => E2): Ok<A, E2>;\n  mapError<E2, R extends AnyResult = Result<A, E>>(\n    this: R,\n    _fn: (e: InferErr<R>) => E2,\n  ): MapErrorReturn<R, E2>;\n  mapError<E2>(_fn: (e: never) => E2): Ok<A, E2> {\n    // SAFETY: E is phantom on Ok (not used at runtime).\n    return this as unknown as Ok<A, E2>;\n  }\n\n  /**\n   * No-op on Ok, returns self with new phantom error type.\n   *\n   * @template E2 New error type.\n   * @param _fn Ignored.\n   * @returns Self with updated phantom E type.\n   *\n   * @example\n   * ok(42).tryRecover(() => err(\"fallback\")) // Ok(42)\n   */\n  tryRecover<E2>(this: Ok<A, E>, _fn: (e: never) => Result<NoInfer<A>, E2>): Ok<A, E2>;\n  tryRecover<E2, R extends AnyResult = Result<A, E>>(\n    this: R,\n    _fn: (e: InferErr<R>) => Result<NoInfer<InferSuccess<R>>, E2>,\n  ): TryRecoverReturn<R, E2>;\n  tryRecover<E2>(_fn: (e: never) => Result<NoInfer<A>, E2>): Ok<A, E2> {\n    // SAFETY: E is phantom on Ok (not used at runtime).\n    return this as unknown as Ok<A, E2>;\n  }\n\n  /**\n   * No-op on Ok, returns Promise of self with new phantom error type.\n   *\n   * @template E2 New error type.\n   * @param _fn Ignored.\n   * @returns Promise of self with updated phantom E type.\n   *\n   * @example\n   * await ok(42).tryRecoverAsync(async () => err(\"fallback\")) // Ok(42)\n   */\n  tryRecoverAsync<E2>(\n    this: Ok<A, E>,\n    _fn: (e: never) => Promise<Result<NoInfer<A>, E2>>,\n  ): Promise<Ok<A, E2>>;\n  tryRecoverAsync<E2, R extends AnyResult = Result<A, E>>(\n    this: R,\n    _fn: (e: InferErr<R>) => Promise<Result<NoInfer<InferSuccess<R>>, E2>>,\n  ): Promise<TryRecoverReturn<R, E2>>;\n  tryRecoverAsync<E2>(_fn: (e: never) => Promise<Result<NoInfer<A>, E2>>): Promise<Ok<A, E2>> {\n    // SAFETY: E is phantom on Ok (not used at runtime).\n    return Promise.resolve(this as unknown as Ok<A, E2>);\n  }\n\n  /**\n   * Chains Result-returning function.\n   *\n   * @template B New success type.\n   * @template E2 New error type.\n   * @param fn Function returning Result.\n   * @returns Result from fn.\n   * @throws {Panic} If fn throws.\n   *\n   * @example\n   * ok(2).andThen(x => x > 0 ? ok(x) : err(\"negative\")) // Ok(2)\n   */\n  andThen<B, E2>(this: Ok<A, E>, fn: (a: A) => Result<B, E2>): Result<B, E | E2>;\n  andThen<B, E2, R extends AnyResult = Result<A, E>>(\n    this: R,\n    fn: (a: InferOk<R>) => Result<B, E2>,\n  ): AndThenReturn<R, B, E2>;\n  andThen<B, E2>(fn: (a: A) => Result<B, E2>): Result<B, E | E2> {\n    return tryOrPanic(() => fn(this.value), \"andThen callback threw\");\n  }\n\n  /**\n   * Chains async Result-returning function.\n   *\n   * @template B New success type.\n   * @template E2 New error type.\n   * @param fn Async function returning Result.\n   * @returns Promise of Result from fn.\n   * @throws {Panic} If fn throws synchronously or rejects.\n   *\n   * @example\n   * await ok(1).andThenAsync(async x => ok(await fetchData(x)))\n   */\n  andThenAsync<B, E2>(\n    this: Ok<A, E>,\n    fn: (a: A) => Promise<Result<B, E2>>,\n  ): Promise<Result<B, E | E2>>;\n  andThenAsync<B, E2, R extends AnyResult = Result<A, E>>(\n    this: R,\n    fn: (a: InferOk<R>) => Promise<Result<B, E2>>,\n  ): Promise<AndThenReturn<R, B, E2>>;\n  andThenAsync<B, E2>(fn: (a: A) => Promise<Result<B, E2>>): Promise<Result<B, E | E2>> {\n    return tryOrPanicAsync(() => fn(this.value), \"andThenAsync callback threw\");\n  }\n\n  /**\n   * Pattern matches on Result.\n   *\n   * @template T Return type.\n   * @param handlers Ok and err handlers.\n   * @returns Result of ok handler.\n   * @throws {Panic} If handler throws.\n   *\n   * @example\n   * ok(2).match({ ok: x => x * 2, err: () => 0 }) // 4\n   */\n  match<T>(this: Ok<A, E>, handlers: { ok: (a: A) => T; err: (e: never) => T }): T;\n  match<T, R extends AnyResult = Result<A, E>>(\n    this: R,\n    handlers: { ok: (a: InferOk<R>) => T; err: (e: InferErr<R>) => T },\n  ): T;\n  match<T>(handlers: { ok: (a: A) => T; err: (e: never) => T }): T {\n    return tryOrPanic(() => handlers.ok(this.value), \"match ok handler threw\");\n  }\n\n  /**\n   * Extracts value.\n   *\n   * @param _message Ignored.\n   * @returns The value.\n   *\n   * @example\n   * ok(42).unwrap() // 42\n   */\n  unwrap(_message?: string): A {\n    return this.value;\n  }\n\n  /**\n   * Returns value, ignoring fallback.\n   *\n   * @template B Fallback type.\n   * @param _fallback Ignored.\n   * @returns The value.\n   *\n   * @example\n   * ok(42).unwrapOr(0) // 42\n   */\n  unwrapOr<B>(_fallback: B): A {\n    return this.value;\n  }\n\n  /**\n   * Runs side effect, returns self.\n   *\n   * @param fn Side effect function.\n   * @returns Self.\n   * @throws {Panic} If fn throws.\n   *\n   * @example\n   * ok(2).tap(console.log).map(x => x * 2) // logs 2, returns Ok(4)\n   */\n  tap(this: Ok<A, E>, fn: (a: A) => void): Ok<A, E>;\n  tap<R extends AnyResult = Result<A, E>>(this: R, fn: (a: InferOk<R>) => void): R;\n  tap(fn: (a: A) => void): Ok<A, E> {\n    return tryOrPanic(() => {\n      fn(this.value);\n      return this;\n    }, \"tap callback threw\");\n  }\n\n  /**\n   * Runs async side effect, returns self.\n   *\n   * @param fn Async side effect function.\n   * @returns Promise of self.\n   * @throws {Panic} If fn throws synchronously or rejects.\n   *\n   * @example\n   * await ok(2).tapAsync(async x => await log(x))\n   */\n  tapAsync(this: Ok<A, E>, fn: (a: A) => Promise<void>): Promise<Ok<A, E>>;\n  tapAsync<R extends AnyResult = Result<A, E>>(\n    this: R,\n    fn: (a: InferOk<R>) => Promise<void>,\n  ): Promise<R>;\n  tapAsync(fn: (a: A) => Promise<void>): Promise<Ok<A, E>> {\n    return tryOrPanicAsync(async () => {\n      await fn(this.value);\n      return this;\n    }, \"tapAsync callback threw\");\n  }\n\n  /**\n   * No-op on Ok, returns self.\n   *\n   * @param _fn Ignored.\n   * @returns Self.\n   */\n  tapError(this: Ok<A, E>, _fn: (e: never) => void): Ok<A, E>;\n  tapError<R extends AnyResult = Result<A, E>>(this: R, _fn: (e: InferErr<R>) => void): R;\n  tapError(_fn: (e: never) => void): Ok<A, E> {\n    return this;\n  }\n\n  /**\n   * No-op on Ok, returns Promise of self.\n   *\n   * @param _fn Ignored.\n   * @returns Promise of self.\n   */\n  tapErrorAsync(this: Ok<A, E>, _fn: (e: never) => Promise<void>): Promise<Ok<A, E>>;\n  tapErrorAsync<R extends AnyResult = Result<A, E>>(\n    this: R,\n    _fn: (e: InferErr<R>) => Promise<void>,\n  ): Promise<R>;\n  tapErrorAsync(_fn: (e: never) => Promise<void>): Promise<Ok<A, E>> {\n    return Promise.resolve(this);\n  }\n\n  /**\n   * Runs ok side effect, skips err side effect, returns self.\n   *\n   * @param handlers Ok and err side effect handlers.\n   * @returns Self.\n   * @throws {Panic} If ok handler throws.\n   */\n  tapBoth(this: Ok<A, E>, handlers: TapBothOkHandlers<A>): Ok<A, E>;\n  tapBoth<R extends AnyResult = Result<A, E>>(this: R, handlers: TapBothHandlersFor<R>): R;\n  tapBoth(handlers: TapBothOkHandlers<A>): Ok<A, E> {\n    return tryOrPanic(() => {\n      handlers.ok(this.value);\n      return this;\n    }, \"tapBoth ok callback threw\");\n  }\n\n  /**\n   * Runs async ok side effect, skips err side effect, returns self.\n   *\n   * @param handlers Ok and err async side effect handlers.\n   * @returns Promise of self.\n   * @throws {Panic} If ok handler throws synchronously or rejects.\n   */\n  tapBothAsync(this: Ok<A, E>, handlers: TapBothAsyncOkHandlers<A>): Promise<Ok<A, E>>;\n  tapBothAsync<R extends AnyResult = Result<A, E>>(\n    this: R,\n    handlers: TapBothAsyncHandlersFor<R>,\n  ): Promise<R>;\n  tapBothAsync(handlers: TapBothAsyncOkHandlers<A>): Promise<Ok<A, E>> {\n    return tryOrPanicAsync(async () => {\n      await handlers.ok(this.value);\n      return this;\n    }, \"tapBothAsync ok callback threw\");\n  }\n\n  /**\n   * Makes Ok yieldable in Result.gen blocks.\n   * Immediately returns the value without yielding.\n   * Yield type Err<never, E> matches Err's for proper union inference.\n   */\n  // oxlint-disable-next-line require-yield\n  *[Symbol.iterator](): Generator<Err<never, E>, A, unknown> {\n    return this.value;\n  }\n}\n\n/**\n * Error result variant.\n *\n * @template T Success type (phantom - for type unification with Ok).\n * @template E Error value type.\n *\n * @example\n * const result = new Err(\"failed\");\n * result.error // \"failed\"\n * result.status // \"error\"\n */\nexport class Err<T, E> {\n  readonly status = \"error\" as const;\n  constructor(readonly error: E) {}\n\n  /** Returns false, narrowing Result to Ok. */\n  isOk(): this is Ok<never, E> {\n    return false;\n  }\n\n  /** Returns true, narrowing Result to Err. */\n  isErr(): this is Err<T, E> {\n    return true;\n  }\n\n  /**\n   * No-op on Err, returns self with new phantom T.\n   *\n   * @template U New phantom success type.\n   * @param _fn Ignored.\n   * @returns Self.\n   */\n  map<U>(this: Err<T, E>, _fn: (a: never) => U): Err<U, E>;\n  map<U, R extends AnyResult = Result<T, E>>(this: R, _fn: (a: InferOk<R>) => U): MapReturn<R, U>;\n  map<U>(_fn: (a: never) => U): Err<U, E> {\n    // SAFETY: T is phantom (not used at runtime). Err only holds `error: E`.\n    return this as unknown as Err<U, E>;\n  }\n\n  /**\n   * Transforms error value.\n   *\n   * @template E2 Transformed error type.\n   * @param fn Transformation function.\n   * @returns Err with transformed error.\n   * @throws {Panic} If fn throws.\n   *\n   * @example\n   * err(\"fail\").mapError(e => new Error(e)) // Err(Error(\"fail\"))\n   */\n  mapError<E2>(this: Err<T, E>, fn: (e: E) => E2): Err<T, E2>;\n  mapError<E2, R extends AnyResult = Result<T, E>>(\n    this: R,\n    fn: (e: InferErr<R>) => E2,\n  ): MapErrorReturn<R, E2>;\n  mapError<E2>(fn: (e: E) => E2): Err<T, E2> {\n    return tryOrPanic(() => new Err<T, E2>(fn(this.error)), \"mapError callback threw\");\n  }\n\n  /**\n   * Attempts to recover from Err into the same success type.\n   *\n   * @template E2 New error type.\n   * @param fn Recovery function returning Result with the same success type.\n   * @returns Result from fn.\n   * @throws {Panic} If fn throws.\n   *\n   * @example\n   * err<number, string>(\"missing\").tryRecover(e => e === \"missing\" ? ok(0) : err(new Error(e))) // Ok(0)\n   */\n  tryRecover<E2>(this: Err<T, E>, fn: (e: E) => Result<NoInfer<T>, E2>): Result<T, E2>;\n  tryRecover<E2, R extends AnyResult = Result<T, E>>(\n    this: R,\n    fn: (e: InferErr<R>) => Result<NoInfer<InferSuccess<R>>, E2>,\n  ): TryRecoverReturn<R, E2>;\n  tryRecover<E2>(fn: (e: E) => Result<NoInfer<T>, E2>): Result<T, E2> {\n    return tryOrPanic(() => fn(this.error), \"tryRecover callback threw\");\n  }\n\n  /**\n   * Attempts to recover from Err into the same success type asynchronously.\n   *\n   * @template E2 New error type.\n   * @param fn Async recovery function returning Result with the same success type.\n   * @returns Promise of Result from fn.\n   * @throws {Panic} If fn throws synchronously or rejects.\n   *\n   * @example\n   * await err<number, string>(\"missing\").tryRecoverAsync(async e => e === \"missing\" ? ok(0) : err(new Error(e))) // Ok(0)\n   */\n  tryRecoverAsync<E2>(\n    this: Err<T, E>,\n    fn: (e: E) => Promise<Result<NoInfer<T>, E2>>,\n  ): Promise<Result<T, E2>>;\n  tryRecoverAsync<E2, R extends AnyResult = Result<T, E>>(\n    this: R,\n    fn: (e: InferErr<R>) => Promise<Result<NoInfer<InferSuccess<R>>, E2>>,\n  ): Promise<TryRecoverReturn<R, E2>>;\n  tryRecoverAsync<E2>(fn: (e: E) => Promise<Result<NoInfer<T>, E2>>): Promise<Result<T, E2>> {\n    return tryOrPanicAsync(() => fn(this.error), \"tryRecoverAsync callback threw\");\n  }\n\n  /**\n   * No-op on Err, returns self with widened error type.\n   *\n   * @template U New phantom success type.\n   * @template E2 Additional error type.\n   * @param _fn Ignored.\n   * @returns Self.\n   */\n  andThen<U, E2>(this: Err<T, E>, _fn: (a: never) => Result<U, E2>): Err<U, E | E2>;\n  andThen<U, E2, R extends AnyResult = Result<T, E>>(\n    this: R,\n    _fn: (a: InferOk<R>) => Result<U, E2>,\n  ): AndThenReturn<R, U, E2>;\n  andThen<U, E2>(_fn: (a: never) => Result<U, E2>): Err<U, E | E2> {\n    // SAFETY: T is phantom, E⊂(E|E2) so error type widens safely.\n    return this as unknown as Err<U, E | E2>;\n  }\n\n  /**\n   * No-op on Err, returns Promise of self with widened error type.\n   *\n   * @template U New phantom success type.\n   * @template E2 Additional error type.\n   * @param _fn Ignored.\n   * @returns Promise of self.\n   */\n  andThenAsync<U, E2>(\n    this: Err<T, E>,\n    _fn: (a: never) => Promise<Result<U, E2>>,\n  ): Promise<Err<U, E | E2>>;\n  andThenAsync<U, E2, R extends AnyResult = Result<T, E>>(\n    this: R,\n    _fn: (a: InferOk<R>) => Promise<Result<U, E2>>,\n  ): Promise<AndThenReturn<R, U, E2>>;\n  andThenAsync<U, E2>(_fn: (a: never) => Promise<Result<U, E2>>): Promise<Err<U, E | E2>> {\n    // SAFETY: T is phantom, E⊂(E|E2) so error type widens safely.\n    return Promise.resolve(this as unknown as Err<U, E | E2>);\n  }\n\n  /**\n   * Pattern matches on Result.\n   *\n   * @template R Return type.\n   * @param handlers Ok and err handlers.\n   * @returns Result of err handler.\n   * @throws {Panic} If handler throws.\n   *\n   * @example\n   * err(\"fail\").match({ ok: x => x, err: e => e.length }) // 4\n   */\n  match<U>(this: Err<T, E>, handlers: { ok: (a: never) => U; err: (e: E) => U }): U;\n  match<U, R extends AnyResult = Result<T, E>>(\n    this: R,\n    handlers: { ok: (a: InferOk<R>) => U; err: (e: InferErr<R>) => U },\n  ): U;\n  match<R>(handlers: { ok: (a: never) => R; err: (e: E) => R }): R {\n    return tryOrPanic(() => handlers.err(this.error), \"match err handler threw\");\n  }\n\n  /**\n   * Throws error with optional message.\n   *\n   * @param message Error message.\n   * @throws Always throws.\n   *\n   * @example\n   * err(\"fail\").unwrap() // throws Error\n   * err(\"fail\").unwrap(\"custom\") // throws Error(\"custom\")\n   */\n  unwrap(message?: string): never {\n    return panic(message ?? `Unwrap called on Err: ${String(this.error)}`, this.error);\n  }\n\n  /**\n   * Returns fallback value.\n   *\n   * @template U Fallback type.\n   * @param fallback Fallback value.\n   * @returns Fallback.\n   *\n   * @example\n   * err(\"fail\").unwrapOr(42) // 42\n   */\n  unwrapOr<U>(fallback: U): T | U {\n    return fallback;\n  }\n\n  /**\n   * No-op on Err, returns self.\n   *\n   * @param _fn Ignored.\n   * @returns Self.\n   */\n  tap(this: Err<T, E>, _fn: (a: never) => void): Err<T, E>;\n  tap<R extends AnyResult = Result<T, E>>(this: R, _fn: (a: InferOk<R>) => void): R;\n  tap(_fn: (a: never) => void): Err<T, E> {\n    return this;\n  }\n\n  /**\n   * Runs side effect on error, returns self.\n   *\n   * @param fn Side effect function.\n   * @returns Self.\n   * @throws {Panic} If fn throws.\n   *\n   * @example\n   * err(\"fail\").tapError(console.error) // logs \"fail\", returns Err(\"fail\")\n   */\n  tapError(this: Err<T, E>, fn: (e: E) => void): Err<T, E>;\n  tapError<R extends AnyResult = Result<T, E>>(this: R, fn: (e: InferErr<R>) => void): R;\n  tapError(fn: (e: E) => void): Err<T, E> {\n    return tryOrPanic(() => {\n      fn(this.error);\n      return this;\n    }, \"tapError callback threw\");\n  }\n\n  /**\n   * No-op on Err, returns Promise of self.\n   *\n   * @param _fn Ignored.\n   * @returns Promise of self.\n   */\n  tapAsync(this: Err<T, E>, _fn: (a: never) => Promise<void>): Promise<Err<T, E>>;\n  tapAsync<R extends AnyResult = Result<T, E>>(\n    this: R,\n    _fn: (a: InferOk<R>) => Promise<void>,\n  ): Promise<R>;\n  tapAsync(_fn: (a: never) => Promise<void>): Promise<Err<T, E>> {\n    return Promise.resolve(this);\n  }\n\n  /**\n   * Runs async side effect on error, returns self.\n   *\n   * @param fn Async side effect function.\n   * @returns Promise of self.\n   * @throws {Panic} If fn throws synchronously or rejects.\n   *\n   * @example\n   * await err(\"fail\").tapErrorAsync(async e => await trace(\"request.failed\", { e }))\n   */\n  tapErrorAsync(this: Err<T, E>, fn: (e: E) => Promise<void>): Promise<Err<T, E>>;\n  tapErrorAsync<R extends AnyResult = Result<T, E>>(\n    this: R,\n    fn: (e: InferErr<R>) => Promise<void>,\n  ): Promise<R>;\n  tapErrorAsync(fn: (e: E) => Promise<void>): Promise<Err<T, E>> {\n    return tryOrPanicAsync(async () => {\n      await fn(this.error);\n      return this;\n    }, \"tapErrorAsync callback threw\");\n  }\n\n  /**\n   * Skips ok side effect, runs err side effect, returns self.\n   *\n   * @param handlers Ok and err side effect handlers.\n   * @returns Self.\n   * @throws {Panic} If err handler throws.\n   */\n  tapBoth(this: Err<T, E>, handlers: TapBothErrHandlers<E>): Err<T, E>;\n  tapBoth<R extends AnyResult = Result<T, E>>(this: R, handlers: TapBothHandlersFor<R>): R;\n  tapBoth(handlers: TapBothErrHandlers<E>): Err<T, E> {\n    return tryOrPanic(() => {\n      handlers.err(this.error);\n      return this;\n    }, \"tapBoth err callback threw\");\n  }\n\n  /**\n   * Skips async ok side effect, runs async err side effect, returns self.\n   *\n   * @param handlers Ok and err async side effect handlers.\n   * @returns Promise of self.\n   * @throws {Panic} If err handler throws synchronously or rejects.\n   */\n  tapBothAsync(this: Err<T, E>, handlers: TapBothAsyncErrHandlers<E>): Promise<Err<T, E>>;\n  tapBothAsync<R extends AnyResult = Result<T, E>>(\n    this: R,\n    handlers: TapBothAsyncHandlersFor<R>,\n  ): Promise<R>;\n  tapBothAsync(handlers: TapBothAsyncErrHandlers<E>): Promise<Err<T, E>> {\n    return tryOrPanicAsync(async () => {\n      await handlers.err(this.error);\n      return this;\n    }, \"tapBothAsync err callback threw\");\n  }\n\n  /**\n   * Makes Err yieldable in Result.gen blocks.\n   * Yields Err<never, E> for proper union inference across multiple yields.\n   */\n  *[Symbol.iterator](): Generator<Err<never, E>, never, unknown> {\n    // SAFETY: T is phantom (not used at runtime). Casting to Err<never, E>\n    // ensures all yields have phantom T as `never`, enabling TypeScript to\n    // unify: Err<never, E1> | Err<never, E2> extracts to E1 | E2\n    yield this as unknown as Err<never, E>;\n    return panic(\"Unreachable: Err yielded in Result.gen but generator continued\", this.error);\n  }\n}\n\n/**\n * Discriminated union representing operation success or failure.\n *\n * Both Ok and Err carry phantom types for the \"other\" variant:\n * - Ok<T, E>: T is value, E is phantom error type\n * - Err<T, E>: T is phantom success type, E is error\n *\n * This symmetric structure enables proper type inference in generator-based composition.\n *\n * @template T Success value type.\n * @template E Error value type.\n *\n * @example\n * type ParseResult = Result<number, ParseError>;\n */\nexport type Result<T, E> = Ok<T, E> | Err<T, E>;\n\n/**\n * Infer the Ok value type from a Result.\n * Distributive: InferOk<Ok<A, X> | Ok<B, Y>> = A | B\n */\nexport type InferOk<R> = R extends Ok<infer T, unknown> ? T : never;\n\n/**\n * Infer the Err value type from a Result.\n * Distributive: InferErr<Err<X, A> | Err<Y, B>> = A | B\n */\nexport type InferErr<R> = R extends Err<unknown, infer E> ? E : never;\n\n/**\n * Constraint for any union of Ok/Err types.\n * Used in Result.gen to accept flexible return types from generators.\n */\nexport type AnyResult = Ok<unknown, unknown> | Err<unknown, unknown>;\n\nexport function ok(): Ok<void, never>;\nexport function ok<A, E = never>(value: A): Ok<A, E>;\nexport function ok(value?: unknown): Ok<unknown, never> {\n  return new Ok(value);\n}\n\nexport const isOk = <A, E>(result: Result<A, E>): result is Ok<A, E> => {\n  return result.status === \"ok\";\n};\n\nexport const err = <T = never, E = unknown>(error: E): Err<T, E> => new Err<T, E>(error);\n\nexport const isError = <T, E>(result: Result<T, E>): result is Err<T, E> => {\n  return result.status === \"error\";\n};\n","import { dual } from \"./dual\";\nimport { err, panic, type Err } from \"./core\";\n\n/** Serialize cause for JSON output */\nconst serializeCause = (cause: unknown): unknown => {\n  if (cause instanceof Error) {\n    return { name: cause.name, message: cause.message, stack: cause.stack };\n  }\n  return cause;\n};\n\n/** Any tagged error (for generic constraints) */\ntype AnyTaggedError = Error & { readonly _tag: string };\n\n/** Type guard for any tagged error */\nconst isAnyTaggedError = (value: unknown): value is AnyTaggedError => {\n  return value instanceof Error && \"_tag\" in value && typeof value._tag === \"string\";\n};\n\n/**\n * Factory for tagged error classes.\n *\n * @example\n * class NotFoundError extends TaggedError(\"NotFoundError\")<{\n *   id: string;\n *   message: string;\n * }>() {}\n *\n * const err = new NotFoundError({ id: \"123\", message: \"Not found: 123\" });\n * err._tag    // \"NotFoundError\"\n * err.id      // \"123\"\n * err.message // \"Not found: 123\"\n *\n * // Check if any tagged error\n * TaggedError.is(err) // true\n */\nexport const TaggedError: {\n  <Tag extends string>(\n    tag: Tag,\n  ): <Props extends Record<string, unknown> = {}>() => TaggedErrorClass<Tag, Props>;\n  /** Type guard for any TaggedError instance */\n  is(value: unknown): value is AnyTaggedError;\n} = Object.assign(\n  <Tag extends string>(tag: Tag) =>\n    <Props extends Record<string, unknown> = {}>(): TaggedErrorClass<Tag, Props> => {\n      class Base extends Error {\n        readonly _tag: Tag = tag;\n\n        /** Type guard for this error class */\n        static is(value: unknown): value is Base {\n          return value instanceof Base;\n        }\n\n        constructor(args?: Props) {\n          const message =\n            args && \"message\" in args && typeof args.message === \"string\"\n              ? args.message\n              : undefined;\n          const cause = args && \"cause\" in args ? args.cause : undefined;\n\n          super(message, cause !== undefined ? { cause } : undefined);\n\n          if (args) {\n            Object.assign(this, args);\n          }\n\n          Object.setPrototypeOf(this, new.target.prototype);\n          this.name = tag;\n\n          if (cause instanceof Error && cause.stack) {\n            const indented = cause.stack.replace(/\\n/g, \"\\n  \");\n            this.stack = `${this.stack}\\nCaused by: ${indented}`;\n          }\n        }\n\n        toJSON(): object {\n          return {\n            ...this,\n            _tag: this._tag,\n            name: this.name,\n            message: this.message,\n            cause: serializeCause(this.cause),\n            stack: this.stack,\n          };\n        }\n\n        /**\n         * Makes this TaggedError yieldable in Result.gen blocks.\n         * Yielding short-circuits with this error, matching Err semantics.\n         */\n        *[Symbol.iterator](): Generator<Err<never, this>, never, unknown> {\n          yield* err(this);\n          return panic(\"Unreachable: Err yielded in TaggedError but generator continued\", this);\n        }\n      }\n\n      // SAFETY: Cast needed for factory pattern - Props are assigned via Object.assign\n      return Base as unknown as TaggedErrorClass<Tag, Props>;\n    },\n  { is: isAnyTaggedError },\n);\n\ninterface IterableError extends Error {\n  /** Makes TaggedError instances yieldable in Result.gen blocks. */\n  [Symbol.iterator](): Generator<Err<never, this>, never, unknown>;\n}\n\n/** Instance type produced by TaggedError factory */\nexport type TaggedErrorInstance<Tag extends string, Props> = IterableError & {\n  readonly _tag: Tag;\n  toJSON(): object;\n} & Readonly<Props>;\n\n/** Class type produced by TaggedError factory */\nexport type TaggedErrorClass<Tag extends string, Props> = {\n  new (\n    ...args: keyof Props extends never ? [args?: {}] : [args: Props]\n  ): TaggedErrorInstance<Tag, Props>;\n  /** Type guard for this error class */\n  is(value: unknown): value is TaggedErrorInstance<Tag, Props>;\n};\n\n/** Handler map for exhaustive matching */\ntype MatchHandlers<E extends AnyTaggedError, R> = {\n  [K in E[\"_tag\"]]: (err: Extract<E, { _tag: K }>) => R;\n};\n\n/** Partial handler map for non-exhaustive matching */\ntype PartialMatchHandlers<E extends AnyTaggedError, R> = Partial<MatchHandlers<E, R>>;\n\n/** Extract handled tags from a handlers object */\ntype HandledTags<E extends AnyTaggedError, H> = Extract<keyof H, E[\"_tag\"]>;\n\n/**\n * Exhaustive pattern match on tagged error union.\n *\n * @example\n * // Data-first\n * matchError(err, {\n *   NotFoundError: (e) => `Missing: ${e.id}`,\n *   ValidationError: (e) => `Invalid: ${e.field}`,\n * });\n *\n * // Data-last (pipeable)\n * pipe(err, matchError({\n *   NotFoundError: (e) => `Missing: ${e.id}`,\n *   ValidationError: (e) => `Invalid: ${e.field}`,\n * }));\n */\nexport const matchError: {\n  <E extends AnyTaggedError, R>(handlers: MatchHandlers<E, R>): (err: E) => R;\n  <E extends AnyTaggedError, R>(err: E, handlers: MatchHandlers<E, R>): R;\n} = dual(2, <E extends AnyTaggedError, R>(err: E, handlers: MatchHandlers<E, R>): R => {\n  const handler = handlers[err._tag as E[\"_tag\"]];\n  // SAFETY: handler exists if handlers satisfies MatchHandlers<E, R>\n  return handler(err as Extract<E, { _tag: (typeof err)[\"_tag\"] }>);\n});\n\n/**\n * Partial pattern match with fallback for unhandled tags.\n *\n * @example\n * matchErrorPartial(err, {\n *   NotFoundError: (e) => `Missing: ${e.id}`,\n * }, (e) => `Unknown: ${e.message}`);\n */\nexport const matchErrorPartial: {\n  <\n    E extends AnyTaggedError,\n    R,\n    const H extends PartialMatchHandlers<E, R> = PartialMatchHandlers<E, R>,\n  >(\n    handlers: H,\n    fallback: (e: Exclude<E, { _tag: NoInfer<HandledTags<E, H>> }>) => R,\n  ): (err: E) => R;\n  <E extends AnyTaggedError, R, const H extends PartialMatchHandlers<E, R>>(\n    err: E,\n    handlers: H,\n    fallback: (e: Exclude<E, { _tag: NoInfer<HandledTags<E, H>> }>) => R,\n  ): R;\n} = dual(\n  3,\n  <E extends AnyTaggedError, R, H extends PartialMatchHandlers<E, R>>(\n    err: E,\n    handlers: H,\n    fallback: (e: Exclude<E, { _tag: HandledTags<E, H> }>) => R,\n  ): R => {\n    type K = HandledTags<E, H>;\n    const handler = handlers[err._tag as K];\n    if (typeof handler === \"function\") {\n      // SAFETY: handler exists and matches the tag\n      return handler(err as Parameters<NonNullable<typeof handler>>[0]);\n    }\n    // SAFETY: If no handler matched, err is in the Exclude type\n    return fallback(err as Exclude<E, { _tag: K }>);\n  },\n);\n\n/**\n * Type guard for tagged error instances.\n *\n * @example\n * if (isTaggedError(value)) { value._tag }\n */\nexport const isTaggedError = isAnyTaggedError;\n\n/**\n * Wraps exceptions caught by Result.try/tryPromise.\n * Custom constructor derives message from cause.\n */\nexport class UnhandledException extends TaggedError(\"UnhandledException\")<{\n  message: string;\n  cause: unknown;\n}>() {\n  constructor(args: { cause: unknown }) {\n    const message =\n      args.cause instanceof Error\n        ? `Unhandled exception: ${args.cause.message}`\n        : `Unhandled exception: ${String(args.cause)}`;\n    super({ message, cause: args.cause });\n  }\n}\n\n/**\n * Returned when Result.deserialize receives invalid input.\n *\n * @example\n * const result = Result.deserialize(invalidData);\n * if (Result.isError(result) && ResultDeserializationError.is(result.error)) {\n *   console.log(\"Invalid input:\", result.error.value);\n * }\n */\nexport class ResultDeserializationError extends TaggedError(\"ResultDeserializationError\")<{\n  message: string;\n  value: unknown;\n}>() {\n  constructor(args: { value: unknown }) {\n    super({\n      message: `Failed to deserialize value as Result: expected { status: \"ok\", value } or { status: \"error\", error }`,\n      value: args.value,\n    });\n  }\n}\n\nexport { Panic, isPanic, panic } from \"./core\";\n","import { dual } from \"./dual\";\nimport { ResultDeserializationError, UnhandledException } from \"./error\";\nimport {\n  Err,\n  Ok,\n  err,\n  isError,\n  isOk,\n  ok,\n  panic,\n  type AnyResult,\n  type InferErr,\n  type InferOk,\n  type TapBothAsyncHandlers,\n  type TapBothHandlers,\n} from \"./core\";\n\nexport { Err, Ok } from \"./core\";\nexport type { InferErr, InferOk } from \"./core\";\nexport type Result<T, E> = import(\"./core\").Result<T, E>;\n\n/** Executes fn, panics if it throws. */\nconst tryOrPanic = <T>(fn: () => T, message: string): T => {\n  try {\n    return fn();\n  } catch (cause) {\n    throw panic(message, cause);\n  }\n};\n\n/**\n * Extracts error type E from yield union in Result.gen.\n * Yields are always Err<never, E>, so we match on that pattern.\n * Distributive conditional: InferYieldErr<Err<never, A> | Err<never, B>> = A | B\n */\ntype InferYieldErr<Y> = Y extends Err<never, infer E> ? E : never;\n\ntype NoInfer<T> = [T][T extends unknown ? 0 : never];\n\nconst tryFn: {\n  <A, E>(\n    options: { try: () => Awaited<A>; catch: (cause: unknown) => Awaited<E> },\n    config?: { retry?: { times: number } },\n  ): Result<A, E>;\n  <A>(\n    thunk: () => Awaited<A>,\n    config?: { retry?: { times: number } },\n  ): Result<A, UnhandledException>;\n} = <A, E>(\n  options: (() => Awaited<A>) | { try: () => Awaited<A>; catch: (cause: unknown) => Awaited<E> },\n  config?: { retry?: { times: number } },\n): Result<A, E | UnhandledException> => {\n  const execute = (): Result<A, E | UnhandledException> => {\n    if (typeof options === \"function\") {\n      try {\n        return ok(options());\n      } catch (cause) {\n        return err(new UnhandledException({ cause }));\n      }\n    }\n    try {\n      return ok(options.try());\n    } catch (originalCause) {\n      // If the user's catch handler throws, it's a defect — Panic\n      try {\n        return err(options.catch(originalCause));\n      } catch (catchHandlerError) {\n        throw panic(\"Result.try catch handler threw\", catchHandlerError);\n      }\n    }\n  };\n\n  const times = config?.retry?.times ?? 0;\n  let result = execute();\n\n  for (let retry = 0; retry < times && result.status === \"error\"; retry++) {\n    result = execute();\n  }\n\n  return result;\n};\n\ntype RetryConfig<E = unknown> = {\n  retry?: {\n    times: number;\n    delayMs: number;\n    backoff: \"linear\" | \"constant\" | \"exponential\";\n    /** Predicate to determine if an error should trigger a retry. Defaults to always retry. */\n    shouldRetry?: (error: E) => boolean;\n  };\n};\n\nconst tryPromise: {\n  <A, E>(\n    options: { try: () => Promise<A>; catch: (cause: unknown) => E | Promise<E> },\n    config?: RetryConfig<E>,\n  ): Promise<Result<A, E>>;\n  <A>(\n    thunk: () => Promise<A>,\n    config?: RetryConfig<UnhandledException>,\n  ): Promise<Result<A, UnhandledException>>;\n} = async <A, E>(\n  options:\n    | (() => Promise<A>)\n    | { try: () => Promise<A>; catch: (cause: unknown) => E | Promise<E> },\n  config?: RetryConfig<E | UnhandledException>,\n): Promise<Result<A, E | UnhandledException>> => {\n  const execute = async (): Promise<Result<A, E | UnhandledException>> => {\n    if (typeof options === \"function\") {\n      try {\n        return ok(await options());\n      } catch (cause) {\n        return err(new UnhandledException({ cause }));\n      }\n    }\n    try {\n      return ok(await options.try());\n    } catch (originalCause) {\n      // If the user's catch handler throws, it's a defect — Panic\n      try {\n        return err(await options.catch(originalCause));\n      } catch (catchHandlerError) {\n        throw panic(\"Result.tryPromise catch handler threw\", catchHandlerError);\n      }\n    }\n  };\n\n  const retry = config?.retry;\n\n  if (!retry) {\n    return execute();\n  }\n\n  const getDelay = (retryAttempt: number): number => {\n    switch (retry.backoff) {\n      case \"constant\":\n        return retry.delayMs;\n      case \"linear\":\n        return retry.delayMs * (retryAttempt + 1);\n      case \"exponential\":\n        return retry.delayMs * 2 ** retryAttempt;\n    }\n  };\n\n  const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));\n\n  let result = await execute();\n\n  const shouldRetryFn = retry.shouldRetry ?? (() => true);\n\n  for (let attempt = 0; attempt < retry.times; attempt++) {\n    if (result.status !== \"error\") break;\n    const error = result.error;\n    const shouldContinue = tryOrPanic(() => shouldRetryFn(error), \"shouldRetry predicate threw\");\n    if (!shouldContinue) break;\n    await sleep(getDelay(attempt));\n    result = await execute();\n  }\n\n  return result;\n};\n\nconst map: {\n  <A, B, E>(result: Result<A, E>, fn: (a: A) => B): Result<B, E>;\n  <A, B>(fn: (a: A) => B): <E>(result: Result<A, E>) => Result<B, E>;\n} = dual(2, <A, B, E>(result: Result<A, E>, fn: (a: A) => B): Result<B, E> => {\n  return result.map(fn);\n});\n\nconst mapError: {\n  <A, E, E2>(result: Result<A, E>, fn: (e: E) => E2): Result<A, E2>;\n  <E, E2>(fn: (e: E) => E2): <A>(result: Result<A, E>) => Result<A, E2>;\n} = dual(2, <A, E, E2>(result: Result<A, E>, fn: (e: E) => E2): Result<A, E2> => {\n  return result.mapError(fn);\n});\n\nconst tryRecover: {\n  <A, E, E2>(result: Result<A, E>, fn: (e: E) => Result<NoInfer<A>, E2>): Result<A, E2>;\n  <E, E2>(fn: (e: E) => Result<never, E2>): <A>(result: Result<A, E>) => Result<A, E2>;\n  <E, A, E2>(fn: (e: E) => Result<A, E2>): (result: Result<A, E>) => Result<A, E2>;\n} = dual(\n  2,\n  <A, E, E2>(result: Result<A, E>, fn: (e: E) => Result<NoInfer<A>, E2>): Result<A, E2> => {\n    return result.tryRecover(fn);\n  },\n);\n\nconst andThen: {\n  <A, B, E, E2>(result: Result<A, E>, fn: (a: A) => Result<B, E2>): Result<B, E | E2>;\n  <A, B, E2>(fn: (a: A) => Result<B, E2>): <E>(result: Result<A, E>) => Result<B, E | E2>;\n} = dual(2, <A, B, E, E2>(result: Result<A, E>, fn: (a: A) => Result<B, E2>): Result<B, E | E2> => {\n  return result.andThen(fn);\n});\n\nconst tryRecoverAsync: {\n  <A, E, E2>(\n    result: Result<A, E>,\n    fn: (e: E) => Promise<Result<NoInfer<A>, E2>>,\n  ): Promise<Result<A, E2>>;\n  <E, E2>(\n    fn: (e: E) => Promise<Result<never, E2>>,\n  ): <A>(result: Result<A, E>) => Promise<Result<A, E2>>;\n  <E, A, E2>(\n    fn: (e: E) => Promise<Result<A, E2>>,\n  ): (result: Result<A, E>) => Promise<Result<A, E2>>;\n} = dual(\n  2,\n  <A, E, E2>(\n    result: Result<A, E>,\n    fn: (e: E) => Promise<Result<NoInfer<A>, E2>>,\n  ): Promise<Result<A, E2>> => {\n    return result.tryRecoverAsync(fn);\n  },\n);\n\nconst andThenAsync: {\n  <A, B, E, E2>(\n    result: Result<A, E>,\n    fn: (a: A) => Promise<Result<B, E2>>,\n  ): Promise<Result<B, E | E2>>;\n  <A, B, E2>(\n    fn: (a: A) => Promise<Result<B, E2>>,\n  ): <E>(result: Result<A, E>) => Promise<Result<B, E | E2>>;\n} = dual(\n  2,\n  <A, B, E, E2>(\n    result: Result<A, E>,\n    fn: (a: A) => Promise<Result<B, E2>>,\n  ): Promise<Result<B, E | E2>> => {\n    return result.andThenAsync(fn);\n  },\n);\n\nconst match: {\n  <A, E, T>(handlers: { ok: (a: A) => T; err: (e: E) => T }): (result: Result<A, E>) => T;\n  <A, E, T>(result: Result<A, E>, handlers: { ok: (a: A) => T; err: (e: E) => T }): T;\n} = dual(2, <A, E, T>(result: Result<A, E>, handlers: { ok: (a: A) => T; err: (e: E) => T }): T => {\n  return result.match(handlers);\n});\n\nconst tap: {\n  <A, E>(result: Result<A, E>, fn: (a: A) => void): Result<A, E>;\n  <A>(fn: (a: A) => void): <E>(result: Result<A, E>) => Result<A, E>;\n} = dual(2, <A, E>(result: Result<A, E>, fn: (a: A) => void): Result<A, E> => {\n  return result.tap(fn);\n});\n\nconst tapAsync: {\n  <A, E>(result: Result<A, E>, fn: (a: A) => Promise<void>): Promise<Result<A, E>>;\n  <A>(fn: (a: A) => Promise<void>): <E>(result: Result<A, E>) => Promise<Result<A, E>>;\n} = dual(2, <A, E>(result: Result<A, E>, fn: (a: A) => Promise<void>): Promise<Result<A, E>> => {\n  return result.tapAsync(fn);\n});\n\nconst tapError: {\n  <A, E>(result: Result<A, E>, fn: (e: E) => void): Result<A, E>;\n  <E>(fn: (e: E) => void): <A>(result: Result<A, E>) => Result<A, E>;\n} = dual(2, <A, E>(result: Result<A, E>, fn: (e: E) => void): Result<A, E> => {\n  return result.tapError(fn);\n});\n\nconst tapErrorAsync: {\n  <A, E>(result: Result<A, E>, fn: (e: E) => Promise<void>): Promise<Result<A, E>>;\n  <E>(fn: (e: E) => Promise<void>): <A>(result: Result<A, E>) => Promise<Result<A, E>>;\n} = dual(2, <A, E>(result: Result<A, E>, fn: (e: E) => Promise<void>): Promise<Result<A, E>> => {\n  return result.tapErrorAsync(fn);\n});\n\nconst tapBoth: {\n  <A, E>(handlers: TapBothHandlers<A, E>): (result: Result<A, E>) => Result<A, E>;\n  <A, E>(result: Result<A, E>, handlers: TapBothHandlers<A, E>): Result<A, E>;\n} = dual(2, <A, E>(result: Result<A, E>, handlers: TapBothHandlers<A, E>): Result<A, E> => {\n  return result.tapBoth(handlers);\n});\n\nconst tapBothAsync: {\n  <A, E>(handlers: TapBothAsyncHandlers<A, E>): (result: Result<A, E>) => Promise<Result<A, E>>;\n  <A, E>(result: Result<A, E>, handlers: TapBothAsyncHandlers<A, E>): Promise<Result<A, E>>;\n} = dual(\n  2,\n  <A, E>(result: Result<A, E>, handlers: TapBothAsyncHandlers<A, E>): Promise<Result<A, E>> => {\n    return result.tapBothAsync(handlers);\n  },\n);\n\nconst unwrap = <A, E>(result: Result<A, E>, message?: string): A => {\n  return result.unwrap(message);\n};\n\n/** Validates that a value is a Result instance. Throws with helpful message if not. */\nfunction assertIsResult(value: unknown): asserts value is Result<unknown, unknown> {\n  if (\n    value !== null &&\n    typeof value === \"object\" &&\n    \"status\" in value &&\n    (value.status === \"ok\" || value.status === \"error\")\n  ) {\n    return;\n  }\n  return panic(\n    \"Result.gen body must return Result.ok() or Result.err(), got: \" +\n      (value === null ? \"null\" : typeof value === \"object\" ? JSON.stringify(value) : String(value)),\n  );\n}\n\nconst unwrapOr: {\n  <A, E, B>(result: Result<A, E>, fallback: B): A | B;\n  <B>(fallback: B): <A, E>(result: Result<A, E>) => A | B;\n} = dual(2, <A, E, B>(result: Result<A, E>, fallback: B): A | B => {\n  return result.unwrapOr(fallback);\n});\n\nconst gen: {\n  <Yield extends Err<never, unknown>, R extends AnyResult>(\n    body: () => Generator<Yield, R, unknown>,\n  ): Result<InferOk<R>, InferYieldErr<Yield> | InferErr<R>>;\n  <Yield extends Err<never, unknown>, R extends AnyResult, This>(\n    body: (this: This) => Generator<Yield, R, unknown>,\n    thisArg: This,\n  ): Result<InferOk<R>, InferYieldErr<Yield> | InferErr<R>>;\n  <Yield extends Err<never, unknown>, R extends AnyResult>(\n    body: () => AsyncGenerator<Yield, R, unknown>,\n  ): Promise<Result<InferOk<R>, InferYieldErr<Yield> | InferErr<R>>>;\n  <Yield extends Err<never, unknown>, R extends AnyResult, This>(\n    body: (this: This) => AsyncGenerator<Yield, R, unknown>,\n    thisArg: This,\n  ): Promise<Result<InferOk<R>, InferYieldErr<Yield> | InferErr<R>>>;\n} = (<Yield extends Err<never, unknown>, R extends AnyResult, This>(\n  body:\n    | (() => Generator<Yield, R, unknown>)\n    | (() => AsyncGenerator<Yield, R, unknown>)\n    | ((this: This) => Generator<Yield, R, unknown>)\n    | ((this: This) => AsyncGenerator<Yield, R, unknown>),\n  thisArg?: This,\n):\n  | Result<InferOk<R>, InferYieldErr<Yield> | InferErr<R>>\n  | Promise<Result<InferOk<R>, InferYieldErr<Yield> | InferErr<R>>> => {\n  // SAFETY: body.call binds thisArg; cast needed due to union of function signatures\n  const iterator = (body as (this: This) => Generator<Yield, R, unknown>).call(thisArg as This);\n\n  // Detect async generator via Symbol.asyncIterator\n  if (Symbol.asyncIterator in iterator) {\n    return (async () => {\n      // SAFETY: Async check above guarantees this is an async generator\n      const asyncIter = iterator as unknown as AsyncGenerator<Yield, R, unknown>;\n\n      let state: IteratorResult<Yield, R>;\n      try {\n        state = await asyncIter.next();\n      } catch (cause) {\n        // Generator body threw before yielding (user code error or cleanup on success path)\n        throw panic(\"generator body threw\", cause);\n      }\n\n      assertIsResult(state.value);\n\n      if (!state.done) {\n        // Close generator to run finally blocks and Symbol.asyncDispose.\n        // If cleanup throws, it's unrecoverable — Panic.\n        try {\n          await asyncIter.return?.(undefined as unknown as R);\n        } catch (cause) {\n          throw panic(\"generator cleanup threw\", cause);\n        }\n      }\n\n      return state.value as Result<InferOk<R>, InferYieldErr<Yield> | InferErr<R>>;\n    })();\n  }\n\n  // Sync generator\n  // SAFETY: If not async, must be sync generator\n  const syncIter = iterator as Generator<Yield, R, unknown>;\n\n  let state: IteratorResult<Yield, R>;\n  try {\n    state = syncIter.next();\n  } catch (cause) {\n    // Generator body threw before yielding (user code error or cleanup on success path)\n    throw panic(\"generator body threw\", cause);\n  }\n\n  assertIsResult(state.value);\n\n  if (!state.done) {\n    // Close generator to run finally blocks and Symbol.dispose.\n    // If cleanup throws, it's unrecoverable — Panic.\n    try {\n      syncIter.return?.(undefined as unknown as R);\n    } catch (cause) {\n      throw panic(\"generator cleanup threw\", cause);\n    }\n  }\n\n  return state.value as Result<InferOk<R>, InferYieldErr<Yield> | InferErr<R>>;\n}) as {\n  <Yield extends Err<never, unknown>, R extends AnyResult>(\n    body: () => Generator<Yield, R, unknown>,\n  ): Result<InferOk<R>, InferYieldErr<Yield> | InferErr<R>>;\n  <Yield extends Err<never, unknown>, R extends AnyResult, This>(\n    body: (this: This) => Generator<Yield, R, unknown>,\n    thisArg: This,\n  ): Result<InferOk<R>, InferYieldErr<Yield> | InferErr<R>>;\n  <Yield extends Err<never, unknown>, R extends AnyResult>(\n    body: () => AsyncGenerator<Yield, R, unknown>,\n  ): Promise<Result<InferOk<R>, InferYieldErr<Yield> | InferErr<R>>>;\n  <Yield extends Err<never, unknown>, R extends AnyResult, This>(\n    body: (this: This) => AsyncGenerator<Yield, R, unknown>,\n    thisArg: This,\n  ): Promise<Result<InferOk<R>, InferYieldErr<Yield> | InferErr<R>>>;\n};\n\nasync function* resultAwait<T, E>(\n  promise: Promise<Result<T, E>>,\n): AsyncGenerator<Err<never, E>, T, unknown> {\n  const result = await promise;\n  return yield* result;\n}\n\n/** Shape of a serialized Ok over RPC. */\nexport interface SerializedOk<T> {\n  status: \"ok\";\n  value: T;\n}\n\n/** Shape of a serialized Err over RPC. */\nexport interface SerializedErr<E> {\n  status: \"error\";\n  error: E;\n}\n\n/** Shape of a serialized Result over RPC. */\nexport type SerializedResult<T, E> = SerializedOk<T> | SerializedErr<E>;\n\nfunction isSerializedResult(obj: unknown): obj is SerializedResult<unknown, unknown> {\n  return (\n    obj !== null &&\n    typeof obj === \"object\" &&\n    \"status\" in obj &&\n    ((obj.status === \"ok\" && \"value\" in obj) || (obj.status === \"error\" && \"error\" in obj))\n  );\n}\n\nconst serialize = <T, E>(result: Result<T, E>): SerializedResult<T, E> => {\n  return result.status === \"ok\"\n    ? { status: \"ok\", value: result.value }\n    : { status: \"error\", error: result.error };\n};\n\nconst deserialize = <T, E>(value: unknown): Result<T, E | ResultDeserializationError> => {\n  if (isSerializedResult(value)) {\n    return value.status === \"ok\"\n      ? (new Ok(value.value) as Result<T, E>)\n      : (new Err(value.error) as Result<T, E>);\n  }\n  return err(new ResultDeserializationError({ value }));\n};\n\n/**\n * @deprecated Use `Result.deserialize` instead. Will be removed in 3.0.\n */\nconst hydrate = <T, E>(value: unknown): Result<T, E | ResultDeserializationError> => {\n  return deserialize(value);\n};\n\nconst partition = <T, E>(results: readonly Result<T, E>[]): [T[], E[]] => {\n  const oks: T[] = [];\n  const errs: E[] = [];\n  for (const r of results) {\n    if (r.status === \"ok\") {\n      oks.push(r.value);\n    } else {\n      errs.push(r.error);\n    }\n  }\n  return [oks, errs];\n};\n\n/**\n * Flattens nested Result into single Result.\n *\n * @example\n * const nested: Result<Result<number, E1>, E2> = Result.ok(Result.ok(42));\n * const flat: Result<number, E1 | E2> = Result.flatten(nested); // Ok(42)\n */\nconst flatten = <T, E, E2>(result: Result<Result<T, E>, E2>): Result<T, E | E2> => {\n  if (result.status === \"ok\") {\n    return result.value;\n  }\n  // SAFETY: T is phantom on Err (not used at runtime), widening E2 to E|E2 is safe\n  return result as unknown as Err<T, E | E2>;\n};\n\n/**\n * Utilities for creating and handling Result types.\n *\n * @example\n * const result = Result.try(() => JSON.parse(str));\n * const value = result.map(x => x.id).unwrapOr(\"default\");\n */\nexport const Result = {\n  /**\n   * Creates successful result.\n   *\n   * @example\n   * Result.ok(42)  // Ok<number, never>\n   * Result.ok()    // Ok<void, never> - for side-effectful operations\n   */\n  ok,\n  /**\n   * Type guard for Ok.\n   *\n   * @example\n   * if (Result.isOk(result)) { result.value }\n   */\n  isOk,\n  /**\n   * Creates error result.\n   *\n   * @example\n   * Result.err(\"failed\") // Err(\"failed\")\n   */\n  err,\n  /**\n   * Type guard for Err.\n   *\n   * @example\n   * if (Result.isError(result)) { result.error }\n   */\n  isError,\n  /**\n   * Executes sync function, wraps result/error in Result.\n   *\n   * @example\n   * Result.try(() => JSON.parse(str))\n   * Result.try({ try: () => parse(x), catch: e => new ParseError(e) })\n   */\n  try: tryFn,\n  /**\n   * Executes async function, wraps result/error in Result with retry support.\n   *\n   * @example\n   * // Basic retry\n   * await Result.tryPromise(() => fetch(url), {\n   *   retry: { times: 3, delayMs: 100, backoff: \"exponential\" }\n   * })\n   *\n   * @example\n   * // Retry only for specific error types (user-defined TaggedError classes)\n   * await Result.tryPromise({\n   *   try: () => fetch(url),\n   *   catch: e => e instanceof TypeError ? new RetryableError(e) : new FatalError(e)\n   * }, {\n   *   retry: {\n   *     times: 3,\n   *     delayMs: 100,\n   *     backoff: \"exponential\",\n   *     shouldRetry: e => e._tag === \"RetryableError\"\n   *   }\n   * })\n   *\n   * @example\n   * // Async retry decisions: enrich error in catch handler\n   * await Result.tryPromise({\n   *   try: () => callApi(url),\n   *   catch: async (e) => {\n   *     const limited = await redis.get(`ratelimit:${userId}`);\n   *     return new ApiError({ cause: e, rateLimited: !!limited });\n   *   }\n   * }, {\n   *   retry: { times: 3, delayMs: 100, backoff: \"exponential\", shouldRetry: e => !e.rateLimited }\n   * })\n   */\n  tryPromise,\n  /**\n   * Transforms success value, passes error through.\n   *\n   * @example\n   * Result.map(ok(2), x => x * 2) // Ok(4)\n   * Result.map(x => x * 2)(ok(2)) // Ok(4)\n   */\n  map,\n  /**\n   * Transforms error value, passes success through.\n   *\n   * @example\n   * Result.mapError(err(\"fail\"), e => new Error(e)) // Err(Error(\"fail\"))\n   */\n  mapError,\n  /**\n   * Attempts to recover from an error into the same success type.\n   *\n   * @example\n   * Result.tryRecover(err(\"fail\"), e => ok(e.length)) // Ok(4)\n   * Result.tryRecover(e => ok(e.length))(err(\"fail\")) // Ok(4)\n   */\n  tryRecover,\n  /**\n   * Chains Result-returning function on success.\n   *\n   * @example\n   * Result.andThen(ok(2), x => x > 0 ? ok(x) : err(\"neg\")) // Ok(2)\n   */\n  andThen,\n  /**\n   * Attempts to recover from an error into the same success type asynchronously.\n   *\n   * @example\n   * await Result.tryRecoverAsync(err(\"fail\"), async e => ok(e.length)) // Ok(4)\n   * await Result.tryRecoverAsync(async e => ok(e.length))(err(\"fail\")) // Ok(4)\n   */\n  tryRecoverAsync,\n  /**\n   * Chains async Result-returning function on success.\n   *\n   * @example\n   * await Result.andThenAsync(ok(1), async x => ok(await fetch(x)))\n   */\n  andThenAsync,\n  /**\n   * Pattern matches on Result.\n   *\n   * @example\n   * Result.match(ok(2), { ok: x => x * 2, err: () => 0 }) // 4\n   */\n  match,\n  /**\n   * Runs side effect on success value, returns original result.\n   *\n   * @example\n   * Result.tap(ok(2), console.log) // logs 2, returns Ok(2)\n   */\n  tap,\n  /**\n   * Runs async side effect on success value, returns original result.\n   *\n   * @example\n   * await Result.tapAsync(ok(2), async x => await log(x))\n   */\n  tapAsync,\n  /**\n   * Runs side effect on error value, returns original result.\n   *\n   * @example\n   * Result.tapError(err(\"fail\"), console.error) // logs \"fail\", returns Err(\"fail\")\n   * Result.tapError(console.error)(err(\"fail\")) // logs \"fail\", returns Err(\"fail\")\n   */\n  tapError,\n  /**\n   * Runs async side effect on error value, returns original result.\n   *\n   * @example\n   * await Result.tapErrorAsync(err(\"fail\"), async e => await reportError(e))\n   * await Result.tapErrorAsync(async e => await reportError(e))(err(\"fail\"))\n   */\n  tapErrorAsync,\n  /**\n   * Runs side effect on either branch, returns original result.\n   *\n   * @example\n   * Result.tapBoth(ok(2), { ok: console.log, err: console.error })\n   * Result.tapBoth({ ok: console.log, err: console.error })(err(\"fail\"))\n   */\n  tapBoth,\n  /**\n   * Runs async side effect on either branch, returns original result.\n   *\n   * @example\n   * await Result.tapBothAsync(ok(2), { ok: async x => await log(x), err: async e => await reportError(e) })\n   * await Result.tapBothAsync({ ok: async x => await log(x), err: async e => await reportError(e) })(err(\"fail\"))\n   */\n  tapBothAsync,\n  /**\n   * Extracts value or throws.\n   *\n   * @example\n   * Result.unwrap(ok(42)) // 42\n   * Result.unwrap(err(\"fail\")) // throws Error\n   */\n  unwrap,\n  /**\n   * Extracts value or returns fallback.\n   *\n   * @example\n   * Result.unwrapOr(ok(42), 0) // 42\n   * Result.unwrapOr(err(\"fail\"), 0) // 0\n   */\n  unwrapOr,\n  /**\n   * Generator-based composition for Result types.\n   * Errors from yielded Results form a union; use mapError to normalize.\n   *\n   * @example\n   * const result = Result.gen(function* () {\n   *   const a = yield* getA(); // Err: ErrorA\n   *   const b = yield* getB(a); // Err: ErrorB\n   *   return Result.ok({ a, b });\n   * });\n   * // Result<{a, b}, ErrorA | ErrorB>\n   *\n   * @example\n   * // Normalize error types with mapError\n   * const result = Result.gen(function* () {\n   *   const a = yield* getA();\n   *   const b = yield* getB(a);\n   *   return Result.ok({ a, b });\n   * }).mapError(e => new UnifiedError(e._tag, e.message));\n   * // Result<{a, b}, UnifiedError>\n   *\n   * @example\n   * // Async with Result.await\n   * const result = await Result.gen(async function* () {\n   *   const a = yield* Result.await(fetchA());\n   *   const b = yield* Result.await(fetchB(a));\n   *   return Result.ok({ a, b });\n   * });\n   */\n  gen,\n  /**\n   * Wraps Promise<Result> to be yieldable in async Result.gen blocks.\n   *\n   * @example\n   * yield* Result.await(fetchUser(id))\n   */\n  await: resultAwait,\n  /**\n   * Converts a Result to a plain object for serialization (e.g., RPC, server actions).\n   *\n   * @example\n   * const serialized = Result.serialize(ok(42)); // { status: \"ok\", value: 42 }\n   */\n  serialize,\n  /**\n   * Rehydrates serialized Result from RPC back into Ok/Err instances.\n   * Returns `Err<ResultDeserializationError>` if the input is not a valid serialized Result.\n   *\n   * @example\n   * // Valid serialized Result\n   * const result = Result.deserialize<User, AppError>(rpcResponse);\n   * if (Result.isOk(result)) {\n   *   console.log(result.value); // User\n   * }\n   *\n   * // Invalid input returns ResultDeserializationError\n   * const invalid = Result.deserialize({ foo: \"bar\" });\n   * if (Result.isError(invalid) && ResultDeserializationError.is(invalid.error)) {\n   *   console.log(\"Bad input:\", invalid.error.value);\n   * }\n   */\n  deserialize,\n  /**\n   * @deprecated Use `Result.deserialize` instead. Will be removed in 3.0.\n   */\n  hydrate,\n  /**\n   * Splits array of Results into tuple of [okValues, errorValues].\n   *\n   * @example\n   * partition([ok(1), err(\"a\"), ok(2)]) // [[1, 2], [\"a\"]]\n   */\n  partition,\n  /**\n   * Flattens nested Result into single Result.\n   *\n   * @example\n   * const nested = Result.ok(Result.ok(42));\n   * Result.flatten(nested) // Ok(42)\n   */\n  flatten,\n} as const;\n"],"mappings":"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"}