@onrails/result 0.3.1 → 0.4.1

package/dist/result.d.ts

@@ -0,0 +1,315 @@
+import type { Locked } from "./internal/lock.js";
+import type { Err, Ok, Result } from "./types.js";
+export type { Err, Ok, Result } from "./types.js";
+/**
+ * Lifts a value into the success track.
+ *
+ * @example
+ * ```ts
+ * const r = ok(42);                          // Result<42, never> — literal locked
+ * const typed: Result<number, "parse"> = ok(1);
+ * const lift = <T, E>(v: T): Result<T, E> => ok<T, E>(v);  // explicit args opt out
+ * ```
+ *
+ * @remarks
+ * An inline literal keeps its narrow type instead of widening (`ok("a")` is
+ * `Result<"a", never>`, not `Result<string, never>`). Pass both type arguments
+ * to opt out — generic code that must produce `Result<T, E>` for an unresolved
+ * `T` needs that form.
+ */
+export declare function ok<const T>(value: T): Result<Locked<T>, never>;
+export declare function ok<T, E>(value: T): Result<T, E>;
+/**
+ * Fantasy Land `pure` — alias of {@link ok}. One lift name shared across the
+ * trio (`of` / `Maybe.of` / `ResultAsync.of`) for generic and FL-style code.
+ *
+ * @example
+ * ```ts
+ * const r = of(42);   // Result<42, never> — identical to ok(42)
+ * ```
+ */
+export declare const of: typeof ok;
+/**
+ * Lifts a value into the error track.
+ *
+ * @example
+ * ```ts
+ * const r = err({ kind: "parse", message: "bad json" });
+ * // Result<never, { readonly kind: "parse"; readonly message: string }>
+ *
+ * type AppError = { kind: "parse" } | { kind: "io" };
+ * err<AppError>({ kind: "io" });          // Result<never, AppError> — one arg names the error
+ * err<number, AppError>({ kind: "io" });  // Result<number, AppError> — neverthrow's T, E order
+ * ```
+ *
+ * @remarks
+ * One explicit type argument names the **error** channel, which is what the
+ * call site almost always means. Both channels still take neverthrow's `T, E`
+ * order, and that two-argument form is also the escape hatch for generic code:
+ * inference-driven calls lock literals, so a generic `E` must be passed
+ * explicitly to keep the error type from being rewritten.
+ */
+export declare function err<const E>(error: E): Result<never, Locked<E>>;
+export declare function err<T, E>(error: E): Result<T, E>;
+/**
+ * Type-narrowing predicate: returns `true` when the result is `Ok`.
+ *
+ * @example
+ * ```ts
+ * if (isOk(r)) {
+ *   console.log(r.value);    // narrowed to Ok branch
+ * }
+ * ```
+ */
+export declare const isOk: <T, E>(result: Result<T, E>) => result is Ok<T, E>;
+/**
+ * Type-narrowing predicate: returns `true` when the result is `Err`.
+ *
+ * @example
+ * ```ts
+ * if (isErr(r)) {
+ *   metrics.inc("error", { kind: r.error.kind });
+ * }
+ * ```
+ */
+export declare const isErr: <T, E>(result: Result<T, E>) => result is Err<T, E>;
+/**
+ * Transform the `Ok` value, passing `Err` through unchanged. Dual-form:
+ * call data-first or curried (for use with {@link pipe}).
+ *
+ * @example
+ * ```ts
+ * map(ok(2), (n) => n * 3);          // Ok 6 — data-first
+ * pipe(ok("x"), map((s) => s.length));// Ok 1 — curried
+ * ```
+ */
+export declare const map: {
+    <T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+    <T, U>(fn: (value: T) => U): <E>(result: Result<T, E>) => Result<U, E>;
+};
+/**
+ * Transform the `Err` value, passing `Ok` through unchanged. Useful for
+ * unifying heterogeneous failure types into one app-level union.
+ *
+ * @example
+ * ```ts
+ * type AppError = { kind: "http"; status: number } | { kind: "parse" };
+ * pipe(
+ *   fetchSync(url),                                     // Result<Body, { status: number }>
+ *   mapErr((e): AppError => ({ kind: "http", status: e.status })),
+ * );
+ * ```
+ */
+export declare const mapErr: {
+    <T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
+    <E, F>(fn: (error: E) => F): <T>(result: Result<T, E>) => Result<T, F>;
+};
+/**
+ * Transform both tracks at once — `Ok` via `onOk`, `Err` via `onErr`.
+ * Equivalent to `mapErr(onErr)(map(onOk)(result))` but in one pass.
+ *
+ * @example
+ * ```ts
+ * bimap(parsed, (cfg) => cfg.name, (e) => ({ kind: "input", cause: e }));
+ * ```
+ */
+export declare const bimap: {
+    <T, U, E, F>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => F): Result<U, F>;
+    <T, U, E, F>(onOk: (value: T) => U, onErr: (error: E) => F): (result: Result<T, E>) => Result<U, F>;
+};
+/**
+ * Canonical bind (Fantasy Land `chain`). Chains a Result-returning step,
+ * widening the error union to `E | F`. Short-circuits on `Err`.
+ *
+ * @example
+ * ```ts
+ * flatMap(parseInput(raw), (data) =>
+ *   data.id != null ? ok(data) : err({ kind: "missing_id" as const }),
+ * );
+ * // Result<Data, ParseError | { kind: "missing_id" }>
+ * ```
+ */
+export declare const flatMap: {
+    <T, U, E, F>(result: Result<T, E>, fn: (value: T) => Result<U, F>): Result<U, E | F>;
+    <T, U, F>(fn: (value: T) => Result<U, F>): <E>(result: Result<T, E>) => Result<U, E | F>;
+};
+/**
+ * Error-track bind — runs `fn` only when the result is `Err`, allowing
+ * a failed workflow to recover to `Ok` or remap the failure. Mirror of
+ * {@link flatMap} on the error channel.
+ *
+ * @example
+ * ```ts
+ * recover(networkResult, (e) =>
+ *   e.kind === "rate_limit" ? ok(cachedBody) : err(e),
+ * );
+ * ```
+ */
+export declare const recover: {
+    <T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F>;
+    <T, E, F>(fn: (error: E) => Result<T, F>): (result: Result<T, E>) => Result<T, F>;
+};
+/**
+ * Observe the `Ok` value for side effects (logging, metrics) without
+ * changing the carried value. Passes `Err` through untouched.
+ *
+ * @example
+ * ```ts
+ * pipe(
+ *   parseConfig(raw),
+ *   tap((cfg) => log.info({ msg: "parsed", name: cfg.name })),
+ *   flatMap(validate),
+ * );
+ * ```
+ */
+export declare const tap: {
+    <T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E>;
+    <T>(fn: (value: T) => void): <E>(result: Result<T, E>) => Result<T, E>;
+};
+/**
+ * Observe the `Err` value for side effects (logging, metrics) without
+ * changing the carried error. Passes `Ok` through untouched.
+ *
+ * @example
+ * ```ts
+ * pipe(
+ *   loadUser(id),
+ *   tapErr((e) => metrics.inc("user.load.fail", { kind: e.kind })),
+ * );
+ * ```
+ */
+export declare const tapErr: {
+    <T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E>;
+    <E>(fn: (error: E) => void): <T>(result: Result<T, E>) => Result<T, E>;
+};
+/**
+ * Terminal collapse — fold both tracks into a single value. Dual-form:
+ * 3-args data-first, 2-args curried for {@link pipe}. Returns whatever
+ * the handlers return.
+ *
+ * For files that also import `match` from `ts-pattern`, use a namespace
+ * import (`import * as R from "@onrails/result"` → `R.match`) to dissolve
+ * the collision.
+ *
+ * @example
+ * ```ts
+ * const html = match(parsed, (cfg) => render(cfg), (e) => renderError(e));
+ * ```
+ */
+export declare const match: {
+    <T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U;
+    <T, E, U>(onOk: (value: T) => U, onErr: (error: E) => U): (result: Result<T, E>) => U;
+};
+/**
+ * Returns the `Ok` value, or `defaultValue` when the result is `Err`. The
+ * fallback may be a different type from `T` — the return widens to `T | U`,
+ * matching `ResultAsync.unwrapOr` and the compat shim.
+ *
+ * @example
+ * ```ts
+ * unwrapOr(parsedSetting, "default-value");  // string
+ * unwrapOr(parsedPort, null);                // number | null
+ * ```
+ */
+export declare const unwrapOr: {
+    <T, E, U>(result: Result<T, E>, defaultValue: U): T | U;
+    <U>(defaultValue: U): <T, E>(result: Result<T, E>) => T | U;
+};
+/**
+ * Test/assert helper — returns the `Ok` value, or **throws the original `Err`
+ * value** when called on an `Err`. This is the assertion tier (RFC 0001 §4):
+ * intended for `*.spec.ts` / `*.test.ts`, where throwing fails the test loudly.
+ * In business logic prefer {@link match} or {@link unwrapOr}; the lint plugins
+ * flag `unwrapOk` outside test files.
+ *
+ * @returns the unwrapped `Ok` value
+ * @throws the carried `Err` value when the result is `Err`
+ *
+ * @example
+ * ```ts
+ * // in a *.spec.ts
+ * expect(unwrapOk(ok(5))).toBe(5);
+ * expect(() => unwrapOk(err(error))).toThrow(error);
+ * ```
+ */
+export declare function unwrapOk<T, E>(result: Result<T, E>): T;
+/** Alias of {@link unwrapOk} for syntax cohesion with `@onrails/maybe`. */
+export declare const unwrap: typeof unwrapOk;
+/**
+ * Test/assert helper — returns the `Err` value, or **throws a `TypeError`**
+ * when called on an `Ok`. Mirror of {@link unwrapOk} on the error track and
+ * part of the same assertion tier (RFC 0001 §4): intended for `*.spec.ts` /
+ * `*.test.ts`. Prefer {@link match} / {@link unwrapOr} in business logic; the
+ * lint plugins flag `unwrapErr` outside test files.
+ *
+ * @returns the unwrapped `Err` value
+ * @throws `TypeError` when the result is `Ok`
+ *
+ * @example
+ * ```ts
+ * // in a *.spec.ts
+ * expect(unwrapErr(err("x"))).toBe("x");
+ * expect(() => unwrapErr(ok(5))).toThrow(TypeError);
+ * ```
+ */
+export declare function unwrapErr<T, E>(result: Result<T, E>): E;
+/**
+ * Wraps a throwing sync **function**, returning a function that produces a
+ * {@link Result} instead of throwing. Thrown errors pass through `onThrow` to
+ * become a typed `Err`; a normal return becomes `Ok`. Same name and shape as
+ * neverthrow's `Result.fromThrowable`.
+ *
+ * Reach for {@link trySync} instead when you want to run the call right now
+ * rather than build a reusable wrapper.
+ *
+ * @param fn - the throwing function to wrap
+ * @param onThrow - maps a thrown value to the `Err` channel
+ * @returns a function with `fn`'s parameters that returns `Result<ReturnType, E>`
+ *
+ * @example
+ * ```ts
+ * type ParseError = { kind: "parse"; message: string };
+ * const parse = fromThrowable(
+ *   JSON.parse,
+ *   (e): ParseError => ({ kind: "parse", message: String(e) }),
+ * );
+ * parse("{}");      // Ok({})
+ * parse("nope");    // Err({ kind: "parse", … })
+ * ```
+ */
+export declare function fromThrowable<A extends readonly unknown[], T, E>(fn: (...args: A) => T, onThrow: (error: unknown) => E): (...args: A) => Result<T, E>;
+export declare function fromThrowable<F extends (...args: never) => unknown, E>(fn: F, onThrow: (error: unknown) => E): (...args: Parameters<F>) => Result<ReturnType<F>, E>;
+/**
+ * Runs `fn` **now**, catching a throw into the `Err` track — the sync mirror
+ * of `tryAsync`. Without `onThrow` the thrown value is normalized to an
+ * `Error`; pass a mapper for a typed error.
+ *
+ * To lift a throwing function once and call it many times, use
+ * {@link fromThrowable}.
+ *
+ * @param fn - the throwing thunk to run
+ * @param onThrow - maps a thrown value to the `Err` channel
+ *
+ * @example
+ * ```ts
+ * trySync(() => JSON.parse(raw));                    // Result<unknown, Error>
+ * trySync(() => Schema.parse(input), (e): SchemaError => ({
+ *   kind: "schema",
+ *   cause: e,
+ * }));
+ * ```
+ */
+export declare function trySync<T>(fn: () => T): Result<T, Error>;
+export declare function trySync<T, E>(fn: () => T, onThrow: (error: unknown) => E): Result<T, E>;
+/**
+ * Debug printer — renders a result as `Ok(…)` / `Err(…)` for logs. Payloads
+ * print as JSON (values are plain data by design); non-JSON payloads fall
+ * back to `String(...)`.
+ *
+ * @example
+ * ```ts
+ * show(ok(1));               // 'Ok(1)'
+ * show(err({ kind: "e" })); // 'Err({"kind":"e"})'
+ * ```
+ */
+export declare const show: <T, E>(result: Result<T, E>) => string;

package/dist/try-gen.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-// src/internal/dual.ts
-var err = (error) => ({
+// src/internal/ctor.ts
+var mkErr = (error) => ({
   _tag: "Err",
   error
 });
@@ -27,7 +27,7 @@ var tryGen = (fn) => {
     return fn();
   } catch (error) {
     if (error instanceof ErrSignal) {
-      return err(error.error);
+      return mkErr(error.error);
     }
     throw error;
   }

package/dist/try-gen.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/result.ts","../src/try-gen.ts"],"names":[],"mappings":";;;AAuCO,IAAM,GAAA,GAAM,CAAyB,KAAA,MAA4B;AAAA,EACtE,IAAA,EAAM,KAAA;AAAA,EACN;AACF,CAAA,CAAA;AAwBO,IAAM,KAAA,GAAQ,CAAO,MAAA,KAA8C,MAAA,CAAO,IAAA,KAAS,KAAA;;;AC9D1F,IAAM,YAAN,MAAmB;AAAA,EAEjB,YAAqB,KAAA,EAAU;AAAV,IAAA,IAAA,CAAA,KAAA,GAAA,KAAA;AAAA,EAAW;AAAA,EAAX,KAAA;AAAA,EADZ,IAAA,GAAO,WAAA;AAElB,CAAA;AAmBO,IAAM,WAAA,GAAc,CAAO,MAAA,KAA4B;AAC5D,EAAA,IAAI,KAAA,CAAM,MAAM,CAAA,EAAG;AACjB,IAAA,MAAM,IAAI,SAAA,CAAU,MAAA,CAAO,KAAK,CAAA;AAAA,EAClC;AACA,EAAA,OAAO,MAAA,CAAO,KAAA;AAChB;AAeO,IAAM,CAAA,GAAI;AAcV,IAAM,MAAA,GAAS,CAAO,EAAA,KAAyC;AACpE,EAAA,IAAI;AACF,IAAA,OAAO,EAAA,EAAG;AAAA,EACZ,SAAS,KAAA,EAAO;AACd,IAAA,IAAI,iBAAiB,SAAA,EAAW;AAC9B,MAAA,OAAO,GAAA,CAAI,MAAM,KAAK,CAAA;AAAA,IACxB;AACA,IAAA,MAAM,KAAA;AAAA,EACR;AACF","file":"try-gen.cjs","sourcesContent":["import { dual } from \"./internal/dual.js\";\nimport type { Err, Ok, Result } from \"./types.js\";\n\nexport type { Err, Ok, Result } from \"./types.js\";\n\n/**\n * Lifts a value into the success track.\n *\n * @example\n * ```ts\n * const r = ok(42);                          // Result<number, never>\n * const typed: Result<number, \"parse\"> = ok(1);\n * ```\n */\nexport const ok = <T, E = never>(value: T): Result<T, E> => ({\n  _tag: \"Ok\",\n  value,\n});\n\n/**\n * Fantasy Land `pure` — alias of {@link ok}. One lift name shared across the\n * trio (`of` / `Maybe.of` / `ResultAsync.of`) for generic and FL-style code.\n *\n * @example\n * ```ts\n * const r = of(42);   // Result<number, never> — identical to ok(42)\n * ```\n */\nexport const of = ok;\n\n/**\n * Lifts a value into the error track.\n *\n * @example\n * ```ts\n * const r = err({ kind: \"parse\", message: \"bad json\" });\n * // Result<never, { kind: \"parse\"; message: string }>\n * ```\n */\nexport const err = <T = never, E = unknown>(error: E): Result<T, E> => ({\n  _tag: \"Err\",\n  error,\n});\n\n/**\n * Type-narrowing predicate: returns `true` when the result is `Ok`.\n *\n * @example\n * ```ts\n * if (isOk(r)) {\n *   console.log(r.value);    // narrowed to Ok branch\n * }\n * ```\n */\nexport const isOk = <T, E>(result: Result<T, E>): result is Ok<T, E> => result._tag === \"Ok\";\n\n/**\n * Type-narrowing predicate: returns `true` when the result is `Err`.\n *\n * @example\n * ```ts\n * if (isErr(r)) {\n *   metrics.inc(\"error\", { kind: r.error.kind });\n * }\n * ```\n */\nexport const isErr = <T, E>(result: Result<T, E>): result is Err<T, E> => result._tag === \"Err\";\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Dual-form helpers — each export accepts either shape:\n//   data-first: `map(result, fn)`\n//   curried:    `map(fn)(result)`\n// Arity dispatch is derived from the internal `dual` combinator\n// (src/internal/dual.ts); the const annotation carries the public overloads.\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Transform the `Ok` value, passing `Err` through unchanged. Dual-form:\n * call data-first or curried (for use with {@link pipe}).\n *\n * @example\n * ```ts\n * map(ok(2), (n) => n * 3);          // Ok 6 — data-first\n * pipe(ok(\"x\"), map((s) => s.length));// Ok 1 — curried\n * ```\n */\nexport const map: {\n  <T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;\n  <T, U>(fn: (value: T) => U): <E>(result: Result<T, E>) => Result<U, E>;\n} = dual(\n  2,\n  <T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> =>\n    isOk(result) ? ok(fn(result.value)) : err(result.error),\n);\n\n/**\n * Transform the `Err` value, passing `Ok` through unchanged. Useful for\n * unifying heterogeneous failure types into one app-level union.\n *\n * @example\n * ```ts\n * type AppError = { kind: \"http\"; status: number } | { kind: \"parse\" };\n * pipe(\n *   fetchSync(url),                                     // Result<Body, { status: number }>\n *   mapErr((e): AppError => ({ kind: \"http\", status: e.status })),\n * );\n * ```\n */\nexport const mapErr: {\n  <T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;\n  <E, F>(fn: (error: E) => F): <T>(result: Result<T, E>) => Result<T, F>;\n} = dual(\n  2,\n  <T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> =>\n    isErr(result) ? err(fn(result.error)) : ok(result.value),\n);\n\n/**\n * Transform both tracks at once — `Ok` via `onOk`, `Err` via `onErr`.\n * Equivalent to `mapErr(onErr)(map(onOk)(result))` but in one pass.\n *\n * @example\n * ```ts\n * bimap(parsed, (cfg) => cfg.name, (e) => ({ kind: \"input\", cause: e }));\n * ```\n */\nexport const bimap: {\n  <T, U, E, F>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => F): Result<U, F>;\n  <T, U, E, F>(\n    onOk: (value: T) => U,\n    onErr: (error: E) => F,\n  ): (result: Result<T, E>) => Result<U, F>;\n} = dual(\n  3,\n  <T, U, E, F>(\n    result: Result<T, E>,\n    onOk: (value: T) => U,\n    onErr: (error: E) => F,\n  ): Result<U, F> => (isOk(result) ? ok(onOk(result.value)) : err(onErr(result.error))),\n);\n\n/**\n * Canonical bind (Fantasy Land `chain`). Chains a Result-returning step,\n * widening the error union to `E | F`. Short-circuits on `Err`.\n *\n * @example\n * ```ts\n * flatMap(parseInput(raw), (data) =>\n *   data.id != null ? ok(data) : err({ kind: \"missing_id\" as const }),\n * );\n * // Result<Data, ParseError | { kind: \"missing_id\" }>\n * ```\n */\nexport const flatMap: {\n  <T, U, E, F>(result: Result<T, E>, fn: (value: T) => Result<U, F>): Result<U, E | F>;\n  <T, U, F>(fn: (value: T) => Result<U, F>): <E>(result: Result<T, E>) => Result<U, E | F>;\n} = dual(\n  2,\n  <T, U, E, F>(result: Result<T, E>, fn: (value: T) => Result<U, F>): Result<U, E | F> =>\n    isOk(result) ? fn(result.value) : err(result.error),\n);\n\n/**\n * Error-track bind — runs `fn` only when the result is `Err`, allowing\n * a failed workflow to recover to `Ok` or remap the failure. Mirror of\n * {@link flatMap} on the error channel.\n *\n * @example\n * ```ts\n * recover(networkResult, (e) =>\n *   e.kind === \"rate_limit\" ? ok(cachedBody) : err(e),\n * );\n * ```\n */\nexport const recover: {\n  <T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F>;\n  <T, E, F>(fn: (error: E) => Result<T, F>): (result: Result<T, E>) => Result<T, F>;\n} = dual(\n  2,\n  <T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> =>\n    isErr(result) ? fn(result.error) : ok(result.value),\n);\n\n/**\n * Observe the `Ok` value for side effects (logging, metrics) without\n * changing the carried value. Passes `Err` through untouched.\n *\n * @example\n * ```ts\n * pipe(\n *   parseConfig(raw),\n *   tap((cfg) => log.info({ msg: \"parsed\", name: cfg.name })),\n *   flatMap(validate),\n * );\n * ```\n */\nexport const tap: {\n  <T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E>;\n  <T>(fn: (value: T) => void): <E>(result: Result<T, E>) => Result<T, E>;\n} = dual(2, <T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E> => {\n  if (isOk(result)) fn(result.value);\n  return result;\n});\n\n/**\n * Observe the `Err` value for side effects (logging, metrics) without\n * changing the carried error. Passes `Ok` through untouched.\n *\n * @example\n * ```ts\n * pipe(\n *   loadUser(id),\n *   tapErr((e) => metrics.inc(\"user.load.fail\", { kind: e.kind })),\n * );\n * ```\n */\nexport const tapErr: {\n  <T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E>;\n  <E>(fn: (error: E) => void): <T>(result: Result<T, E>) => Result<T, E>;\n} = dual(2, <T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E> => {\n  if (isErr(result)) fn(result.error);\n  return result;\n});\n\n/**\n * Terminal collapse — fold both tracks into a single value. Dual-form:\n * 3-args data-first, 2-args curried for {@link pipe}. Returns whatever\n * the handlers return.\n *\n * For files that also import `match` from `ts-pattern`, use a namespace\n * import (`import * as R from \"@onrails/result\"` → `R.match`) to dissolve\n * the collision.\n *\n * @example\n * ```ts\n * const html = match(parsed, (cfg) => render(cfg), (e) => renderError(e));\n * ```\n */\nexport const match: {\n  <T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U;\n  <T, E, U>(onOk: (value: T) => U, onErr: (error: E) => U): (result: Result<T, E>) => U;\n} = dual(\n  3,\n  <T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U =>\n    isOk(result) ? onOk(result.value) : onErr(result.error),\n);\n\n/**\n * Returns the `Ok` value, or `defaultValue` when the result is `Err`.\n *\n * @example\n * ```ts\n * unwrapOr(parsedSetting, \"default-value\");\n * ```\n */\nexport const unwrapOr: {\n  <T, E>(result: Result<T, E>, defaultValue: T): T;\n  <T>(defaultValue: T): <E>(result: Result<T, E>) => T;\n} = dual(\n  2,\n  <T, E>(result: Result<T, E>, defaultValue: T): T => (isOk(result) ? result.value : defaultValue),\n);\n\n/**\n * Test/assert helper — returns the `Ok` value, or **throws the original `Err`\n * value** when called on an `Err`. This is the assertion tier (RFC 0001 §4):\n * intended for `*.spec.ts` / `*.test.ts`, where throwing fails the test loudly.\n * In business logic prefer {@link match} or {@link unwrapOr}; the lint plugins\n * flag `unwrapOk` outside test files.\n *\n * @returns the unwrapped `Ok` value\n * @throws the carried `Err` value when the result is `Err`\n *\n * @example\n * ```ts\n * // in a *.spec.ts\n * expect(unwrapOk(ok(5))).toBe(5);\n * expect(() => unwrapOk(err(error))).toThrow(error);\n * ```\n */\nexport function unwrapOk<T, E>(result: Result<T, E>): T {\n  if (isErr(result)) throw result.error;\n  return result.value;\n}\n\n/** Alias of {@link unwrapOk} for syntax cohesion with `@onrails/maybe`. */\nexport const unwrap = unwrapOk;\n\n/**\n * Test/assert helper — returns the `Err` value, or **throws a `TypeError`**\n * when called on an `Ok`. Mirror of {@link unwrapOk} on the error track and\n * part of the same assertion tier (RFC 0001 §4): intended for `*.spec.ts` /\n * `*.test.ts`. Prefer {@link match} / {@link unwrapOr} in business logic; the\n * lint plugins flag `unwrapErr` outside test files.\n *\n * @returns the unwrapped `Err` value\n * @throws `TypeError` when the result is `Ok`\n *\n * @example\n * ```ts\n * // in a *.spec.ts\n * expect(unwrapErr(err(\"x\"))).toBe(\"x\");\n * expect(() => unwrapErr(ok(5))).toThrow(TypeError);\n * ```\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n  if (isOk(result)) throw new TypeError(\"unwrapErr called on Ok\");\n  return result.error;\n}\n\n/**\n * Wraps a throwing sync function, returning a function that produces a\n * {@link Result} instead of throwing. Thrown errors pass through `onThrow` to\n * become a typed `Err`; a normal return becomes `Ok`. The neverthrow analogue\n * is `Result.fromThrowable`.\n *\n * @param fn - the throwing function to wrap\n * @param onThrow - maps a thrown value to the `Err` channel\n * @returns a function with `fn`'s parameters that returns `Result<ReturnType, E>`\n *\n * @example\n * ```ts\n * type ParseError = { kind: \"parse\"; message: string };\n * const parse = trySync(\n *   JSON.parse,\n *   (e): ParseError => ({ kind: \"parse\", message: String(e) }),\n * );\n * parse(\"{}\");      // Ok({})\n * parse(\"nope\");    // Err({ kind: \"parse\", … })\n * ```\n */\nexport function trySync<A extends readonly unknown[], T, E>(\n  fn: (...args: A) => T,\n  onThrow: (error: unknown) => E,\n): (...args: A) => Result<T, E>;\nexport function trySync<F extends (...args: never) => unknown, E>(\n  fn: F,\n  onThrow: (error: unknown) => E,\n): (...args: Parameters<F>) => Result<ReturnType<F>, E>;\nexport function trySync(\n  fn: (...args: never) => unknown,\n  onThrow: (error: unknown) => unknown,\n): (...args: never) => Result<unknown, unknown> {\n  return (...args: never) => {\n    try {\n      return ok(fn(...args));\n    } catch (error) {\n      return err(onThrow(error));\n    }\n  };\n}\n\n/**\n * Variadic value-first pipe — threads `value` through up to nine unary fns,\n * left-to-right. Use {@link pipe} when you already have a starting value;\n * use {@link flow} to define a reusable composed function with no value yet.\n *\n * @example\n * ```ts\n * pipe(\n *   parseConfig(raw),\n *   map((cfg) => cfg.name),\n *   flatMap((name) => (name ? ok(name) : err({ kind: \"empty\" as const }))),\n *   tap(log),\n * );\n * ```\n */\nexport function pipe<A>(value: A): A;\nexport function pipe<A, B>(value: A, ab: (a: A) => B): B;\nexport function pipe<A, B, C>(value: A, ab: (a: A) => B, bc: (b: B) => C): C;\nexport function pipe<A, B, C, D>(value: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;\nexport function pipe<A, B, C, D, E>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n): E;\nexport function pipe<A, B, C, D, E, F>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n): F;\nexport function pipe<A, B, C, D, E, F, G>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n): G;\nexport function pipe<A, B, C, D, E, F, G, H>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n): I;\nexport function pipe(value: unknown, ...fns: ReadonlyArray<(x: unknown) => unknown>): unknown {\n  let acc = value;\n  for (const fn of fns) {\n    acc = fn(acc);\n  }\n  return acc;\n}\n\nconst printPayload = (payload: unknown): string => {\n  try {\n    return JSON.stringify(payload) ?? String(payload);\n  } catch {\n    // cyclic or non-JSON payload — a debug printer must not throw\n    return String(payload);\n  }\n};\n\n/**\n * Debug printer — renders a result as `Ok(…)` / `Err(…)` for logs. Payloads\n * print as JSON (values are plain data by design); non-JSON payloads fall\n * back to `String(...)`.\n *\n * @example\n * ```ts\n * show(ok(1));               // 'Ok(1)'\n * show(err({ kind: \"e\" })); // 'Err({\"kind\":\"e\"})'\n * ```\n */\nexport const show = <T, E>(result: Result<T, E>): string =>\n  isOk(result) ? `Ok(${printPayload(result.value)})` : `Err(${printPayload(result.error)})`;\n","import { err, isErr } from \"./result.js\";\nimport type { Result } from \"./types.js\";\n\n/** Internal control-flow signal — not part of public error types */\nclass ErrSignal<E> {\n  readonly _tag = \"ErrSignal\" as const;\n  constructor(readonly error: E) {}\n}\n\n/**\n * Unwraps a {@link Result} inside a {@link tryGen} block — the sync analogue of\n * Rust's `?` operator. On `Ok` it returns the value; on `Err` it short-circuits\n * the enclosing `tryGen`, which returns that `Err`. Only valid inside `tryGen`;\n * prefer {@link flatMap} / `pipe` for long pipelines.\n *\n * @returns the unwrapped `Ok` value\n *\n * @example\n * ```ts\n * const out = tryGen(() => {\n *   const a = yieldResult(parseA());   // unwrap or short-circuit\n *   const b = yieldResult(parseB());\n *   return ok(a + b);\n * });\n * ```\n */\nexport const yieldResult = <T, E>(result: Result<T, E>): T => {\n  if (isErr(result)) {\n    throw new ErrSignal(result.error);\n  }\n  return result.value;\n};\n\n/**\n * Terse alias of {@link yieldResult} (mirrors Rust's `?`), for compact\n * {@link tryGen} blocks.\n *\n * @example\n * ```ts\n * const out = tryGen(() => {\n *   const a = $(parseA());\n *   const b = $(parseB());\n *   return ok(a + b);\n * });\n * ```\n */\nexport const $ = yieldResult;\n\n/**\n * Run a block that uses {@link yieldResult}; returns the final `Result` or the first Err.\n *\n * @example\n * ```ts\n * const out = tryGen(() => {\n *   const a = $(parseA());\n *   const b = $(parseB());\n *   return ok(a + b);\n * });\n * ```\n */\nexport const tryGen = <T, E>(fn: () => Result<T, E>): Result<T, E> => {\n  try {\n    return fn();\n  } catch (error) {\n    if (error instanceof ErrSignal) {\n      return err(error.error);\n    }\n    throw error;\n  }\n};\n"]}
+{"version":3,"sources":["../src/internal/ctor.ts","../src/result.ts","../src/try-gen.ts"],"names":[],"mappings":";;;AAgBO,IAAM,KAAA,GAAQ,CAAyB,KAAA,MAA4B;AAAA,EACxE,IAAA,EAAM,KAAA;AAAA,EACN;AACF,CAAA,CAAA;ACyEO,IAAM,KAAA,GAAQ,CAAO,MAAA,KAA8C,MAAA,CAAO,IAAA,KAAS,KAAA;;;ACvF1F,IAAM,YAAN,MAAmB;AAAA,EAEjB,YAAqB,KAAA,EAAU;AAAV,IAAA,IAAA,CAAA,KAAA,GAAA,KAAA;AAAA,EAAW;AAAA,EAAX,KAAA;AAAA,EADZ,IAAA,GAAO,WAAA;AAElB,CAAA;AAmBO,IAAM,WAAA,GAAc,CAAO,MAAA,KAA4B;AAC5D,EAAA,IAAI,KAAA,CAAM,MAAM,CAAA,EAAG;AACjB,IAAA,MAAM,IAAI,SAAA,CAAU,MAAA,CAAO,KAAK,CAAA;AAAA,EAClC;AACA,EAAA,OAAO,MAAA,CAAO,KAAA;AAChB;AAeO,IAAM,CAAA,GAAI;AAcV,IAAM,MAAA,GAAS,CAAO,EAAA,KAAyC;AACpE,EAAA,IAAI;AACF,IAAA,OAAO,EAAA,EAAG;AAAA,EACZ,SAAS,KAAA,EAAO;AACd,IAAA,IAAI,iBAAiB,SAAA,EAAW;AAC9B,MAAA,OAAO,KAAA,CAAM,MAAM,KAAK,CAAA;AAAA,IAC1B;AACA,IAAA,MAAM,KAAA;AAAA,EACR;AACF","file":"try-gen.cjs","sourcesContent":["import type { Result } from \"../types.js\";\n\n/**\n * Unlocked `Ok` constructor for library internals.\n *\n * The public {@link ok} takes a `const` type parameter so caller literals stay\n * narrow. That is wrong inside a generic transform, where the payload type is\n * an unresolved type parameter and the resulting `Locked<T>` would never reduce\n * back to `T`. Internals build results through this constructor instead.\n */\nexport const mkOk = <T, E = never>(value: T): Result<T, E> => ({\n  _tag: \"Ok\",\n  value,\n});\n\n/** Unlocked `Err` constructor for library internals. Mirror of {@link mkOk}. */\nexport const mkErr = <T = never, E = unknown>(error: E): Result<T, E> => ({\n  _tag: \"Err\",\n  error,\n});\n","import { mkErr, mkOk } from \"./internal/ctor.js\";\nimport { dual } from \"./internal/dual.js\";\nimport type { Locked } from \"./internal/lock.js\";\nimport { toError } from \"./internal/to-error.js\";\nimport type { Err, Ok, Result } from \"./types.js\";\n\nexport type { Err, Ok, Result } from \"./types.js\";\n\n/**\n * Lifts a value into the success track.\n *\n * @example\n * ```ts\n * const r = ok(42);                          // Result<42, never> — literal locked\n * const typed: Result<number, \"parse\"> = ok(1);\n * const lift = <T, E>(v: T): Result<T, E> => ok<T, E>(v);  // explicit args opt out\n * ```\n *\n * @remarks\n * An inline literal keeps its narrow type instead of widening (`ok(\"a\")` is\n * `Result<\"a\", never>`, not `Result<string, never>`). Pass both type arguments\n * to opt out — generic code that must produce `Result<T, E>` for an unresolved\n * `T` needs that form.\n */\nexport function ok<const T>(value: T): Result<Locked<T>, never>;\nexport function ok<T, E>(value: T): Result<T, E>;\nexport function ok<T>(value: T): Result<T, never> {\n  // Safe: `Locked<T>` only unwraps the readonly tuple that `const` inference\n  // adds; the runtime payload is the value the caller passed, unchanged.\n  return mkOk(value);\n}\n\n/**\n * Fantasy Land `pure` — alias of {@link ok}. One lift name shared across the\n * trio (`of` / `Maybe.of` / `ResultAsync.of`) for generic and FL-style code.\n *\n * @example\n * ```ts\n * const r = of(42);   // Result<42, never> — identical to ok(42)\n * ```\n */\nexport const of = ok;\n\n/**\n * Lifts a value into the error track.\n *\n * @example\n * ```ts\n * const r = err({ kind: \"parse\", message: \"bad json\" });\n * // Result<never, { readonly kind: \"parse\"; readonly message: string }>\n *\n * type AppError = { kind: \"parse\" } | { kind: \"io\" };\n * err<AppError>({ kind: \"io\" });          // Result<never, AppError> — one arg names the error\n * err<number, AppError>({ kind: \"io\" });  // Result<number, AppError> — neverthrow's T, E order\n * ```\n *\n * @remarks\n * One explicit type argument names the **error** channel, which is what the\n * call site almost always means. Both channels still take neverthrow's `T, E`\n * order, and that two-argument form is also the escape hatch for generic code:\n * inference-driven calls lock literals, so a generic `E` must be passed\n * explicitly to keep the error type from being rewritten.\n */\nexport function err<const E>(error: E): Result<never, Locked<E>>;\nexport function err<T, E>(error: E): Result<T, E>;\nexport function err<E>(error: E): Result<never, E> {\n  // Safe: see the note on `ok` — `Locked` is a type-level unwrap only.\n  return mkErr(error);\n}\n\n/**\n * Type-narrowing predicate: returns `true` when the result is `Ok`.\n *\n * @example\n * ```ts\n * if (isOk(r)) {\n *   console.log(r.value);    // narrowed to Ok branch\n * }\n * ```\n */\nexport const isOk = <T, E>(result: Result<T, E>): result is Ok<T, E> => result._tag === \"Ok\";\n\n/**\n * Type-narrowing predicate: returns `true` when the result is `Err`.\n *\n * @example\n * ```ts\n * if (isErr(r)) {\n *   metrics.inc(\"error\", { kind: r.error.kind });\n * }\n * ```\n */\nexport const isErr = <T, E>(result: Result<T, E>): result is Err<T, E> => result._tag === \"Err\";\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Dual-form helpers — each export accepts either shape:\n//   data-first: `map(result, fn)`\n//   curried:    `map(fn)(result)`\n// Arity dispatch is derived from the internal `dual` combinator\n// (src/internal/dual.ts); the const annotation carries the public overloads.\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Transform the `Ok` value, passing `Err` through unchanged. Dual-form:\n * call data-first or curried (for use with {@link pipe}).\n *\n * @example\n * ```ts\n * map(ok(2), (n) => n * 3);          // Ok 6 — data-first\n * pipe(ok(\"x\"), map((s) => s.length));// Ok 1 — curried\n * ```\n */\nexport const map: {\n  <T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;\n  <T, U>(fn: (value: T) => U): <E>(result: Result<T, E>) => Result<U, E>;\n} = dual(\n  2,\n  <T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> =>\n    isOk(result) ? mkOk(fn(result.value)) : mkErr(result.error),\n);\n\n/**\n * Transform the `Err` value, passing `Ok` through unchanged. Useful for\n * unifying heterogeneous failure types into one app-level union.\n *\n * @example\n * ```ts\n * type AppError = { kind: \"http\"; status: number } | { kind: \"parse\" };\n * pipe(\n *   fetchSync(url),                                     // Result<Body, { status: number }>\n *   mapErr((e): AppError => ({ kind: \"http\", status: e.status })),\n * );\n * ```\n */\nexport const mapErr: {\n  <T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;\n  <E, F>(fn: (error: E) => F): <T>(result: Result<T, E>) => Result<T, F>;\n} = dual(\n  2,\n  <T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> =>\n    isErr(result) ? mkErr(fn(result.error)) : mkOk(result.value),\n);\n\n/**\n * Transform both tracks at once — `Ok` via `onOk`, `Err` via `onErr`.\n * Equivalent to `mapErr(onErr)(map(onOk)(result))` but in one pass.\n *\n * @example\n * ```ts\n * bimap(parsed, (cfg) => cfg.name, (e) => ({ kind: \"input\", cause: e }));\n * ```\n */\nexport const bimap: {\n  <T, U, E, F>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => F): Result<U, F>;\n  <T, U, E, F>(\n    onOk: (value: T) => U,\n    onErr: (error: E) => F,\n  ): (result: Result<T, E>) => Result<U, F>;\n} = dual(\n  3,\n  <T, U, E, F>(\n    result: Result<T, E>,\n    onOk: (value: T) => U,\n    onErr: (error: E) => F,\n  ): Result<U, F> => (isOk(result) ? mkOk(onOk(result.value)) : mkErr(onErr(result.error))),\n);\n\n/**\n * Canonical bind (Fantasy Land `chain`). Chains a Result-returning step,\n * widening the error union to `E | F`. Short-circuits on `Err`.\n *\n * @example\n * ```ts\n * flatMap(parseInput(raw), (data) =>\n *   data.id != null ? ok(data) : err({ kind: \"missing_id\" as const }),\n * );\n * // Result<Data, ParseError | { kind: \"missing_id\" }>\n * ```\n */\nexport const flatMap: {\n  <T, U, E, F>(result: Result<T, E>, fn: (value: T) => Result<U, F>): Result<U, E | F>;\n  <T, U, F>(fn: (value: T) => Result<U, F>): <E>(result: Result<T, E>) => Result<U, E | F>;\n} = dual(\n  2,\n  <T, U, E, F>(result: Result<T, E>, fn: (value: T) => Result<U, F>): Result<U, E | F> =>\n    isOk(result) ? fn(result.value) : mkErr(result.error),\n);\n\n/**\n * Error-track bind — runs `fn` only when the result is `Err`, allowing\n * a failed workflow to recover to `Ok` or remap the failure. Mirror of\n * {@link flatMap} on the error channel.\n *\n * @example\n * ```ts\n * recover(networkResult, (e) =>\n *   e.kind === \"rate_limit\" ? ok(cachedBody) : err(e),\n * );\n * ```\n */\nexport const recover: {\n  <T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F>;\n  <T, E, F>(fn: (error: E) => Result<T, F>): (result: Result<T, E>) => Result<T, F>;\n} = dual(\n  2,\n  <T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> =>\n    isErr(result) ? fn(result.error) : mkOk(result.value),\n);\n\n/**\n * Observe the `Ok` value for side effects (logging, metrics) without\n * changing the carried value. Passes `Err` through untouched.\n *\n * @example\n * ```ts\n * pipe(\n *   parseConfig(raw),\n *   tap((cfg) => log.info({ msg: \"parsed\", name: cfg.name })),\n *   flatMap(validate),\n * );\n * ```\n */\nexport const tap: {\n  <T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E>;\n  <T>(fn: (value: T) => void): <E>(result: Result<T, E>) => Result<T, E>;\n} = dual(2, <T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E> => {\n  if (isOk(result)) fn(result.value);\n  return result;\n});\n\n/**\n * Observe the `Err` value for side effects (logging, metrics) without\n * changing the carried error. Passes `Ok` through untouched.\n *\n * @example\n * ```ts\n * pipe(\n *   loadUser(id),\n *   tapErr((e) => metrics.inc(\"user.load.fail\", { kind: e.kind })),\n * );\n * ```\n */\nexport const tapErr: {\n  <T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E>;\n  <E>(fn: (error: E) => void): <T>(result: Result<T, E>) => Result<T, E>;\n} = dual(2, <T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E> => {\n  if (isErr(result)) fn(result.error);\n  return result;\n});\n\n/**\n * Terminal collapse — fold both tracks into a single value. Dual-form:\n * 3-args data-first, 2-args curried for {@link pipe}. Returns whatever\n * the handlers return.\n *\n * For files that also import `match` from `ts-pattern`, use a namespace\n * import (`import * as R from \"@onrails/result\"` → `R.match`) to dissolve\n * the collision.\n *\n * @example\n * ```ts\n * const html = match(parsed, (cfg) => render(cfg), (e) => renderError(e));\n * ```\n */\nexport const match: {\n  <T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U;\n  <T, E, U>(onOk: (value: T) => U, onErr: (error: E) => U): (result: Result<T, E>) => U;\n} = dual(\n  3,\n  <T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U =>\n    isOk(result) ? onOk(result.value) : onErr(result.error),\n);\n\n/**\n * Returns the `Ok` value, or `defaultValue` when the result is `Err`. The\n * fallback may be a different type from `T` — the return widens to `T | U`,\n * matching `ResultAsync.unwrapOr` and the compat shim.\n *\n * @example\n * ```ts\n * unwrapOr(parsedSetting, \"default-value\");  // string\n * unwrapOr(parsedPort, null);                // number | null\n * ```\n */\nexport const unwrapOr: {\n  <T, E, U>(result: Result<T, E>, defaultValue: U): T | U;\n  <U>(defaultValue: U): <T, E>(result: Result<T, E>) => T | U;\n} = dual(2, <T, E, U>(result: Result<T, E>, defaultValue: U): T | U =>\n  isOk(result) ? result.value : defaultValue,\n);\n\n/**\n * Test/assert helper — returns the `Ok` value, or **throws the original `Err`\n * value** when called on an `Err`. This is the assertion tier (RFC 0001 §4):\n * intended for `*.spec.ts` / `*.test.ts`, where throwing fails the test loudly.\n * In business logic prefer {@link match} or {@link unwrapOr}; the lint plugins\n * flag `unwrapOk` outside test files.\n *\n * @returns the unwrapped `Ok` value\n * @throws the carried `Err` value when the result is `Err`\n *\n * @example\n * ```ts\n * // in a *.spec.ts\n * expect(unwrapOk(ok(5))).toBe(5);\n * expect(() => unwrapOk(err(error))).toThrow(error);\n * ```\n */\nexport function unwrapOk<T, E>(result: Result<T, E>): T {\n  if (isErr(result)) throw result.error;\n  return result.value;\n}\n\n/** Alias of {@link unwrapOk} for syntax cohesion with `@onrails/maybe`. */\nexport const unwrap = unwrapOk;\n\n/**\n * Test/assert helper — returns the `Err` value, or **throws a `TypeError`**\n * when called on an `Ok`. Mirror of {@link unwrapOk} on the error track and\n * part of the same assertion tier (RFC 0001 §4): intended for `*.spec.ts` /\n * `*.test.ts`. Prefer {@link match} / {@link unwrapOr} in business logic; the\n * lint plugins flag `unwrapErr` outside test files.\n *\n * @returns the unwrapped `Err` value\n * @throws `TypeError` when the result is `Ok`\n *\n * @example\n * ```ts\n * // in a *.spec.ts\n * expect(unwrapErr(err(\"x\"))).toBe(\"x\");\n * expect(() => unwrapErr(ok(5))).toThrow(TypeError);\n * ```\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n  if (isOk(result)) throw new TypeError(\"unwrapErr called on Ok\");\n  return result.error;\n}\n\n/**\n * Wraps a throwing sync **function**, returning a function that produces a\n * {@link Result} instead of throwing. Thrown errors pass through `onThrow` to\n * become a typed `Err`; a normal return becomes `Ok`. Same name and shape as\n * neverthrow's `Result.fromThrowable`.\n *\n * Reach for {@link trySync} instead when you want to run the call right now\n * rather than build a reusable wrapper.\n *\n * @param fn - the throwing function to wrap\n * @param onThrow - maps a thrown value to the `Err` channel\n * @returns a function with `fn`'s parameters that returns `Result<ReturnType, E>`\n *\n * @example\n * ```ts\n * type ParseError = { kind: \"parse\"; message: string };\n * const parse = fromThrowable(\n *   JSON.parse,\n *   (e): ParseError => ({ kind: \"parse\", message: String(e) }),\n * );\n * parse(\"{}\");      // Ok({})\n * parse(\"nope\");    // Err({ kind: \"parse\", … })\n * ```\n */\nexport function fromThrowable<A extends readonly unknown[], T, E>(\n  fn: (...args: A) => T,\n  onThrow: (error: unknown) => E,\n): (...args: A) => Result<T, E>;\nexport function fromThrowable<F extends (...args: never) => unknown, E>(\n  fn: F,\n  onThrow: (error: unknown) => E,\n): (...args: Parameters<F>) => Result<ReturnType<F>, E>;\nexport function fromThrowable(\n  fn: (...args: never) => unknown,\n  onThrow: (error: unknown) => unknown,\n): (...args: never) => Result<unknown, unknown> {\n  return (...args: never) => {\n    try {\n      return mkOk(fn(...args));\n    } catch (error) {\n      return mkErr(onThrow(error));\n    }\n  };\n}\n\n/**\n * Runs `fn` **now**, catching a throw into the `Err` track — the sync mirror\n * of `tryAsync`. Without `onThrow` the thrown value is normalized to an\n * `Error`; pass a mapper for a typed error.\n *\n * To lift a throwing function once and call it many times, use\n * {@link fromThrowable}.\n *\n * @param fn - the throwing thunk to run\n * @param onThrow - maps a thrown value to the `Err` channel\n *\n * @example\n * ```ts\n * trySync(() => JSON.parse(raw));                    // Result<unknown, Error>\n * trySync(() => Schema.parse(input), (e): SchemaError => ({\n *   kind: \"schema\",\n *   cause: e,\n * }));\n * ```\n */\nexport function trySync<T>(fn: () => T): Result<T, Error>;\nexport function trySync<T, E>(fn: () => T, onThrow: (error: unknown) => E): Result<T, E>;\nexport function trySync<T, E>(fn: () => T, onThrow?: (error: unknown) => E): Result<T, E | Error> {\n  try {\n    return mkOk(fn());\n  } catch (error) {\n    return mkErr(onThrow ? onThrow(error) : toError(error));\n  }\n}\n\nconst printPayload = (payload: unknown): string => {\n  try {\n    return JSON.stringify(payload) ?? String(payload);\n  } catch {\n    // cyclic or non-JSON payload — a debug printer must not throw\n    return String(payload);\n  }\n};\n\n/**\n * Debug printer — renders a result as `Ok(…)` / `Err(…)` for logs. Payloads\n * print as JSON (values are plain data by design); non-JSON payloads fall\n * back to `String(...)`.\n *\n * @example\n * ```ts\n * show(ok(1));               // 'Ok(1)'\n * show(err({ kind: \"e\" })); // 'Err({\"kind\":\"e\"})'\n * ```\n */\nexport const show = <T, E>(result: Result<T, E>): string =>\n  isOk(result) ? `Ok(${printPayload(result.value)})` : `Err(${printPayload(result.error)})`;\n","import { mkErr } from \"./internal/ctor.js\";\nimport { isErr } from \"./result.js\";\nimport type { Result } from \"./types.js\";\n\n/** Internal control-flow signal — not part of public error types */\nclass ErrSignal<E> {\n  readonly _tag = \"ErrSignal\" as const;\n  constructor(readonly error: E) {}\n}\n\n/**\n * Unwraps a {@link Result} inside a {@link tryGen} block — the sync analogue of\n * Rust's `?` operator. On `Ok` it returns the value; on `Err` it short-circuits\n * the enclosing `tryGen`, which returns that `Err`. Only valid inside `tryGen`;\n * prefer {@link flatMap} / `pipe` for long pipelines.\n *\n * @returns the unwrapped `Ok` value\n *\n * @example\n * ```ts\n * const out = tryGen(() => {\n *   const a = yieldResult(parseA());   // unwrap or short-circuit\n *   const b = yieldResult(parseB());\n *   return ok(a + b);\n * });\n * ```\n */\nexport const yieldResult = <T, E>(result: Result<T, E>): T => {\n  if (isErr(result)) {\n    throw new ErrSignal(result.error);\n  }\n  return result.value;\n};\n\n/**\n * Terse alias of {@link yieldResult} (mirrors Rust's `?`), for compact\n * {@link tryGen} blocks.\n *\n * @example\n * ```ts\n * const out = tryGen(() => {\n *   const a = $(parseA());\n *   const b = $(parseB());\n *   return ok(a + b);\n * });\n * ```\n */\nexport const $ = yieldResult;\n\n/**\n * Run a block that uses {@link yieldResult}; returns the final `Result` or the first Err.\n *\n * @example\n * ```ts\n * const out = tryGen(() => {\n *   const a = $(parseA());\n *   const b = $(parseB());\n *   return ok(a + b);\n * });\n * ```\n */\nexport const tryGen = <T, E>(fn: () => Result<T, E>): Result<T, E> => {\n  try {\n    return fn();\n  } catch (error) {\n    if (error instanceof ErrSignal) {\n      return mkErr(error.error);\n    }\n    throw error;\n  }\n};\n"]}

package/dist/try-gen.d.cts

@@ -1,5 +1,4 @@
-import { R as Result } from './types-BQ9vv0nD.cjs';
-
+import type { Result } from "./types.js";
 /**
  * Unwraps a {@link Result} inside a {@link tryGen} block — the sync analogue of
  * Rust's `?` operator. On `Ok` it returns the value; on `Err` it short-circuits
@@ -17,7 +16,7 @@ import { R as Result } from './types-BQ9vv0nD.cjs';
  * });
  * ```
  */
-declare const yieldResult: <T, E>(result: Result<T, E>) => T;
+export declare const yieldResult: <T, E>(result: Result<T, E>) => T;
 /**
  * Terse alias of {@link yieldResult} (mirrors Rust's `?`), for compact
  * {@link tryGen} blocks.
@@ -31,7 +30,7 @@ declare const yieldResult: <T, E>(result: Result<T, E>) => T;
  * });
  * ```
  */
-declare const $: <T, E>(result: Result<T, E>) => T;
+export declare const $: typeof yieldResult;
 /**
  * Run a block that uses {@link yieldResult}; returns the final `Result` or the first Err.
  *
@@ -44,6 +43,4 @@ declare const $: <T, E>(result: Result<T, E>) => T;
  * });
  * ```
  */
-declare const tryGen: <T, E>(fn: () => Result<T, E>) => Result<T, E>;
-
-export { $, tryGen, yieldResult };
+export declare const tryGen: <T, E>(fn: () => Result<T, E>) => Result<T, E>;

package/dist/try-gen.d.ts

@@ -1,5 +1,4 @@
-import { R as Result } from './types-BQ9vv0nD.js';
-
+import type { Result } from "./types.js";
 /**
  * Unwraps a {@link Result} inside a {@link tryGen} block — the sync analogue of
  * Rust's `?` operator. On `Ok` it returns the value; on `Err` it short-circuits
@@ -17,7 +16,7 @@ import { R as Result } from './types-BQ9vv0nD.js';
  * });
  * ```
  */
-declare const yieldResult: <T, E>(result: Result<T, E>) => T;
+export declare const yieldResult: <T, E>(result: Result<T, E>) => T;
 /**
  * Terse alias of {@link yieldResult} (mirrors Rust's `?`), for compact
  * {@link tryGen} blocks.
@@ -31,7 +30,7 @@ declare const yieldResult: <T, E>(result: Result<T, E>) => T;
  * });
  * ```
  */
-declare const $: <T, E>(result: Result<T, E>) => T;
+export declare const $: typeof yieldResult;
 /**
  * Run a block that uses {@link yieldResult}; returns the final `Result` or the first Err.
  *
@@ -44,6 +43,4 @@ declare const $: <T, E>(result: Result<T, E>) => T;
  * });
  * ```
  */
-declare const tryGen: <T, E>(fn: () => Result<T, E>) => Result<T, E>;
-
-export { $, tryGen, yieldResult };
+export declare const tryGen: <T, E>(fn: () => Result<T, E>) => Result<T, E>;

package/dist/try-gen.js

@@ -1,5 +1,5 @@
-// src/internal/dual.ts
-var err = (error) => ({
+// src/internal/ctor.ts
+var mkErr = (error) => ({
   _tag: "Err",
   error
 });
@@ -25,7 +25,7 @@ var tryGen = (fn) => {
     return fn();
   } catch (error) {
     if (error instanceof ErrSignal) {
-      return err(error.error);
+      return mkErr(error.error);
     }
     throw error;
   }

package/dist/try-gen.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/result.ts","../src/try-gen.ts"],"names":[],"mappings":";AAuCO,IAAM,GAAA,GAAM,CAAyB,KAAA,MAA4B;AAAA,EACtE,IAAA,EAAM,KAAA;AAAA,EACN;AACF,CAAA,CAAA;AAwBO,IAAM,KAAA,GAAQ,CAAO,MAAA,KAA8C,MAAA,CAAO,IAAA,KAAS,KAAA;;;AC9D1F,IAAM,YAAN,MAAmB;AAAA,EAEjB,YAAqB,KAAA,EAAU;AAAV,IAAA,IAAA,CAAA,KAAA,GAAA,KAAA;AAAA,EAAW;AAAA,EAAX,KAAA;AAAA,EADZ,IAAA,GAAO,WAAA;AAElB,CAAA;AAmBO,IAAM,WAAA,GAAc,CAAO,MAAA,KAA4B;AAC5D,EAAA,IAAI,KAAA,CAAM,MAAM,CAAA,EAAG;AACjB,IAAA,MAAM,IAAI,SAAA,CAAU,MAAA,CAAO,KAAK,CAAA;AAAA,EAClC;AACA,EAAA,OAAO,MAAA,CAAO,KAAA;AAChB;AAeO,IAAM,CAAA,GAAI;AAcV,IAAM,MAAA,GAAS,CAAO,EAAA,KAAyC;AACpE,EAAA,IAAI;AACF,IAAA,OAAO,EAAA,EAAG;AAAA,EACZ,SAAS,KAAA,EAAO;AACd,IAAA,IAAI,iBAAiB,SAAA,EAAW;AAC9B,MAAA,OAAO,GAAA,CAAI,MAAM,KAAK,CAAA;AAAA,IACxB;AACA,IAAA,MAAM,KAAA;AAAA,EACR;AACF","file":"try-gen.js","sourcesContent":["import { dual } from \"./internal/dual.js\";\nimport type { Err, Ok, Result } from \"./types.js\";\n\nexport type { Err, Ok, Result } from \"./types.js\";\n\n/**\n * Lifts a value into the success track.\n *\n * @example\n * ```ts\n * const r = ok(42);                          // Result<number, never>\n * const typed: Result<number, \"parse\"> = ok(1);\n * ```\n */\nexport const ok = <T, E = never>(value: T): Result<T, E> => ({\n  _tag: \"Ok\",\n  value,\n});\n\n/**\n * Fantasy Land `pure` — alias of {@link ok}. One lift name shared across the\n * trio (`of` / `Maybe.of` / `ResultAsync.of`) for generic and FL-style code.\n *\n * @example\n * ```ts\n * const r = of(42);   // Result<number, never> — identical to ok(42)\n * ```\n */\nexport const of = ok;\n\n/**\n * Lifts a value into the error track.\n *\n * @example\n * ```ts\n * const r = err({ kind: \"parse\", message: \"bad json\" });\n * // Result<never, { kind: \"parse\"; message: string }>\n * ```\n */\nexport const err = <T = never, E = unknown>(error: E): Result<T, E> => ({\n  _tag: \"Err\",\n  error,\n});\n\n/**\n * Type-narrowing predicate: returns `true` when the result is `Ok`.\n *\n * @example\n * ```ts\n * if (isOk(r)) {\n *   console.log(r.value);    // narrowed to Ok branch\n * }\n * ```\n */\nexport const isOk = <T, E>(result: Result<T, E>): result is Ok<T, E> => result._tag === \"Ok\";\n\n/**\n * Type-narrowing predicate: returns `true` when the result is `Err`.\n *\n * @example\n * ```ts\n * if (isErr(r)) {\n *   metrics.inc(\"error\", { kind: r.error.kind });\n * }\n * ```\n */\nexport const isErr = <T, E>(result: Result<T, E>): result is Err<T, E> => result._tag === \"Err\";\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Dual-form helpers — each export accepts either shape:\n//   data-first: `map(result, fn)`\n//   curried:    `map(fn)(result)`\n// Arity dispatch is derived from the internal `dual` combinator\n// (src/internal/dual.ts); the const annotation carries the public overloads.\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Transform the `Ok` value, passing `Err` through unchanged. Dual-form:\n * call data-first or curried (for use with {@link pipe}).\n *\n * @example\n * ```ts\n * map(ok(2), (n) => n * 3);          // Ok 6 — data-first\n * pipe(ok(\"x\"), map((s) => s.length));// Ok 1 — curried\n * ```\n */\nexport const map: {\n  <T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;\n  <T, U>(fn: (value: T) => U): <E>(result: Result<T, E>) => Result<U, E>;\n} = dual(\n  2,\n  <T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> =>\n    isOk(result) ? ok(fn(result.value)) : err(result.error),\n);\n\n/**\n * Transform the `Err` value, passing `Ok` through unchanged. Useful for\n * unifying heterogeneous failure types into one app-level union.\n *\n * @example\n * ```ts\n * type AppError = { kind: \"http\"; status: number } | { kind: \"parse\" };\n * pipe(\n *   fetchSync(url),                                     // Result<Body, { status: number }>\n *   mapErr((e): AppError => ({ kind: \"http\", status: e.status })),\n * );\n * ```\n */\nexport const mapErr: {\n  <T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;\n  <E, F>(fn: (error: E) => F): <T>(result: Result<T, E>) => Result<T, F>;\n} = dual(\n  2,\n  <T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> =>\n    isErr(result) ? err(fn(result.error)) : ok(result.value),\n);\n\n/**\n * Transform both tracks at once — `Ok` via `onOk`, `Err` via `onErr`.\n * Equivalent to `mapErr(onErr)(map(onOk)(result))` but in one pass.\n *\n * @example\n * ```ts\n * bimap(parsed, (cfg) => cfg.name, (e) => ({ kind: \"input\", cause: e }));\n * ```\n */\nexport const bimap: {\n  <T, U, E, F>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => F): Result<U, F>;\n  <T, U, E, F>(\n    onOk: (value: T) => U,\n    onErr: (error: E) => F,\n  ): (result: Result<T, E>) => Result<U, F>;\n} = dual(\n  3,\n  <T, U, E, F>(\n    result: Result<T, E>,\n    onOk: (value: T) => U,\n    onErr: (error: E) => F,\n  ): Result<U, F> => (isOk(result) ? ok(onOk(result.value)) : err(onErr(result.error))),\n);\n\n/**\n * Canonical bind (Fantasy Land `chain`). Chains a Result-returning step,\n * widening the error union to `E | F`. Short-circuits on `Err`.\n *\n * @example\n * ```ts\n * flatMap(parseInput(raw), (data) =>\n *   data.id != null ? ok(data) : err({ kind: \"missing_id\" as const }),\n * );\n * // Result<Data, ParseError | { kind: \"missing_id\" }>\n * ```\n */\nexport const flatMap: {\n  <T, U, E, F>(result: Result<T, E>, fn: (value: T) => Result<U, F>): Result<U, E | F>;\n  <T, U, F>(fn: (value: T) => Result<U, F>): <E>(result: Result<T, E>) => Result<U, E | F>;\n} = dual(\n  2,\n  <T, U, E, F>(result: Result<T, E>, fn: (value: T) => Result<U, F>): Result<U, E | F> =>\n    isOk(result) ? fn(result.value) : err(result.error),\n);\n\n/**\n * Error-track bind — runs `fn` only when the result is `Err`, allowing\n * a failed workflow to recover to `Ok` or remap the failure. Mirror of\n * {@link flatMap} on the error channel.\n *\n * @example\n * ```ts\n * recover(networkResult, (e) =>\n *   e.kind === \"rate_limit\" ? ok(cachedBody) : err(e),\n * );\n * ```\n */\nexport const recover: {\n  <T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F>;\n  <T, E, F>(fn: (error: E) => Result<T, F>): (result: Result<T, E>) => Result<T, F>;\n} = dual(\n  2,\n  <T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> =>\n    isErr(result) ? fn(result.error) : ok(result.value),\n);\n\n/**\n * Observe the `Ok` value for side effects (logging, metrics) without\n * changing the carried value. Passes `Err` through untouched.\n *\n * @example\n * ```ts\n * pipe(\n *   parseConfig(raw),\n *   tap((cfg) => log.info({ msg: \"parsed\", name: cfg.name })),\n *   flatMap(validate),\n * );\n * ```\n */\nexport const tap: {\n  <T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E>;\n  <T>(fn: (value: T) => void): <E>(result: Result<T, E>) => Result<T, E>;\n} = dual(2, <T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E> => {\n  if (isOk(result)) fn(result.value);\n  return result;\n});\n\n/**\n * Observe the `Err` value for side effects (logging, metrics) without\n * changing the carried error. Passes `Ok` through untouched.\n *\n * @example\n * ```ts\n * pipe(\n *   loadUser(id),\n *   tapErr((e) => metrics.inc(\"user.load.fail\", { kind: e.kind })),\n * );\n * ```\n */\nexport const tapErr: {\n  <T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E>;\n  <E>(fn: (error: E) => void): <T>(result: Result<T, E>) => Result<T, E>;\n} = dual(2, <T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E> => {\n  if (isErr(result)) fn(result.error);\n  return result;\n});\n\n/**\n * Terminal collapse — fold both tracks into a single value. Dual-form:\n * 3-args data-first, 2-args curried for {@link pipe}. Returns whatever\n * the handlers return.\n *\n * For files that also import `match` from `ts-pattern`, use a namespace\n * import (`import * as R from \"@onrails/result\"` → `R.match`) to dissolve\n * the collision.\n *\n * @example\n * ```ts\n * const html = match(parsed, (cfg) => render(cfg), (e) => renderError(e));\n * ```\n */\nexport const match: {\n  <T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U;\n  <T, E, U>(onOk: (value: T) => U, onErr: (error: E) => U): (result: Result<T, E>) => U;\n} = dual(\n  3,\n  <T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U =>\n    isOk(result) ? onOk(result.value) : onErr(result.error),\n);\n\n/**\n * Returns the `Ok` value, or `defaultValue` when the result is `Err`.\n *\n * @example\n * ```ts\n * unwrapOr(parsedSetting, \"default-value\");\n * ```\n */\nexport const unwrapOr: {\n  <T, E>(result: Result<T, E>, defaultValue: T): T;\n  <T>(defaultValue: T): <E>(result: Result<T, E>) => T;\n} = dual(\n  2,\n  <T, E>(result: Result<T, E>, defaultValue: T): T => (isOk(result) ? result.value : defaultValue),\n);\n\n/**\n * Test/assert helper — returns the `Ok` value, or **throws the original `Err`\n * value** when called on an `Err`. This is the assertion tier (RFC 0001 §4):\n * intended for `*.spec.ts` / `*.test.ts`, where throwing fails the test loudly.\n * In business logic prefer {@link match} or {@link unwrapOr}; the lint plugins\n * flag `unwrapOk` outside test files.\n *\n * @returns the unwrapped `Ok` value\n * @throws the carried `Err` value when the result is `Err`\n *\n * @example\n * ```ts\n * // in a *.spec.ts\n * expect(unwrapOk(ok(5))).toBe(5);\n * expect(() => unwrapOk(err(error))).toThrow(error);\n * ```\n */\nexport function unwrapOk<T, E>(result: Result<T, E>): T {\n  if (isErr(result)) throw result.error;\n  return result.value;\n}\n\n/** Alias of {@link unwrapOk} for syntax cohesion with `@onrails/maybe`. */\nexport const unwrap = unwrapOk;\n\n/**\n * Test/assert helper — returns the `Err` value, or **throws a `TypeError`**\n * when called on an `Ok`. Mirror of {@link unwrapOk} on the error track and\n * part of the same assertion tier (RFC 0001 §4): intended for `*.spec.ts` /\n * `*.test.ts`. Prefer {@link match} / {@link unwrapOr} in business logic; the\n * lint plugins flag `unwrapErr` outside test files.\n *\n * @returns the unwrapped `Err` value\n * @throws `TypeError` when the result is `Ok`\n *\n * @example\n * ```ts\n * // in a *.spec.ts\n * expect(unwrapErr(err(\"x\"))).toBe(\"x\");\n * expect(() => unwrapErr(ok(5))).toThrow(TypeError);\n * ```\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n  if (isOk(result)) throw new TypeError(\"unwrapErr called on Ok\");\n  return result.error;\n}\n\n/**\n * Wraps a throwing sync function, returning a function that produces a\n * {@link Result} instead of throwing. Thrown errors pass through `onThrow` to\n * become a typed `Err`; a normal return becomes `Ok`. The neverthrow analogue\n * is `Result.fromThrowable`.\n *\n * @param fn - the throwing function to wrap\n * @param onThrow - maps a thrown value to the `Err` channel\n * @returns a function with `fn`'s parameters that returns `Result<ReturnType, E>`\n *\n * @example\n * ```ts\n * type ParseError = { kind: \"parse\"; message: string };\n * const parse = trySync(\n *   JSON.parse,\n *   (e): ParseError => ({ kind: \"parse\", message: String(e) }),\n * );\n * parse(\"{}\");      // Ok({})\n * parse(\"nope\");    // Err({ kind: \"parse\", … })\n * ```\n */\nexport function trySync<A extends readonly unknown[], T, E>(\n  fn: (...args: A) => T,\n  onThrow: (error: unknown) => E,\n): (...args: A) => Result<T, E>;\nexport function trySync<F extends (...args: never) => unknown, E>(\n  fn: F,\n  onThrow: (error: unknown) => E,\n): (...args: Parameters<F>) => Result<ReturnType<F>, E>;\nexport function trySync(\n  fn: (...args: never) => unknown,\n  onThrow: (error: unknown) => unknown,\n): (...args: never) => Result<unknown, unknown> {\n  return (...args: never) => {\n    try {\n      return ok(fn(...args));\n    } catch (error) {\n      return err(onThrow(error));\n    }\n  };\n}\n\n/**\n * Variadic value-first pipe — threads `value` through up to nine unary fns,\n * left-to-right. Use {@link pipe} when you already have a starting value;\n * use {@link flow} to define a reusable composed function with no value yet.\n *\n * @example\n * ```ts\n * pipe(\n *   parseConfig(raw),\n *   map((cfg) => cfg.name),\n *   flatMap((name) => (name ? ok(name) : err({ kind: \"empty\" as const }))),\n *   tap(log),\n * );\n * ```\n */\nexport function pipe<A>(value: A): A;\nexport function pipe<A, B>(value: A, ab: (a: A) => B): B;\nexport function pipe<A, B, C>(value: A, ab: (a: A) => B, bc: (b: B) => C): C;\nexport function pipe<A, B, C, D>(value: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;\nexport function pipe<A, B, C, D, E>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n): E;\nexport function pipe<A, B, C, D, E, F>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n): F;\nexport function pipe<A, B, C, D, E, F, G>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n): G;\nexport function pipe<A, B, C, D, E, F, G, H>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n): H;\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  value: A,\n  ab: (a: A) => B,\n  bc: (b: B) => C,\n  cd: (c: C) => D,\n  de: (d: D) => E,\n  ef: (e: E) => F,\n  fg: (f: F) => G,\n  gh: (g: G) => H,\n  hi: (h: H) => I,\n): I;\nexport function pipe(value: unknown, ...fns: ReadonlyArray<(x: unknown) => unknown>): unknown {\n  let acc = value;\n  for (const fn of fns) {\n    acc = fn(acc);\n  }\n  return acc;\n}\n\nconst printPayload = (payload: unknown): string => {\n  try {\n    return JSON.stringify(payload) ?? String(payload);\n  } catch {\n    // cyclic or non-JSON payload — a debug printer must not throw\n    return String(payload);\n  }\n};\n\n/**\n * Debug printer — renders a result as `Ok(…)` / `Err(…)` for logs. Payloads\n * print as JSON (values are plain data by design); non-JSON payloads fall\n * back to `String(...)`.\n *\n * @example\n * ```ts\n * show(ok(1));               // 'Ok(1)'\n * show(err({ kind: \"e\" })); // 'Err({\"kind\":\"e\"})'\n * ```\n */\nexport const show = <T, E>(result: Result<T, E>): string =>\n  isOk(result) ? `Ok(${printPayload(result.value)})` : `Err(${printPayload(result.error)})`;\n","import { err, isErr } from \"./result.js\";\nimport type { Result } from \"./types.js\";\n\n/** Internal control-flow signal — not part of public error types */\nclass ErrSignal<E> {\n  readonly _tag = \"ErrSignal\" as const;\n  constructor(readonly error: E) {}\n}\n\n/**\n * Unwraps a {@link Result} inside a {@link tryGen} block — the sync analogue of\n * Rust's `?` operator. On `Ok` it returns the value; on `Err` it short-circuits\n * the enclosing `tryGen`, which returns that `Err`. Only valid inside `tryGen`;\n * prefer {@link flatMap} / `pipe` for long pipelines.\n *\n * @returns the unwrapped `Ok` value\n *\n * @example\n * ```ts\n * const out = tryGen(() => {\n *   const a = yieldResult(parseA());   // unwrap or short-circuit\n *   const b = yieldResult(parseB());\n *   return ok(a + b);\n * });\n * ```\n */\nexport const yieldResult = <T, E>(result: Result<T, E>): T => {\n  if (isErr(result)) {\n    throw new ErrSignal(result.error);\n  }\n  return result.value;\n};\n\n/**\n * Terse alias of {@link yieldResult} (mirrors Rust's `?`), for compact\n * {@link tryGen} blocks.\n *\n * @example\n * ```ts\n * const out = tryGen(() => {\n *   const a = $(parseA());\n *   const b = $(parseB());\n *   return ok(a + b);\n * });\n * ```\n */\nexport const $ = yieldResult;\n\n/**\n * Run a block that uses {@link yieldResult}; returns the final `Result` or the first Err.\n *\n * @example\n * ```ts\n * const out = tryGen(() => {\n *   const a = $(parseA());\n *   const b = $(parseB());\n *   return ok(a + b);\n * });\n * ```\n */\nexport const tryGen = <T, E>(fn: () => Result<T, E>): Result<T, E> => {\n  try {\n    return fn();\n  } catch (error) {\n    if (error instanceof ErrSignal) {\n      return err(error.error);\n    }\n    throw error;\n  }\n};\n"]}
+{"version":3,"sources":["../src/internal/ctor.ts","../src/result.ts","../src/try-gen.ts"],"names":[],"mappings":";AAgBO,IAAM,KAAA,GAAQ,CAAyB,KAAA,MAA4B;AAAA,EACxE,IAAA,EAAM,KAAA;AAAA,EACN;AACF,CAAA,CAAA;ACyEO,IAAM,KAAA,GAAQ,CAAO,MAAA,KAA8C,MAAA,CAAO,IAAA,KAAS,KAAA;;;ACvF1F,IAAM,YAAN,MAAmB;AAAA,EAEjB,YAAqB,KAAA,EAAU;AAAV,IAAA,IAAA,CAAA,KAAA,GAAA,KAAA;AAAA,EAAW;AAAA,EAAX,KAAA;AAAA,EADZ,IAAA,GAAO,WAAA;AAElB,CAAA;AAmBO,IAAM,WAAA,GAAc,CAAO,MAAA,KAA4B;AAC5D,EAAA,IAAI,KAAA,CAAM,MAAM,CAAA,EAAG;AACjB,IAAA,MAAM,IAAI,SAAA,CAAU,MAAA,CAAO,KAAK,CAAA;AAAA,EAClC;AACA,EAAA,OAAO,MAAA,CAAO,KAAA;AAChB;AAeO,IAAM,CAAA,GAAI;AAcV,IAAM,MAAA,GAAS,CAAO,EAAA,KAAyC;AACpE,EAAA,IAAI;AACF,IAAA,OAAO,EAAA,EAAG;AAAA,EACZ,SAAS,KAAA,EAAO;AACd,IAAA,IAAI,iBAAiB,SAAA,EAAW;AAC9B,MAAA,OAAO,KAAA,CAAM,MAAM,KAAK,CAAA;AAAA,IAC1B;AACA,IAAA,MAAM,KAAA;AAAA,EACR;AACF","file":"try-gen.js","sourcesContent":["import type { Result } from \"../types.js\";\n\n/**\n * Unlocked `Ok` constructor for library internals.\n *\n * The public {@link ok} takes a `const` type parameter so caller literals stay\n * narrow. That is wrong inside a generic transform, where the payload type is\n * an unresolved type parameter and the resulting `Locked<T>` would never reduce\n * back to `T`. Internals build results through this constructor instead.\n */\nexport const mkOk = <T, E = never>(value: T): Result<T, E> => ({\n  _tag: \"Ok\",\n  value,\n});\n\n/** Unlocked `Err` constructor for library internals. Mirror of {@link mkOk}. */\nexport const mkErr = <T = never, E = unknown>(error: E): Result<T, E> => ({\n  _tag: \"Err\",\n  error,\n});\n","import { mkErr, mkOk } from \"./internal/ctor.js\";\nimport { dual } from \"./internal/dual.js\";\nimport type { Locked } from \"./internal/lock.js\";\nimport { toError } from \"./internal/to-error.js\";\nimport type { Err, Ok, Result } from \"./types.js\";\n\nexport type { Err, Ok, Result } from \"./types.js\";\n\n/**\n * Lifts a value into the success track.\n *\n * @example\n * ```ts\n * const r = ok(42);                          // Result<42, never> — literal locked\n * const typed: Result<number, \"parse\"> = ok(1);\n * const lift = <T, E>(v: T): Result<T, E> => ok<T, E>(v);  // explicit args opt out\n * ```\n *\n * @remarks\n * An inline literal keeps its narrow type instead of widening (`ok(\"a\")` is\n * `Result<\"a\", never>`, not `Result<string, never>`). Pass both type arguments\n * to opt out — generic code that must produce `Result<T, E>` for an unresolved\n * `T` needs that form.\n */\nexport function ok<const T>(value: T): Result<Locked<T>, never>;\nexport function ok<T, E>(value: T): Result<T, E>;\nexport function ok<T>(value: T): Result<T, never> {\n  // Safe: `Locked<T>` only unwraps the readonly tuple that `const` inference\n  // adds; the runtime payload is the value the caller passed, unchanged.\n  return mkOk(value);\n}\n\n/**\n * Fantasy Land `pure` — alias of {@link ok}. One lift name shared across the\n * trio (`of` / `Maybe.of` / `ResultAsync.of`) for generic and FL-style code.\n *\n * @example\n * ```ts\n * const r = of(42);   // Result<42, never> — identical to ok(42)\n * ```\n */\nexport const of = ok;\n\n/**\n * Lifts a value into the error track.\n *\n * @example\n * ```ts\n * const r = err({ kind: \"parse\", message: \"bad json\" });\n * // Result<never, { readonly kind: \"parse\"; readonly message: string }>\n *\n * type AppError = { kind: \"parse\" } | { kind: \"io\" };\n * err<AppError>({ kind: \"io\" });          // Result<never, AppError> — one arg names the error\n * err<number, AppError>({ kind: \"io\" });  // Result<number, AppError> — neverthrow's T, E order\n * ```\n *\n * @remarks\n * One explicit type argument names the **error** channel, which is what the\n * call site almost always means. Both channels still take neverthrow's `T, E`\n * order, and that two-argument form is also the escape hatch for generic code:\n * inference-driven calls lock literals, so a generic `E` must be passed\n * explicitly to keep the error type from being rewritten.\n */\nexport function err<const E>(error: E): Result<never, Locked<E>>;\nexport function err<T, E>(error: E): Result<T, E>;\nexport function err<E>(error: E): Result<never, E> {\n  // Safe: see the note on `ok` — `Locked` is a type-level unwrap only.\n  return mkErr(error);\n}\n\n/**\n * Type-narrowing predicate: returns `true` when the result is `Ok`.\n *\n * @example\n * ```ts\n * if (isOk(r)) {\n *   console.log(r.value);    // narrowed to Ok branch\n * }\n * ```\n */\nexport const isOk = <T, E>(result: Result<T, E>): result is Ok<T, E> => result._tag === \"Ok\";\n\n/**\n * Type-narrowing predicate: returns `true` when the result is `Err`.\n *\n * @example\n * ```ts\n * if (isErr(r)) {\n *   metrics.inc(\"error\", { kind: r.error.kind });\n * }\n * ```\n */\nexport const isErr = <T, E>(result: Result<T, E>): result is Err<T, E> => result._tag === \"Err\";\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Dual-form helpers — each export accepts either shape:\n//   data-first: `map(result, fn)`\n//   curried:    `map(fn)(result)`\n// Arity dispatch is derived from the internal `dual` combinator\n// (src/internal/dual.ts); the const annotation carries the public overloads.\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Transform the `Ok` value, passing `Err` through unchanged. Dual-form:\n * call data-first or curried (for use with {@link pipe}).\n *\n * @example\n * ```ts\n * map(ok(2), (n) => n * 3);          // Ok 6 — data-first\n * pipe(ok(\"x\"), map((s) => s.length));// Ok 1 — curried\n * ```\n */\nexport const map: {\n  <T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;\n  <T, U>(fn: (value: T) => U): <E>(result: Result<T, E>) => Result<U, E>;\n} = dual(\n  2,\n  <T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> =>\n    isOk(result) ? mkOk(fn(result.value)) : mkErr(result.error),\n);\n\n/**\n * Transform the `Err` value, passing `Ok` through unchanged. Useful for\n * unifying heterogeneous failure types into one app-level union.\n *\n * @example\n * ```ts\n * type AppError = { kind: \"http\"; status: number } | { kind: \"parse\" };\n * pipe(\n *   fetchSync(url),                                     // Result<Body, { status: number }>\n *   mapErr((e): AppError => ({ kind: \"http\", status: e.status })),\n * );\n * ```\n */\nexport const mapErr: {\n  <T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;\n  <E, F>(fn: (error: E) => F): <T>(result: Result<T, E>) => Result<T, F>;\n} = dual(\n  2,\n  <T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> =>\n    isErr(result) ? mkErr(fn(result.error)) : mkOk(result.value),\n);\n\n/**\n * Transform both tracks at once — `Ok` via `onOk`, `Err` via `onErr`.\n * Equivalent to `mapErr(onErr)(map(onOk)(result))` but in one pass.\n *\n * @example\n * ```ts\n * bimap(parsed, (cfg) => cfg.name, (e) => ({ kind: \"input\", cause: e }));\n * ```\n */\nexport const bimap: {\n  <T, U, E, F>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => F): Result<U, F>;\n  <T, U, E, F>(\n    onOk: (value: T) => U,\n    onErr: (error: E) => F,\n  ): (result: Result<T, E>) => Result<U, F>;\n} = dual(\n  3,\n  <T, U, E, F>(\n    result: Result<T, E>,\n    onOk: (value: T) => U,\n    onErr: (error: E) => F,\n  ): Result<U, F> => (isOk(result) ? mkOk(onOk(result.value)) : mkErr(onErr(result.error))),\n);\n\n/**\n * Canonical bind (Fantasy Land `chain`). Chains a Result-returning step,\n * widening the error union to `E | F`. Short-circuits on `Err`.\n *\n * @example\n * ```ts\n * flatMap(parseInput(raw), (data) =>\n *   data.id != null ? ok(data) : err({ kind: \"missing_id\" as const }),\n * );\n * // Result<Data, ParseError | { kind: \"missing_id\" }>\n * ```\n */\nexport const flatMap: {\n  <T, U, E, F>(result: Result<T, E>, fn: (value: T) => Result<U, F>): Result<U, E | F>;\n  <T, U, F>(fn: (value: T) => Result<U, F>): <E>(result: Result<T, E>) => Result<U, E | F>;\n} = dual(\n  2,\n  <T, U, E, F>(result: Result<T, E>, fn: (value: T) => Result<U, F>): Result<U, E | F> =>\n    isOk(result) ? fn(result.value) : mkErr(result.error),\n);\n\n/**\n * Error-track bind — runs `fn` only when the result is `Err`, allowing\n * a failed workflow to recover to `Ok` or remap the failure. Mirror of\n * {@link flatMap} on the error channel.\n *\n * @example\n * ```ts\n * recover(networkResult, (e) =>\n *   e.kind === \"rate_limit\" ? ok(cachedBody) : err(e),\n * );\n * ```\n */\nexport const recover: {\n  <T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F>;\n  <T, E, F>(fn: (error: E) => Result<T, F>): (result: Result<T, E>) => Result<T, F>;\n} = dual(\n  2,\n  <T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> =>\n    isErr(result) ? fn(result.error) : mkOk(result.value),\n);\n\n/**\n * Observe the `Ok` value for side effects (logging, metrics) without\n * changing the carried value. Passes `Err` through untouched.\n *\n * @example\n * ```ts\n * pipe(\n *   parseConfig(raw),\n *   tap((cfg) => log.info({ msg: \"parsed\", name: cfg.name })),\n *   flatMap(validate),\n * );\n * ```\n */\nexport const tap: {\n  <T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E>;\n  <T>(fn: (value: T) => void): <E>(result: Result<T, E>) => Result<T, E>;\n} = dual(2, <T, E>(result: Result<T, E>, fn: (value: T) => void): Result<T, E> => {\n  if (isOk(result)) fn(result.value);\n  return result;\n});\n\n/**\n * Observe the `Err` value for side effects (logging, metrics) without\n * changing the carried error. Passes `Ok` through untouched.\n *\n * @example\n * ```ts\n * pipe(\n *   loadUser(id),\n *   tapErr((e) => metrics.inc(\"user.load.fail\", { kind: e.kind })),\n * );\n * ```\n */\nexport const tapErr: {\n  <T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E>;\n  <E>(fn: (error: E) => void): <T>(result: Result<T, E>) => Result<T, E>;\n} = dual(2, <T, E>(result: Result<T, E>, fn: (error: E) => void): Result<T, E> => {\n  if (isErr(result)) fn(result.error);\n  return result;\n});\n\n/**\n * Terminal collapse — fold both tracks into a single value. Dual-form:\n * 3-args data-first, 2-args curried for {@link pipe}. Returns whatever\n * the handlers return.\n *\n * For files that also import `match` from `ts-pattern`, use a namespace\n * import (`import * as R from \"@onrails/result\"` → `R.match`) to dissolve\n * the collision.\n *\n * @example\n * ```ts\n * const html = match(parsed, (cfg) => render(cfg), (e) => renderError(e));\n * ```\n */\nexport const match: {\n  <T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U;\n  <T, E, U>(onOk: (value: T) => U, onErr: (error: E) => U): (result: Result<T, E>) => U;\n} = dual(\n  3,\n  <T, E, U>(result: Result<T, E>, onOk: (value: T) => U, onErr: (error: E) => U): U =>\n    isOk(result) ? onOk(result.value) : onErr(result.error),\n);\n\n/**\n * Returns the `Ok` value, or `defaultValue` when the result is `Err`. The\n * fallback may be a different type from `T` — the return widens to `T | U`,\n * matching `ResultAsync.unwrapOr` and the compat shim.\n *\n * @example\n * ```ts\n * unwrapOr(parsedSetting, \"default-value\");  // string\n * unwrapOr(parsedPort, null);                // number | null\n * ```\n */\nexport const unwrapOr: {\n  <T, E, U>(result: Result<T, E>, defaultValue: U): T | U;\n  <U>(defaultValue: U): <T, E>(result: Result<T, E>) => T | U;\n} = dual(2, <T, E, U>(result: Result<T, E>, defaultValue: U): T | U =>\n  isOk(result) ? result.value : defaultValue,\n);\n\n/**\n * Test/assert helper — returns the `Ok` value, or **throws the original `Err`\n * value** when called on an `Err`. This is the assertion tier (RFC 0001 §4):\n * intended for `*.spec.ts` / `*.test.ts`, where throwing fails the test loudly.\n * In business logic prefer {@link match} or {@link unwrapOr}; the lint plugins\n * flag `unwrapOk` outside test files.\n *\n * @returns the unwrapped `Ok` value\n * @throws the carried `Err` value when the result is `Err`\n *\n * @example\n * ```ts\n * // in a *.spec.ts\n * expect(unwrapOk(ok(5))).toBe(5);\n * expect(() => unwrapOk(err(error))).toThrow(error);\n * ```\n */\nexport function unwrapOk<T, E>(result: Result<T, E>): T {\n  if (isErr(result)) throw result.error;\n  return result.value;\n}\n\n/** Alias of {@link unwrapOk} for syntax cohesion with `@onrails/maybe`. */\nexport const unwrap = unwrapOk;\n\n/**\n * Test/assert helper — returns the `Err` value, or **throws a `TypeError`**\n * when called on an `Ok`. Mirror of {@link unwrapOk} on the error track and\n * part of the same assertion tier (RFC 0001 §4): intended for `*.spec.ts` /\n * `*.test.ts`. Prefer {@link match} / {@link unwrapOr} in business logic; the\n * lint plugins flag `unwrapErr` outside test files.\n *\n * @returns the unwrapped `Err` value\n * @throws `TypeError` when the result is `Ok`\n *\n * @example\n * ```ts\n * // in a *.spec.ts\n * expect(unwrapErr(err(\"x\"))).toBe(\"x\");\n * expect(() => unwrapErr(ok(5))).toThrow(TypeError);\n * ```\n */\nexport function unwrapErr<T, E>(result: Result<T, E>): E {\n  if (isOk(result)) throw new TypeError(\"unwrapErr called on Ok\");\n  return result.error;\n}\n\n/**\n * Wraps a throwing sync **function**, returning a function that produces a\n * {@link Result} instead of throwing. Thrown errors pass through `onThrow` to\n * become a typed `Err`; a normal return becomes `Ok`. Same name and shape as\n * neverthrow's `Result.fromThrowable`.\n *\n * Reach for {@link trySync} instead when you want to run the call right now\n * rather than build a reusable wrapper.\n *\n * @param fn - the throwing function to wrap\n * @param onThrow - maps a thrown value to the `Err` channel\n * @returns a function with `fn`'s parameters that returns `Result<ReturnType, E>`\n *\n * @example\n * ```ts\n * type ParseError = { kind: \"parse\"; message: string };\n * const parse = fromThrowable(\n *   JSON.parse,\n *   (e): ParseError => ({ kind: \"parse\", message: String(e) }),\n * );\n * parse(\"{}\");      // Ok({})\n * parse(\"nope\");    // Err({ kind: \"parse\", … })\n * ```\n */\nexport function fromThrowable<A extends readonly unknown[], T, E>(\n  fn: (...args: A) => T,\n  onThrow: (error: unknown) => E,\n): (...args: A) => Result<T, E>;\nexport function fromThrowable<F extends (...args: never) => unknown, E>(\n  fn: F,\n  onThrow: (error: unknown) => E,\n): (...args: Parameters<F>) => Result<ReturnType<F>, E>;\nexport function fromThrowable(\n  fn: (...args: never) => unknown,\n  onThrow: (error: unknown) => unknown,\n): (...args: never) => Result<unknown, unknown> {\n  return (...args: never) => {\n    try {\n      return mkOk(fn(...args));\n    } catch (error) {\n      return mkErr(onThrow(error));\n    }\n  };\n}\n\n/**\n * Runs `fn` **now**, catching a throw into the `Err` track — the sync mirror\n * of `tryAsync`. Without `onThrow` the thrown value is normalized to an\n * `Error`; pass a mapper for a typed error.\n *\n * To lift a throwing function once and call it many times, use\n * {@link fromThrowable}.\n *\n * @param fn - the throwing thunk to run\n * @param onThrow - maps a thrown value to the `Err` channel\n *\n * @example\n * ```ts\n * trySync(() => JSON.parse(raw));                    // Result<unknown, Error>\n * trySync(() => Schema.parse(input), (e): SchemaError => ({\n *   kind: \"schema\",\n *   cause: e,\n * }));\n * ```\n */\nexport function trySync<T>(fn: () => T): Result<T, Error>;\nexport function trySync<T, E>(fn: () => T, onThrow: (error: unknown) => E): Result<T, E>;\nexport function trySync<T, E>(fn: () => T, onThrow?: (error: unknown) => E): Result<T, E | Error> {\n  try {\n    return mkOk(fn());\n  } catch (error) {\n    return mkErr(onThrow ? onThrow(error) : toError(error));\n  }\n}\n\nconst printPayload = (payload: unknown): string => {\n  try {\n    return JSON.stringify(payload) ?? String(payload);\n  } catch {\n    // cyclic or non-JSON payload — a debug printer must not throw\n    return String(payload);\n  }\n};\n\n/**\n * Debug printer — renders a result as `Ok(…)` / `Err(…)` for logs. Payloads\n * print as JSON (values are plain data by design); non-JSON payloads fall\n * back to `String(...)`.\n *\n * @example\n * ```ts\n * show(ok(1));               // 'Ok(1)'\n * show(err({ kind: \"e\" })); // 'Err({\"kind\":\"e\"})'\n * ```\n */\nexport const show = <T, E>(result: Result<T, E>): string =>\n  isOk(result) ? `Ok(${printPayload(result.value)})` : `Err(${printPayload(result.error)})`;\n","import { mkErr } from \"./internal/ctor.js\";\nimport { isErr } from \"./result.js\";\nimport type { Result } from \"./types.js\";\n\n/** Internal control-flow signal — not part of public error types */\nclass ErrSignal<E> {\n  readonly _tag = \"ErrSignal\" as const;\n  constructor(readonly error: E) {}\n}\n\n/**\n * Unwraps a {@link Result} inside a {@link tryGen} block — the sync analogue of\n * Rust's `?` operator. On `Ok` it returns the value; on `Err` it short-circuits\n * the enclosing `tryGen`, which returns that `Err`. Only valid inside `tryGen`;\n * prefer {@link flatMap} / `pipe` for long pipelines.\n *\n * @returns the unwrapped `Ok` value\n *\n * @example\n * ```ts\n * const out = tryGen(() => {\n *   const a = yieldResult(parseA());   // unwrap or short-circuit\n *   const b = yieldResult(parseB());\n *   return ok(a + b);\n * });\n * ```\n */\nexport const yieldResult = <T, E>(result: Result<T, E>): T => {\n  if (isErr(result)) {\n    throw new ErrSignal(result.error);\n  }\n  return result.value;\n};\n\n/**\n * Terse alias of {@link yieldResult} (mirrors Rust's `?`), for compact\n * {@link tryGen} blocks.\n *\n * @example\n * ```ts\n * const out = tryGen(() => {\n *   const a = $(parseA());\n *   const b = $(parseB());\n *   return ok(a + b);\n * });\n * ```\n */\nexport const $ = yieldResult;\n\n/**\n * Run a block that uses {@link yieldResult}; returns the final `Result` or the first Err.\n *\n * @example\n * ```ts\n * const out = tryGen(() => {\n *   const a = $(parseA());\n *   const b = $(parseB());\n *   return ok(a + b);\n * });\n * ```\n */\nexport const tryGen = <T, E>(fn: () => Result<T, E>): Result<T, E> => {\n  try {\n    return fn();\n  } catch (error) {\n    if (error instanceof ErrSignal) {\n      return mkErr(error.error);\n    }\n    throw error;\n  }\n};\n"]}

package/dist/{types-BQ9vv0nD.d.cts → types.d.cts}

@@ -15,7 +15,7 @@
  * }
  * ```
  */
-type Result<T, E> = {
+export type Result<T, E> = {
     readonly _tag: "Ok";
     readonly value: T;
 } | {
@@ -26,13 +26,13 @@ type Result<T, E> = {
  * The success branch of a {@link Result} — `{ _tag: "Ok"; value: T }`.
  * The `E` parameter keeps the type assignable to `Result<T, E>`.
  */
-type Ok<T, E = never> = Extract<Result<T, E>, {
+export type Ok<T, E = never> = Extract<Result<T, E>, {
     _tag: "Ok";
 }>;
 /**
  * The failure branch of a {@link Result} — `{ _tag: "Err"; error: E }`.
  */
-type Err<T, E> = Extract<Result<T, E>, {
+export type Err<T, E> = Extract<Result<T, E>, {
     _tag: "Err";
 }>;
 /**
@@ -47,9 +47,7 @@ type Err<T, E> = Extract<Result<T, E>, {
  * defect.cause; // the original thrown value
  * ```
  */
-declare class UnexpectedError extends Error {
-    readonly cause?: unknown | undefined;
-    constructor(message: string, cause?: unknown | undefined);
+export declare class UnexpectedError extends Error {
+    readonly cause?: unknown;
+    constructor(message: string, cause?: unknown);
 }
-
-export { type Err as E, type Ok as O, type Result as R, UnexpectedError as U };