{"version":3,"file":"index.mjs","names":["state"],"sources":["../src/error.ts","../src/dual.ts","../src/option.ts"],"sourcesContent":["/** 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/**\n * Unrecoverable error — user code threw inside Option operations.\n *\n * @example\n * // Panic in generator cleanup:\n * Option.gen(function* () {\n * try {\n * yield* Option.none();\n * } finally {\n * throw new Error(\"cleanup failed\"); // Panic!\n * }\n * });\n *\n * // Panic in combinator:\n * Option.some(1).map(() => { throw new Error(\"oops\"); }); // Panic!\n */\nexport class Panic extends Error {\n readonly _tag = \"Panic\" as const;\n override readonly cause?: unknown;\n\n constructor(args: { message: string; cause?: unknown }) {\n const { message, cause } = args;\n super(message, cause !== undefined ? { cause } : undefined);\n\n this.cause = cause;\n this.name = \"Panic\";\n\n Object.setPrototypeOf(this, new.target.prototype);\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 _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/**\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","/* 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,\n DataFirst extends (...args: Array) => any,\n>(arity: Parameters[\"length\"], body: DataFirst): DataLast & DataFirst {\n if (arity === 2) {\n return ((...args: Array) => {\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) => {\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) => {\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) => {\n if (args.length >= arity) {\n return body(...args);\n }\n return (self: any) => body(self, ...args);\n }) as DataLast & DataFirst;\n}\n","import { panic } from \"./error\";\nimport { dual } from \"./dual\";\n\n/** Executes fn, panics if it throws. */\nconst tryOrPanic = (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 (fn: () => Promise, message: string): Promise => {\n try {\n return await fn();\n } catch (cause) {\n throw panic(message, cause);\n }\n};\n\n/**\n * Present value variant.\n *\n * @template A Value type.\n *\n * @example\n * const option = new Some(42);\n * option.value // 42\n * option.status // \"some\"\n */\nexport class Some {\n readonly status = \"some\" as const;\n constructor(readonly value: A) {}\n\n /** Returns true, narrowing Option to Some. */\n isSome(): this is Some {\n return true;\n }\n\n /** Returns false, narrowing Option to None. */\n isNone(): this is None {\n return false;\n }\n\n /**\n * Transforms value.\n *\n * @template B Transformed type.\n * @param fn Transformation function.\n * @returns Some with transformed value.\n * @throws {Panic} If fn throws.\n *\n * @example\n * some(2).map(x => x * 2) // Some(4)\n */\n map(fn: (a: A) => B): Some {\n return tryOrPanic(() => new Some(fn(this.value)), \"map callback threw\");\n }\n\n /**\n * Chains Option-returning function.\n *\n * @template B New value type.\n * @param fn Function returning Option.\n * @returns Option from fn.\n * @throws {Panic} If fn throws.\n *\n * @example\n * some(2).andThen(x => x > 0 ? some(x) : none()) // Some(2)\n */\n andThen(fn: (a: A) => Option): Option {\n return tryOrPanic(() => fn(this.value), \"andThen callback threw\");\n }\n\n /**\n * Chains async Option-returning function.\n *\n * @template B New value type.\n * @param fn Async function returning Option.\n * @returns Promise of Option from fn.\n * @throws {Panic} If fn throws synchronously or rejects.\n *\n * @example\n * await some(1).andThenAsync(async x => some(await fetchData(x)))\n */\n andThenAsync(fn: (a: A) => Promise>): Promise> {\n return tryOrPanicAsync(() => fn(this.value), \"andThenAsync callback threw\");\n }\n\n /**\n * Pattern matches on Option.\n *\n * @template T Return type.\n * @param handlers Some and none handlers.\n * @returns Result of some handler.\n * @throws {Panic} If handler throws.\n *\n * @example\n * some(2).match({ some: x => x * 2, none: () => 0 }) // 4\n */\n match(handlers: { some: (a: A) => T; none: () => T }): T {\n return tryOrPanic(() => handlers.some(this.value), \"match some handler threw\");\n }\n\n /**\n * Extracts value.\n *\n * @param _message Ignored.\n * @returns The value.\n *\n * @example\n * some(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 * some(42).unwrapOr(0) // 42\n */\n unwrapOr(_fallback: B): A {\n return this.value;\n }\n\n /**\n * Returns value, ignoring fallback thunk.\n *\n * @template B Fallback type.\n * @param _fallback Ignored.\n * @returns The value.\n *\n * @example\n * some(42).unwrapOrElse(() => 0) // 42\n */\n unwrapOrElse(_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 * some(2).tap(console.log).map(x => x * 2) // logs 2, returns Some(4)\n */\n tap(fn: (a: A) => void): Some {\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 some(2).tapAsync(async x => await log(x))\n */\n tapAsync(fn: (a: A) => Promise): Promise> {\n return tryOrPanicAsync(async () => {\n await fn(this.value);\n return this;\n }, \"tapAsync callback threw\");\n }\n\n /**\n * Returns Some if predicate passes, None otherwise.\n *\n * @param predicate Test function.\n * @returns Some if predicate returns true, None otherwise.\n * @throws {Panic} If predicate throws.\n *\n * @example\n * some(5).filter(x => x > 3) // Some(5)\n * some(2).filter(x => x > 3) // None\n */\n filter(predicate: (a: A) => boolean): Option {\n return tryOrPanic(\n () => (predicate(this.value) ? this : None.instance),\n \"filter predicate threw\",\n );\n }\n\n /**\n * Makes Some yieldable in Option.gen blocks.\n * Immediately returns the value without yielding.\n */\n // oxlint-disable-next-line require-yield\n *[Symbol.iterator](): Generator {\n return this.value;\n }\n}\n\n/**\n * Absent value variant (singleton).\n *\n * @example\n * const option = None.instance;\n * option.status // \"none\"\n */\nexport class None {\n readonly status = \"none\" as const;\n\n private constructor() {}\n\n /** Singleton instance. */\n static readonly instance = new None();\n\n /** Returns false, narrowing Option to Some. */\n isSome(): this is Some {\n return false;\n }\n\n /** Returns true, narrowing Option to None. */\n isNone(): this is None {\n return true;\n }\n\n /**\n * No-op on None, returns self.\n *\n * @template U New phantom value type.\n * @param _fn Ignored.\n * @returns Self.\n */\n map(_fn: (a: never) => U): None {\n return this;\n }\n\n /**\n * No-op on None, returns self.\n *\n * @template U New phantom value type.\n * @param _fn Ignored.\n * @returns Self.\n */\n andThen(_fn: (a: never) => Option): None {\n return this;\n }\n\n /**\n * No-op on None, returns Promise of self.\n *\n * @template U New phantom value type.\n * @param _fn Ignored.\n * @returns Promise of self.\n */\n andThenAsync(_fn: (a: never) => Promise>): Promise {\n return Promise.resolve(this);\n }\n\n /**\n * Pattern matches on Option.\n *\n * @template R Return type.\n * @param handlers Some and none handlers.\n * @returns Result of none handler.\n * @throws {Panic} If handler throws.\n *\n * @example\n * none().match({ some: x => x, none: () => \"empty\" }) // \"empty\"\n */\n match(handlers: { some: (a: never) => R; none: () => R }): R {\n return tryOrPanic(() => handlers.none(), \"match none 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 * none().unwrap() // throws Panic\n * none().unwrap(\"custom\") // throws Panic(\"custom\")\n */\n unwrap(message?: string): never {\n return panic(message ?? \"Unwrap called on None\");\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 * none().unwrapOr(42) // 42\n */\n unwrapOr(fallback: U): U {\n return fallback;\n }\n\n /**\n * Computes and returns fallback value.\n *\n * @template U Fallback type.\n * @param fallback Fallback thunk.\n * @returns Result of fallback.\n * @throws {Panic} If fallback throws.\n *\n * @example\n * none().unwrapOrElse(() => 42) // 42\n */\n unwrapOrElse(fallback: () => U): U {\n return tryOrPanic(fallback, \"unwrapOrElse fallback threw\");\n }\n\n /**\n * No-op on None, returns self.\n *\n * @param _fn Ignored.\n * @returns Self.\n */\n tap(_fn: (a: never) => void): None {\n return this;\n }\n\n /**\n * No-op on None, returns Promise of self.\n *\n * @param _fn Ignored.\n * @returns Promise of self.\n */\n tapAsync(_fn: (a: never) => Promise): Promise {\n return Promise.resolve(this);\n }\n\n /**\n * No-op on None, returns self.\n *\n * @param _predicate Ignored.\n * @returns Self.\n */\n filter(_predicate: (a: never) => boolean): None {\n return this;\n }\n\n /**\n * Makes None yieldable in Option.gen blocks.\n * Yields None for proper generator short-circuiting.\n */\n *[Symbol.iterator](): Generator {\n yield this;\n return panic(\"Unreachable: None yielded in Option.gen but generator continued\");\n }\n}\n\n/**\n * Union type representing presence or absence of a value.\n *\n * @template A Value type.\n *\n * @example\n * type MaybeUser = Option;\n */\nexport type Option = Some | None;\n\n/**\n * Infer the value type from an Option.\n * Distributive: InferValue | Some> = A | B\n */\nexport type InferValue = O extends Some ? A : never;\n\n/**\n * Constraint for any Option type.\n * Used in Option.gen to accept flexible return types from generators.\n */\ntype AnyOption = Some | None;\n\nfunction some(): Some;\nfunction some(value: A): Some;\nfunction some(value?: unknown): Some {\n return new Some(value);\n}\n\nconst none = (): None => None.instance;\n\nconst isSome = (option: Option): option is Some => {\n return option.status === \"some\";\n};\n\nconst isNone = (option: Option): option is None => {\n return option.status === \"none\";\n};\n\nconst map: {\n (option: Option, fn: (a: A) => B): Option;\n (fn: (a: A) => B): (option: Option) => Option;\n} = dual(2, (option: Option, fn: (a: A) => B): Option => {\n return option.map(fn);\n});\n\nconst andThen: {\n (option: Option, fn: (a: A) => Option): Option;\n (fn: (a: A) => Option): (option: Option) => Option;\n} = dual(2, (option: Option, fn: (a: A) => Option): Option => {\n return option.andThen(fn);\n});\n\nconst andThenAsync: {\n (option: Option, fn: (a: A) => Promise>): Promise>;\n (fn: (a: A) => Promise>): (option: Option) => Promise>;\n} = dual(2, (option: Option, fn: (a: A) => Promise>): Promise> => {\n return option.andThenAsync(fn);\n});\n\nconst match: {\n (option: Option, handlers: { some: (a: A) => T; none: () => T }): T;\n (handlers: { some: (a: A) => T; none: () => T }): (option: Option) => T;\n} = dual(2, (option: Option, handlers: { some: (a: A) => T; none: () => T }): T => {\n return option.match(handlers);\n});\n\nconst tap: {\n (option: Option, fn: (a: A) => void): Option;\n (fn: (a: A) => void): (option: Option) => Option;\n} = dual(2, (option: Option, fn: (a: A) => void): Option => {\n return option.tap(fn);\n});\n\nconst tapAsync: {\n (option: Option, fn: (a: A) => Promise): Promise>;\n (fn: (a: A) => Promise): (option: Option) => Promise>;\n} = dual(2, (option: Option, fn: (a: A) => Promise): Promise> => {\n return option.tapAsync(fn);\n});\n\nconst unwrap = (option: Option, message?: string): A => {\n return option.unwrap(message);\n};\n\nconst unwrapOr: {\n (option: Option, fallback: B): A | B;\n (fallback: B): (option: Option) => A | B;\n} = dual(2, (option: Option, fallback: B): A | B => {\n return option.unwrapOr(fallback);\n});\n\n/** Validates that a value is an Option instance. Throws with helpful message if not. */\nfunction assertIsOption(value: unknown): asserts value is Option {\n if (\n value !== null &&\n typeof value === \"object\" &&\n \"status\" in value &&\n (value.status === \"some\" || value.status === \"none\")\n ) {\n return;\n }\n return panic(\n \"Option.gen body must return Option.some() or Option.none(), got: \" +\n (value === null ? \"null\" : typeof value === \"object\" ? JSON.stringify(value) : String(value)),\n );\n}\n\nconst gen: {\n (body: () => Generator): Option>;\n (\n body: (this: This) => Generator,\n thisArg: This,\n ): Option>;\n (\n body: () => AsyncGenerator,\n ): Promise>>;\n (\n body: (this: This) => AsyncGenerator,\n thisArg: This,\n ): Promise>>;\n} = ((\n body:\n | (() => Generator)\n | (() => AsyncGenerator)\n | ((this: This) => Generator)\n | ((this: This) => AsyncGenerator),\n thisArg?: This,\n): Option> | Promise>> => {\n // SAFETY: body.call binds thisArg; cast needed due to union of function signatures\n const iterator = (body as (this: This) => Generator).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;\n\n let state: IteratorResult;\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 assertIsOption(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 Option>;\n })();\n }\n\n // Sync generator\n // SAFETY: If not async, must be sync generator\n const syncIter = iterator as Generator;\n\n let state: IteratorResult;\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 assertIsOption(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 Option>;\n}) as {\n (body: () => Generator): Option>;\n (\n body: (this: This) => Generator,\n thisArg: This,\n ): Option>;\n (\n body: () => AsyncGenerator,\n ): Promise>>;\n (\n body: (this: This) => AsyncGenerator,\n thisArg: This,\n ): Promise>>;\n};\n\nasync function* optionAwait(promise: Promise>): AsyncGenerator {\n const option = await promise;\n return yield* option;\n}\n\n/** Shape of a serialized Some over RPC. */\nexport interface SerializedSome {\n status: \"some\";\n value: A;\n}\n\n/** Shape of a serialized None over RPC. */\nexport interface SerializedNone {\n status: \"none\";\n}\n\n/** Shape of a serialized Option over RPC. */\nexport type SerializedOption = SerializedSome | SerializedNone;\n\nfunction isSerializedOption(obj: unknown): obj is SerializedOption {\n return (\n obj !== null &&\n typeof obj === \"object\" &&\n \"status\" in obj &&\n ((obj.status === \"some\" && \"value\" in obj) || obj.status === \"none\")\n );\n}\n\nconst serialize = (option: Option): SerializedOption => {\n return option.status === \"some\" ? { status: \"some\", value: option.value } : { status: \"none\" };\n};\n\nconst deserialize = (value: unknown): Option | null => {\n if (isSerializedOption(value)) {\n return value.status === \"some\" ? (new Some(value.value) as Option) : None.instance;\n }\n return null;\n};\n\nconst partition = (options: readonly Option[]): [A[], number] => {\n const values: A[] = [];\n let noneCount = 0;\n for (const o of options) {\n if (o.status === \"some\") {\n values.push(o.value);\n } else {\n noneCount++;\n }\n }\n return [values, noneCount];\n};\n\n/**\n * Flattens nested Option into single Option.\n *\n * @example\n * const nested: Option> = Option.some(Option.some(42));\n * const flat: Option = Option.flatten(nested); // Some(42)\n */\nconst flatten = (option: Option>): Option => {\n if (option.status === \"some\") {\n return option.value;\n }\n return option;\n};\n\n/**\n * Converts nullable value to Option.\n * null and undefined become None, everything else becomes Some.\n */\nconst from = (value: A | null | undefined): Option> => {\n return value == null ? None.instance : new Some(value as NonNullable);\n};\n\n/**\n * Creates Option based on predicate result.\n * Some if predicate passes, None otherwise.\n */\nconst fromPredicate: {\n (value: A, predicate: (a: A) => a is B): Option;\n (value: A, predicate: (a: A) => boolean): Option;\n (predicate: (a: A) => a is B): (value: A) => Option;\n (predicate: (a: A) => boolean): (value: A) => Option;\n} = dual(2, (value: A, predicate: (a: A) => boolean): Option => {\n return tryOrPanic(\n () => (predicate(value) ? new Some(value) : None.instance),\n \"fromPredicate predicate threw\",\n );\n});\n\n/**\n * Filters Option based on predicate.\n * Some becomes None if predicate fails.\n */\nconst filter: {\n (option: Option, predicate: (a: A) => a is B): Option;\n (option: Option, predicate: (a: A) => boolean): Option;\n (predicate: (a: A) => a is B): (option: Option) => Option;\n (predicate: (a: A) => boolean): (option: Option) => Option;\n} = dual(2, (option: Option, predicate: (a: A) => boolean): Option => {\n return option.filter(predicate);\n});\n\n/**\n * Combines two Options into Option of tuple.\n * Returns Some([a, b]) if both are Some, None otherwise.\n */\nconst zip = (optionA: Option, optionB: Option): Option<[A, B]> => {\n if (optionA.status === \"some\" && optionB.status === \"some\") {\n return new Some<[A, B]>([optionA.value, optionB.value]);\n }\n return None.instance;\n};\n\n/**\n * Extracts value or computes fallback lazily.\n */\nconst unwrapOrElse: {\n (option: Option, fallback: () => B): A | B;\n (fallback: () => B): (option: Option) => A | B;\n} = dual(2, (option: Option, fallback: () => B): A | B => {\n return option.unwrapOrElse(fallback);\n});\n\n/**\n * Utilities for creating and handling Option types.\n *\n * @example\n * const option = Option.from(maybeNull);\n * const value = option.map(x => x.id).unwrapOr(\"default\");\n */\nexport const Option = {\n /**\n * Creates present value.\n *\n * @example\n * Option.some(42) // Some\n * Option.some() // Some\n */\n some,\n /**\n * Creates absent value.\n *\n * @example\n * Option.none() // None\n */\n none,\n /**\n * Type guard for Some.\n *\n * @example\n * if (Option.isSome(option)) { option.value }\n */\n isSome,\n /**\n * Type guard for None.\n *\n * @example\n * if (Option.isNone(option)) { // handle absent }\n */\n isNone,\n /**\n * Transforms value, passes None through.\n *\n * @example\n * Option.map(some(2), x => x * 2) // Some(4)\n * Option.map(x => x * 2)(some(2)) // Some(4)\n */\n map,\n /**\n * Chains Option-returning function on Some.\n *\n * @example\n * Option.andThen(some(2), x => x > 0 ? some(x) : none()) // Some(2)\n */\n andThen,\n /**\n * Chains async Option-returning function on Some.\n *\n * @example\n * await Option.andThenAsync(some(1), async x => some(await fetch(x)))\n */\n andThenAsync,\n /**\n * Pattern matches on Option.\n *\n * @example\n * Option.match(some(2), { some: x => x * 2, none: () => 0 }) // 4\n */\n match,\n /**\n * Runs side effect on Some value, returns original option.\n *\n * @example\n * Option.tap(some(2), console.log) // logs 2, returns Some(2)\n */\n tap,\n /**\n * Runs async side effect on Some value, returns original option.\n *\n * @example\n * await Option.tapAsync(some(2), async x => await log(x))\n */\n tapAsync,\n /**\n * Extracts value or throws.\n *\n * @example\n * Option.unwrap(some(42)) // 42\n * Option.unwrap(none()) // throws Panic\n */\n unwrap,\n /**\n * Extracts value or returns fallback.\n *\n * @example\n * Option.unwrapOr(some(42), 0) // 42\n * Option.unwrapOr(none(), 0) // 0\n */\n unwrapOr,\n /**\n * Generator-based composition for Option types.\n *\n * @example\n * const option = Option.gen(function* () {\n * const a = yield* getA(); // Option\n * const b = yield* getB(a); // Option\n * return Option.some({ a, b });\n * });\n * // Option<{a, b}>\n *\n * @example\n * // Async with Option.await\n * const option = await Option.gen(async function* () {\n * const a = yield* Option.await(fetchA());\n * const b = yield* Option.await(fetchB(a));\n * return Option.some({ a, b });\n * });\n */\n gen,\n /**\n * Wraps Promise