1 line
48 KiB
Plaintext
1 line
48 KiB
Plaintext
{"version":3,"file":"index.mjs","names":["err","state"],"sources":["../src/dual.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","import { dual } from \"./dual\";\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 // 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\n/** Instance type produced by TaggedError factory */\nexport type TaggedErrorInstance<Tag extends string, Props> = Error & {\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>(err: E, handlers: MatchHandlers<E, R>): R;\n <E extends AnyTaggedError, R>(handlers: MatchHandlers<E, R>): (err: E) => 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 <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 <\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} = 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 * Unrecoverable error — user code threw inside Result operations.\n *\n * @example\n * // Panic in generator cleanup:\n * Result.gen(function* () {\n * try {\n * yield* Result.err(\"expected error\");\n * } finally {\n * throw new Error(\"cleanup failed\"); // Panic!\n * }\n * });\n *\n * // Panic in combinator:\n * Result.ok(1).map(() => { throw new Error(\"oops\"); }); // Panic!\n */\nexport class Panic extends TaggedError(\"Panic\")<{\n message: string;\n cause?: unknown;\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\n/**\n * Type guard for Panic instances.\n *\n * @example\n * if (isPanic(value)) { value.cause }\n */\nexport const isPanic = (value: unknown): value is Panic => {\n return value instanceof Panic;\n};\n\n/**\n * Throw an unrecoverable Panic.\n *\n * @example\n * panic(\"something went wrong\", cause);\n */\nexport const panic = (message: string, cause?: unknown): never => {\n throw new Panic({ message, cause });\n};\n","import { panic, ResultDeserializationError, UnhandledException } from \"./error\";\nimport { dual } from \"./dual\";\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\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>(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>(_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 * 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>(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>(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>(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(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(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 * 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>(_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>(fn: (e: E) => E2): Err<T, E2> {\n return tryOrPanic(() => new Err<T, E2>(fn(this.error)), \"mapError 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>(_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>(_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<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(_fn: (a: never) => void): Err<T, E> {\n return this;\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(_fn: (a: never) => Promise<void>): Promise<Err<T, E>> {\n return Promise.resolve(this);\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 * 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\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 */\ntype AnyResult = Ok<unknown, unknown> | Err<unknown, unknown>;\n\nfunction ok(): Ok<void, never>;\nfunction ok<A, E = never>(value: A): Ok<A, E>;\nfunction ok(value?: unknown): Ok<unknown, never> {\n return new Ok(value);\n}\n\nconst isOk = <A, E>(result: Result<A, E>): result is Ok<A, E> => {\n return result.status === \"ok\";\n};\n\nconst err = <T = never, E = unknown>(error: E): Err<T, E> => new Err<T, E>(error);\n\nconst isError = <T, E>(result: Result<T, E>): result is Err<T, E> => {\n return result.status === \"error\";\n};\n\nconst tryFn: {\n <A>(\n thunk: () => Awaited<A>,\n config?: { retry?: { times: number } },\n ): Result<A, UnhandledException>;\n <A, E>(\n options: { try: () => Awaited<A>; catch: (cause: unknown) => Awaited<E> },\n config?: { retry?: { times: number } },\n ): Result<A, E>;\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>(\n thunk: () => Promise<A>,\n config?: RetryConfig<UnhandledException>,\n ): Promise<Result<A, UnhandledException>>;\n <A, E>(\n options: { try: () => Promise<A>; catch: (cause: unknown) => E | Promise<E> },\n config?: RetryConfig<E>,\n ): Promise<Result<A, E>>;\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 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 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>(result: Result<A, E>, handlers: { ok: (a: A) => T; err: (e: E) => T }): T;\n <A, E, T>(handlers: { ok: (a: A) => T; err: (e: E) => T }): (result: Result<A, E>) => 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 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 * 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 * 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 * 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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"} |