unthrown 3.1.0 → 4.1.0

package/dist/index.d.cts

@@ -34,7 +34,7 @@ type Bound<T, K extends string, U> = Prettify<Omit<T, K> & { readonly [P in K]:
 type NotThenable<R> = [R] extends [PromiseLike<unknown>] ? "unthrown: combinator callbacks are synchronous — lift async work with fromPromise and compose with flatMap" : unknown;
 /**
  * The fluent method surface every {@link Result} variant carries — the
- * combinators (`map`, `flatMap`, `mapErr`, `match`, `unwrap`, …), documented one
+ * combinators (`map`, `flatMap`, `mapErr`, `match`, `get`, …), documented one
  * per entry below. Factored out so the three variants ({@link OkView},
  * {@link ErrView}, {@link DefectView}) can each intersect it; {@link AsyncResult}
  * mirrors this surface with async signatures.
@@ -79,6 +79,15 @@ type ResultMethods<T, E> = {
    * Runs only on `Ok`. If `f` throws, the throw becomes a `Defect`. An async
    * callback is rejected at compile time ({@link NotThenable}).
    *
+   * @remarks
+   * `f`'s return value is **ignored** — a `Result` returned by the effect
+   * compiles but is discarded, `Err` and all. If the effect can fail, sequence
+   * it instead of tapping it: a `Result`-returning effect goes in
+   * {@link ResultMethods.flatTap | flatTap}; an `AsyncResult`-returning effect
+   * cannot be sequenced from the sync surface — lift the chain with
+   * {@link ResultMethods.toAsync | toAsync} and use the async
+   * {@link AsyncResultMethods.flatTap | flatTap} (which accepts both).
+   *
    * @param f - the side effect (its return value is ignored).
    */
   tap<R>(f: (value: T) => R & NotThenable<R>): Result$1<T, E>;
@@ -155,7 +164,8 @@ type ResultMethods<T, E> = {
    */
   mapErr<E2>(f: (error: E) => E2 & NotThenable<E2>): Result$1<T, E2>;
   /**
-   * Recover from an `Err` by producing another `Result`.
+   * Sequence from an `Err` by producing another `Result` — the error-channel
+   * mirror of {@link ResultMethods.flatMap | flatMap}.
    *
    * Runs `f` only on `Err`; `Ok` and `Defect` pass through. If `f` throws, the
    * throw becomes a `Defect`.
@@ -164,10 +174,22 @@ type ResultMethods<T, E> = {
    * @typeParam E2 - the error type `f` may produce instead.
    * @param f - produces a fallback `Result` from the current error.
    */
+  flatMapErr<U, E2>(f: (error: E) => Result$1<U, E2>): Result$1<T | U, E2>;
+  /**
+   * Sequence from an `Err` by producing another `Result`.
+   *
+   * @deprecated Renamed to {@link ResultMethods.flatMapErr | flatMapErr} — it is
+   * `flatMap` on the error channel, so it now follows the `…Err` convention. This
+   * alias will be removed in a future major.
+   *
+   * @typeParam U - an alternative success type `f` may produce.
+   * @typeParam E2 - the error type `f` may produce instead.
+   * @param f - produces a fallback `Result` from the current error.
+   */
   orElse<U, E2>(f: (error: E) => Result$1<U, E2>): Result$1<T | U, E2>;
   /**
    * Recover from an `Err` by producing a success value, emptying the error
-   * channel.
+   * channel. Pairs with {@link ResultMethods.recoverDefect | recoverDefect}.
    *
    * @remarks
    * The result type is `Result<T | U, never>`, but `never` describes only the
@@ -179,6 +201,17 @@ type ResultMethods<T, E> = {
    * @typeParam U - the recovered success type.
    * @param f - produces a success value from the current error.
    */
+  recoverErr<U>(f: (error: E) => U & NotThenable<U>): Result$1<T | U, never>;
+  /**
+   * Recover from an `Err` by producing a success value.
+   *
+   * @deprecated Renamed to {@link ResultMethods.recoverErr | recoverErr} — it now
+   * pairs with {@link ResultMethods.recoverDefect | recoverDefect} and follows the
+   * `…Err` convention. This alias will be removed in a future major.
+   *
+   * @typeParam U - the recovered success type.
+   * @param f - produces a success value from the current error.
+   */
   recover<U>(f: (error: E) => U & NotThenable<U>): Result$1<T | U, never>;
   /**
    * Run a side effect on the error and pass the `Result` through unchanged.
@@ -188,6 +221,14 @@ type ResultMethods<T, E> = {
    * never destroys it. An async callback is rejected at compile time
    * ({@link NotThenable}).
    *
+   * @remarks
+   * As with {@link ResultMethods.tap | tap}, `f`'s return value is ignored — a
+   * failable `Result`-returning effect belongs in
+   * {@link ResultMethods.flatTapErr | flatTapErr}; an `AsyncResult`-returning
+   * one needs the chain lifted with {@link ResultMethods.toAsync | toAsync}
+   * first (the async {@link AsyncResultMethods.flatTapErr | flatTapErr}
+   * accepts both).
+   *
    * @param f - the side effect (its return value is ignored).
    */
   tapErr<R>(f: (error: E) => R & NotThenable<R>): Result$1<T, E>;
@@ -254,20 +295,52 @@ type ResultMethods<T, E> = {
   /**
    * Extract the success value.
    *
+   * @remarks
+   * Compiles only when the error channel is empty (`E = never`) — eliminate
+   * modeled errors first (`match` / `recoverErr` / `flatMapErr`), or reach for the
+   * `getOr` / `getOrElse` / `getOrNull` / `getOrUndefined` family (which
+   * recover an `Err`). If you get a `'this' context` type error here, that is
+   * the gate: the receiver still has a non-`never` error channel.
+   *
+   * `E = never` empties only the **modeled** error channel — a `Defect` can
+   * still be present, and `get()` **rethrows its original cause** (it
+   * _panics_); `Result<T, never>` does not mean `get()` cannot throw.
+   *
    * @returns the `Ok` value.
-   * @throws On `Err`, an {@link UnwrapError} carrying the error. On a `Defect`,
-   * re-throws the **original cause** with its original stack, so an unhandled
-   * Defect surfaces at the global handler as the real failure.
    */
-  unwrap(): T;
+  get(this: Result$1<T, never>): T;
+  /**
+   * Extract the success value.
+   *
+   * @deprecated Renamed to {@link ResultMethods.get | get}, unifying the extractor
+   * family under `get…`. This alias will be removed in a future major.
+   *
+   * @returns the `Ok` value.
+   */
+  unwrap(this: Result$1<T, never>): T;
   /**
    * Extract the modeled error.
    *
+   * @remarks
+   * Compiles only when the success channel is empty (`T = never`) — eliminate
+   * the success case first. `T = never` is rarely the case in practice (a
+   * `Result` you hold usually still has a success type), so to inspect an
+   * error prefer an `isErr()` guard or, in tests, `@unthrown/vitest`'s
+   * `toBeErrWith`. A `Defect` still **rethrows its original cause** (a defect is
+   * a bug, not an absent value), so this does not mean `getErr()` can't throw.
+   *
    * @returns the `Err` value.
-   * @throws On `Ok`, an {@link UnwrapError} carrying the value. On a `Defect`,
-   * re-throws the original cause.
    */
-  unwrapErr(): E;
+  getErr(this: Result$1<never, E>): E;
+  /**
+   * Extract the modeled error.
+   *
+   * @deprecated Renamed to {@link ResultMethods.getErr | getErr}, unifying the
+   * extractor family under `get…`. This alias will be removed in a future major.
+   *
+   * @returns the `Err` value.
+   */
+  unwrapErr(this: Result$1<never, E>): E;
   /**
    * The success value, or `fallback` on `Err`.
    *
@@ -276,6 +349,17 @@ type ResultMethods<T, E> = {
    * @throws Re-throws on a `Defect` — a Defect is a bug, not an absent value, so
    * it is never silently replaced.
    */
+  getOr<U>(fallback: U): T | U;
+  /**
+   * The success value, or `fallback` on `Err`.
+   *
+   * @deprecated Renamed to {@link ResultMethods.getOr | getOr}, unifying the
+   * extractor family under `get…`. This alias will be removed in a future major.
+   *
+   * @typeParam U - the fallback type (may differ from `T`; the return widens to `T | U`).
+   * @param fallback - returned when the result is an `Err`.
+   * @throws Re-throws on a `Defect`.
+   */
   unwrapOr<U>(fallback: U): T | U;
   /**
    * The success value, or `f(error)` on `Err`.
@@ -284,6 +368,17 @@ type ResultMethods<T, E> = {
    * @param f - lazily computes the fallback from the error (may return a different type; the return widens to `T | U`).
    * @throws Re-throws on a `Defect`.
    */
+  getOrElse<U>(f: (error: E) => U): T | U;
+  /**
+   * The success value, or `f(error)` on `Err`.
+   *
+   * @deprecated Renamed to {@link ResultMethods.getOrElse | getOrElse}, unifying
+   * the extractor family under `get…`. This alias will be removed in a future major.
+   *
+   * @typeParam U - the fallback type (may differ from `T`; the return widens to `T | U`).
+   * @param f - lazily computes the fallback from the error.
+   * @throws Re-throws on a `Defect`.
+   */
   unwrapOrElse<U>(f: (error: E) => U): T | U;
   /**
    * The success value, or `null` on `Err`.
@@ -296,7 +391,25 @@ type ResultMethods<T, E> = {
    *
    * @throws Re-throws on a `Defect`.
    */
-  getOrUndefined(): T | undefined; /** Whether this result is `Ok` — narrows `this` to its {@link OkView} on `true`. */
+  getOrUndefined(): T | undefined;
+  /**
+   * The success value, or **throw** the modeled error on `Err`.
+   *
+   * @remarks
+   * A deliberate escape hatch off the errors-as-values model. Unlike
+   * {@link ResultMethods.get | get} (type-gated to an empty error
+   * channel), this compiles on any `Result<T, E>` and **throws the `Err` value
+   * as-is** at the call site. Its purpose is to move a literal `throw` behind a
+   * method, so a `no-throw` lint rule can ban raw throws while this one
+   * sanctioned extraction remains — _not_ to replace principled handling. When
+   * you can keep the error a value, prefer {@link ResultMethods.match | match} /
+   * {@link ResultMethods.recoverErr | recoverErr} / {@link ResultMethods.flatMapErr | flatMapErr}.
+   *
+   * @returns the `Ok` value.
+   * @throws the modeled `error` on `Err`; re-throws the original `cause` on a
+   * `Defect` (a panic, like the rest of the `getOr…` family).
+   */
+  getOrThrow(): T; /** Whether this result is `Ok` — narrows `this` to its {@link OkView} on `true`. */
   isOk(): this is OkView<T, E>; /** Whether this result is `Err` — narrows `this` to its {@link ErrView} on `true`. */
   isErr(): this is ErrView<E, T>; /** Whether this result is a `Defect` — narrows `this` to its {@link DefectView} on `true`. */
   isDefect(): this is DefectView<T, E>; /** Lift this synchronous `Result` into an {@link AsyncResult}. */
@@ -419,7 +532,7 @@ type Awaitable<T> = {
 };
 /**
  * The async method surface every {@link AsyncResult} carries — the combinators
- * (`map`, `flatMap`, `mapErr`, `match`, `unwrap`, …) with their asynchronous
+ * (`map`, `flatMap`, `mapErr`, `match`, `get`, …) with their asynchronous
  * signatures, documented one per entry below. The async mirror of
  * {@link ResultMethods}: each entry links its synchronous counterpart and states
  * only the async delta.
@@ -453,7 +566,12 @@ type AsyncResultMethods<T, E> = {
   /**
    * Asynchronous {@link ResultMethods.tap | tap}. `f` is synchronous; a throw
    * becomes a `Defect`. An async callback is rejected at compile time
-   * ({@link NotThenable}).
+   * ({@link NotThenable}) — and so is a returned `AsyncResult` (it is
+   * awaitable). Beware the near-miss: _calling_ an `AsyncResult`-returning
+   * effect inside the callback without returning it compiles and leaves the
+   * effect floating — fire-and-forget, never awaited, its `Err`/`Defect`
+   * unobserved. If the effect returns a `Result`/`AsyncResult`, use
+   * {@link AsyncResultMethods.flatTap | flatTap}.
    */
   tap<R>(f: (value: T) => R & NotThenable<R>): AsyncResult$1<T, E>;
   /**
@@ -483,21 +601,34 @@ type AsyncResultMethods<T, E> = {
    */
   mapErr<E2>(f: (error: E) => E2 & NotThenable<E2>): AsyncResult$1<T, E2>;
   /**
-   * Asynchronous {@link ResultMethods.orElse | orElse}. `f` may return a `Result`
-   * or an `AsyncResult`.
+   * Asynchronous {@link ResultMethods.flatMapErr | flatMapErr}. `f` may return a
+   * `Result` or an `AsyncResult`.
+   */
+  flatMapErr<U, E2>(f: (error: E) => Result$1<U, E2> | AsyncResult$1<U, E2>): AsyncResult$1<T | U, E2>;
+  /**
+   * @deprecated Renamed to {@link AsyncResultMethods.flatMapErr | flatMapErr}.
+   * This alias will be removed in a future major.
    */
   orElse<U, E2>(f: (error: E) => Result$1<U, E2> | AsyncResult$1<U, E2>): AsyncResult$1<T | U, E2>;
   /**
-   * Asynchronous {@link ResultMethods.recover | recover}. `f` is synchronous; a
-   * throw becomes a `Defect`. An async callback is rejected at compile time
-   * ({@link NotThenable}).
+   * Asynchronous {@link ResultMethods.recoverErr | recoverErr}. `f` is
+   * synchronous; a throw becomes a `Defect`. An async callback is rejected at
+   * compile time ({@link NotThenable}).
+   */
+  recoverErr<U>(f: (error: E) => U & NotThenable<U>): AsyncResult$1<T | U, never>;
+  /**
+   * @deprecated Renamed to {@link AsyncResultMethods.recoverErr | recoverErr}.
+   * This alias will be removed in a future major.
    */
   recover<U>(f: (error: E) => U & NotThenable<U>): AsyncResult$1<T | U, never>;
   /**
    * Asynchronous {@link ResultMethods.tapErr | tapErr}. `f` is synchronous; if it
    * throws, the result is a `Defect` whose cause is an `AggregateError` of
    * `[thrown, original failure]` — observing a failure never destroys it. An
-   * async callback is rejected at compile time ({@link NotThenable}).
+   * async callback is rejected at compile time ({@link NotThenable}). The
+   * {@link AsyncResultMethods.tap | tap} fire-and-forget caveat applies here
+   * too — a failable effect belongs in
+   * {@link AsyncResultMethods.flatTapErr | flatTapErr}.
    */
   tapErr<R>(f: (error: E) => R & NotThenable<R>): AsyncResult$1<T, E>;
   /**
@@ -531,15 +662,47 @@ type AsyncResultMethods<T, E> = {
     defect: (cause: unknown) => R;
   }): Promise<R>;
   /**
-   * Asynchronous {@link ResultMethods.unwrap | unwrap}. The returned promise
-   * rejects on `Err`/`Defect`.
+   * Asynchronous {@link ResultMethods.get | get}. Compiles only when the
+   * error channel is empty (`this: AsyncResult<T, never>`); the returned promise
+   * rejects on a `Defect` (rethrowing its cause).
+   */
+  get(this: AsyncResult$1<T, never>): Promise<T>;
+  /**
+   * @deprecated Renamed to {@link AsyncResultMethods.get | get}. This alias will
+   * be removed in a future major.
+   */
+  unwrap(this: AsyncResult$1<T, never>): Promise<T>;
+  /**
+   * Asynchronous {@link ResultMethods.getErr | getErr}. Compiles only when
+   * the success channel is empty (`this: AsyncResult<never, E>`); the returned
+   * promise rejects on a `Defect` (rethrowing its cause).
+   */
+  getErr(this: AsyncResult$1<never, E>): Promise<E>;
+  /**
+   * @deprecated Renamed to {@link AsyncResultMethods.getErr | getErr}. This alias
+   * will be removed in a future major.
+   */
+  unwrapErr(this: AsyncResult$1<never, E>): Promise<E>; /** Asynchronous {@link ResultMethods.getOr | getOr}. */
+  getOr<U>(fallback: U): Promise<T | U>;
+  /**
+   * @deprecated Renamed to {@link AsyncResultMethods.getOr | getOr}. This alias
+   * will be removed in a future major.
+   */
+  unwrapOr<U>(fallback: U): Promise<T | U>; /** Asynchronous {@link ResultMethods.getOrElse | getOrElse}. */
+  getOrElse<U>(f: (error: E) => U): Promise<T | U>;
+  /**
+   * @deprecated Renamed to {@link AsyncResultMethods.getOrElse | getOrElse}. This
+   * alias will be removed in a future major.
    */
-  unwrap(): Promise<T>; /** Asynchronous {@link ResultMethods.unwrapErr | unwrapErr}. */
-  unwrapErr(): Promise<E>; /** Asynchronous {@link ResultMethods.unwrapOr | unwrapOr}. */
-  unwrapOr<U>(fallback: U): Promise<T | U>; /** Asynchronous {@link ResultMethods.unwrapOrElse | unwrapOrElse}. */
   unwrapOrElse<U>(f: (error: E) => U): Promise<T | U>; /** Asynchronous {@link ResultMethods.getOrNull | getOrNull}. */
   getOrNull(): Promise<T | null>; /** Asynchronous {@link ResultMethods.getOrUndefined | getOrUndefined}. */
   getOrUndefined(): Promise<T | undefined>;
+  /**
+   * Asynchronous {@link ResultMethods.getOrThrow | getOrThrow} — the returned
+   * promise **rejects** with the modeled error on `Err` (or the original cause
+   * on a `Defect`), rather than throwing synchronously.
+   */
+  getOrThrow(): Promise<T>;
 };
 /**
  * The asynchronous counterpart of {@link Result}: an awaitable wrapper carrying
@@ -552,8 +715,8 @@ type AsyncResultMethods<T, E> = {
  * rejection would silently become a `Defect`, skipping the triage that
  * {@link fromPromise} forces. To do further async work, re-enter through a
  * qualified boundary and compose it: `ar.flatMap((v) => fromPromise(work(v),
- * qualify))`. The eliminators (`unwrap`, …) return promises; the binds
- * (`flatMap`, `flatTap`, `orElse`, `recoverDefect`) additionally accept an
+ * qualify))`. The eliminators (`get`, …) return promises; the binds
+ * (`flatMap`, `flatTap`, `flatMapErr`, `recoverDefect`) additionally accept an
  * `AsyncResult`. Its combinators are documented one per entry on
  * {@link AsyncResultMethods}.
  *
@@ -640,7 +803,7 @@ type AsyncErrOf<R> = R extends AsyncResult$1<unknown, infer E> ? E : never;
  * import { Ok } from "unthrown";
  *
  * Ok(2).map((n) => n + 1); // => Ok(3)
- * Ok(42).unwrap(); // => 42
+ * Ok(42).get(); // => 42
  * ```
  *
  * @category Constructors
@@ -657,12 +820,60 @@ declare function Ok<T>(value: T): Result$1<T, never>;
  * import { Err } from "unthrown";
  *
  * Err("not_found").map((n) => n + 1); // => Err("not_found") (map skipped)
- * Err("not_found").unwrapErr(); // => "not_found"
+ * Err("not_found").getErr(); // => "not_found"
  * ```
  *
  * @category Constructors
  */
 declare function Err<E>(error: E): Result$1<never, E>;
+/**
+ * Construct a successful {@link AsyncResult} from a pure value — the pre-lifted
+ * form of {@link Ok}, sparing you `Ok(value).toAsync()`.
+ *
+ * @remarks
+ * Reach for this on the synchronous/early branch of an `AsyncResult`-returning
+ * function, so both branches share one return type without a trailing
+ * `.toAsync()`. Named with the `Async` suffix the async free functions carry
+ * (`allAsync`, `allFromDictAsync`); the {@link AsyncResult} companion aliases it
+ * as `AsyncResult.Ok` (the namespace already says "async", so the suffix drops).
+ *
+ * @typeParam T - the success value type.
+ * @param value - the success value to wrap.
+ *
+ * @example
+ * ```ts
+ * import { OkAsync, type AsyncResult } from "unthrown";
+ *
+ * function loadItems(ids: string[]): AsyncResult<Item[], never> {
+ *   if (ids.length === 0) return OkAsync([]); // no more Ok([]).toAsync()
+ *   return itemRepository.load(ids);
+ * }
+ * ```
+ *
+ * @category Constructors
+ */
+declare function OkAsync<T>(value: T): AsyncResult$1<T, never>;
+/**
+ * Construct a failed {@link AsyncResult} carrying a **modeled** error — the
+ * pre-lifted form of {@link Err}, sparing you `Err(error).toAsync()`.
+ *
+ * @remarks
+ * The error-channel mirror of {@link OkAsync}; see it for the naming and the
+ * `AsyncResult.Err` companion alias.
+ *
+ * @typeParam E - the modeled error type.
+ * @param error - the domain error to wrap.
+ *
+ * @example
+ * ```ts
+ * import { ErrAsync } from "unthrown";
+ *
+ * ErrAsync("not_found"); // AsyncResult<never, string>
+ * ```
+ *
+ * @category Constructors
+ */
+declare function ErrAsync<E>(error: E): AsyncResult$1<never, E>;
 /**
  * Type guard: narrow a {@link Result} to its `Ok` variant, exposing `.value`.
  *
@@ -730,8 +941,8 @@ declare function isDefect<T, E>(r: Result$1<T, E>): r is DefectView<T, E>;
 //#endregion
 //#region src/core.d.ts
 /**
- * Thrown by a {@link Result}'s `unwrap` / `unwrapErr` when the assertion is
- * wrong on a *modeled* result — `unwrap()` on an `Err`, or `unwrapErr()` on an
+ * Thrown by a {@link Result}'s `get` / `getErr` when the assertion is
+ * wrong on a *modeled* result — `get()` on an `Err`, or `getErr()` on an
  * `Ok`.
  *
  * @remarks
@@ -743,14 +954,19 @@ declare function isDefect<T, E>(r: Result$1<T, E>): r is DefectView<T, E>;
  * A `Defect` is never wrapped in an `UnwrapError`: its original cause is
  * re-thrown (with its original stack) instead.
  *
+ * `get()` and `getErr()` are type-gated (`this: Result<T, never>` /
+ * `Result<never, E>`), so the wrong-variant branch that throws this is
+ * unreachable through well-typed code — it remains only as a defensive guard
+ * against unsound runtime misuse (e.g. an `as` cast past the gate).
+ *
  * @typeParam E - the type of the {@link UnwrapError.error} it carries.
  *
  * @category Errors
  */
 declare class UnwrapError<E = unknown> extends Error {
   /**
-   * The offending value: the `Err` error for `unwrap()`, or the `Ok` value for
-   * `unwrapErr()`.
+   * The offending value: the `Err` error for `get()`, or the `Ok` value for
+   * `getErr()`.
    */
   readonly error: E;
   constructor(error: E);
@@ -868,9 +1084,9 @@ type Defect = {
  * import { fromNullable } from "unthrown";
  *
  * const map = new Map([["a", 1]]);
- * fromNullable(map.get("a"), () => "absent").unwrap(); // => 1
+ * fromNullable(map.get("a"), () => "absent").getOr(0); // => 1
  * fromNullable(map.get("z"), () => "absent"); // => Err("absent")
- * fromNullable(0, () => "absent").unwrap(); // => 0 (falsy but present)
+ * fromNullable(0, () => "absent").getOr(-1); // => 0 (falsy but present)
  * ```
  */
 declare function fromNullable<T, E>(value: T | null | undefined, onAbsent: () => E): Result$1<NonNullable<T>, E>;
@@ -888,7 +1104,7 @@ declare function fromNullable<T, E>(value: T | null | undefined, onAbsent: () =>
  * `qualify`'s return is **subtracted** from `E`, never inferred into it. So a
  * `qualify` that returns *only* `defect(cause)` yields `E = never` (a Defect is
  * out-of-band and must not pollute the error channel); reach for
- * {@link fromSafePromise} when every failure is a Defect.
+ * {@link fromSafeThrowable} when every throw is a Defect.
  *
  * @typeParam A - the wrapped function's argument tuple.
  * @typeParam T - the wrapped function's return type.
@@ -912,11 +1128,41 @@ declare function fromNullable<T, E>(value: T | null | undefined, onAbsent: () =>
  *     cause instanceof SyntaxError ? ("invalid_json" as const) : defect(cause),
  * );
  *
- * parse('{"ok":true}').unwrap(); // => { ok: true }
+ * parse('{"ok":true}').getOr(null); // => { ok: true }
  * parse("nope"); // => Err("invalid_json")
  * ```
  */
 declare function fromThrowable<A extends unknown[], T, R>(fn: (...args: A) => T, qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R): (...args: A) => Result$1<T, Exclude<R, Defect>>;
+/**
+ * Wrap a throwing synchronous function asserted **not** to fail in any modeled
+ * way: any throw becomes a `Defect`.
+ *
+ * @remarks
+ * The synchronous counterpart of {@link fromSafePromise}. Use it only when a
+ * throw genuinely indicates a bug rather than an anticipated outcome — the
+ * error channel is `never`, so there is nothing to triage; there is no
+ * `qualify`. When some throws *are* anticipated, reach for
+ * {@link fromThrowable} and triage them.
+ *
+ * @typeParam A - the wrapped function's argument tuple.
+ * @typeParam T - the wrapped function's return type.
+ * @param fn - the throwing function to wrap.
+ * @returns a function with the same arguments returning `Result<T, never>`.
+ *
+ * @category Interop
+ *
+ * @example
+ * ```ts
+ * import { fromSafeThrowable } from "unthrown";
+ *
+ * // A decode failure here is a bug (the row came from our own schema), so
+ * // every throw is a defect — no throwaway `(cause, defect) => defect(cause)`.
+ * const decode = fromSafeThrowable((row: Row) => userSchema.parse(row));
+ *
+ * decode(row); // => Result<User, never> — a throw becomes a Defect
+ * ```
+ */
+declare function fromSafeThrowable<A extends unknown[], T>(fn: (...args: A) => T): (...args: A) => Result$1<T, never>;
 /**
  * Wrap a `Promise` (or a thunk producing one) as an {@link AsyncResult}, forcing
  * every rejection to be triaged.
@@ -950,8 +1196,8 @@ declare function fromThrowable<A extends unknown[], T, R>(fn: (...args: A) => T,
  *   cause instanceof NotFoundError ? ("not_found" as const) : defect(cause),
  * );
  *
- * user.unwrap(); // => the fetched user (on success)
- * // when fetchUser rejects with NotFoundError: => Err("not_found")
+ * if (user.isOk()) user.value; // => the fetched user
+ * // when fetchUser rejects with NotFoundError: user is Err("not_found")
  * ```
  */
 declare function fromPromise<T, R>(promise: Promise<T> | (() => Promise<T>), qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R): AsyncResult$1<T, Exclude<R, Defect>>;
@@ -962,7 +1208,8 @@ declare function fromPromise<T, R>(promise: Promise<T> | (() => Promise<T>), qua
  * @remarks
  * Use this only when a rejection genuinely indicates a bug rather than an
  * anticipated outcome — the error channel is `never`, so there is nothing to
- * triage. (`await`-ing still yields a `Result`; it never throws.)
+ * triage. (`await`-ing still yields a `Result`; it never throws.) The
+ * synchronous counterpart is {@link fromSafeThrowable}.
  *
  * @typeParam T - the resolved value type.
  * @param promise - the promise, or a thunk returning one.
@@ -973,7 +1220,7 @@ declare function fromPromise<T, R>(promise: Promise<T> | (() => Promise<T>), qua
  * ```ts
  * import { fromSafePromise } from "unthrown";
  *
- * (await fromSafePromise(Promise.resolve(3))).unwrap(); // => 3
+ * (await fromSafePromise(Promise.resolve(3))).get(); // => 3
  * // a rejection becomes a Defect (never a modeled Err):
  * await fromSafePromise(Promise.reject(new Error("boom"))); // => Defect(Error("boom"))
  * ```
@@ -1019,7 +1266,7 @@ type AsyncResultRecord = Record<string, AsyncResult$1<unknown, unknown>>;
  * ```ts
  * import { all, Ok, Err } from "unthrown";
  *
- * all([Ok(1), Ok("a"), Ok(true)]).unwrap(); // => [1, "a", true] (typed [number, string, boolean])
+ * all([Ok(1), Ok("a"), Ok(true)]).get(); // => [1, "a", true] (typed [number, string, boolean])
  * all([Ok(1), Err("e"), Ok(3)]); // => Err("e") (short-circuits on the first Err)
  * ```
  */
@@ -1040,7 +1287,7 @@ declare function all<Rs extends readonly Result$1<unknown, unknown>[]>(results:
  * ```ts
  * import { allFromDict, Ok, Err } from "unthrown";
  *
- * allFromDict({ id: Ok(1), name: Ok("ada") }).unwrap(); // => { id: 1, name: "ada" }
+ * allFromDict({ id: Ok(1), name: Ok("ada") }).get(); // => { id: 1, name: "ada" }
  * allFromDict({ id: Ok(1), name: Err("missing") }); // => Err("missing")
  * ```
  */
@@ -1062,7 +1309,7 @@ declare function allFromDict<R extends ResultRecord>(results: R): Result$1<{ [K
  * import { allAsync, fromSafePromise } from "unthrown";
  *
  * const both = allAsync([fromSafePromise(Promise.resolve(1)), fromSafePromise(Promise.resolve(2))]);
- * (await both).unwrap(); // => [1, 2]
+ * (await both).get(); // => [1, 2]
  * ```
  */
 declare function allAsync<Rs extends readonly AsyncResult$1<unknown, unknown>[]>(results: readonly [...Rs]): AsyncResult$1<AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]> }>, AsyncErrOf<Rs[number]>>;
@@ -1084,7 +1331,7 @@ declare function allAsync<Rs extends readonly AsyncResult$1<unknown, unknown>[]>
  *   a: fromSafePromise(Promise.resolve(1)),
  *   b: fromSafePromise(Promise.resolve("x")),
  * });
- * (await both).unwrap(); // => { a: 1, b: "x" }
+ * (await both).get(); // => { a: 1, b: "x" }
  * ```
  */
 declare function allFromDictAsync<R extends AsyncResultRecord>(results: R): AsyncResult$1<{ [K in keyof R]: AsyncOkOf<R[K]> }, AsyncErrOf<R[keyof R]>>;
@@ -1094,8 +1341,9 @@ declare function allFromDictAsync<R extends AsyncResultRecord>(results: R): Asyn
  * Companion object grouping the **`Result`-producing** entry points under a
  * single, discoverable namespace: {@link Result.Ok}, {@link Result.Err},
  * {@link Result.Do}, {@link Result.fromNullable}, {@link Result.fromThrowable},
- * {@link Result.all}, {@link Result.allFromDict}, {@link Result.isOk},
- * {@link Result.isErr}, {@link Result.isDefect}, {@link Result.isResult}.
+ * {@link Result.fromSafeThrowable}, {@link Result.all},
+ * {@link Result.allFromDict}, {@link Result.isOk}, {@link Result.isErr},
+ * {@link Result.isDefect}, {@link Result.isResult}.
  *
  * @remarks
  * Purely additive sugar — each member **is** the corresponding free function.
@@ -1112,7 +1360,7 @@ declare function allFromDictAsync<R extends AsyncResultRecord>(results: R): Asyn
  * @example
  * ```ts
  * import { Result } from "unthrown";
- * Result.Ok(1).flatMap((n) => Result.Ok(n + 1)).unwrap(); // => 2
+ * Result.Ok(1).flatMap((n) => Result.Ok(n + 1)).get(); // => 2
  * ```
  */
 declare const Result: {
@@ -1121,6 +1369,7 @@ declare const Result: {
   readonly Do: typeof Do;
   readonly fromNullable: typeof fromNullable;
   readonly fromThrowable: typeof fromThrowable;
+  readonly fromSafeThrowable: typeof fromSafeThrowable;
   readonly all: typeof all;
   readonly allFromDict: typeof allFromDict;
   readonly isOk: typeof isOk;
@@ -1135,7 +1384,7 @@ declare const Result: {
  *
  * @remarks
  * A `Result` is a discriminated union, so TypeDoc can't list its methods on this
- * alias. Its fluent combinators (`map`, `flatMap`, `match`, `unwrap`, …) are
+ * alias. Its fluent combinators (`map`, `flatMap`, `match`, `get`, …) are
  * documented one per entry on {@link ResultMethods} — the shared method surface
  * every variant carries. For "which one do I reach for?", see the
  * [Choosing a combinator](/guide/choosing-a-combinator) guide.
@@ -1145,18 +1394,20 @@ declare const Result: {
 type Result<T, E> = Result$1<T, E>;
 /**
  * Companion object grouping the **`AsyncResult`-producing** entry points under
- * the matching namespace: {@link AsyncResult.fromPromise},
- * {@link AsyncResult.fromSafePromise}, {@link AsyncResult.all},
- * {@link AsyncResult.allFromDict}.
+ * the matching namespace: {@link AsyncResult.Ok}, {@link AsyncResult.Err},
+ * {@link AsyncResult.fromPromise}, {@link AsyncResult.fromSafePromise},
+ * {@link AsyncResult.all}, {@link AsyncResult.allFromDict}.
  *
  * @remarks
  * The async sibling of {@link Result}. Statics are grouped by what they
- * **return**, so `fromPromise`/`fromSafePromise` and the async aggregates sit
- * here rather than on {@link Result}; the namespace already conveys "async", so
- * the aggregates drop the `Async` suffix (`AsyncResult.all` is the free function
- * `allAsync`; `AsyncResult.allFromDict` is `allFromDictAsync`). Like
- * {@link Result}, the free functions remain the primary, tree-shakeable API; the
- * value `AsyncResult` and the type {@link AsyncResult} share one name.
+ * **return**, so the pre-lifted constructors, `fromPromise`/`fromSafePromise`,
+ * and the async aggregates sit here rather than on {@link Result}; the namespace
+ * already conveys "async", so the members drop the `Async` suffix their free
+ * functions carry (`AsyncResult.Ok` is `OkAsync`; `AsyncResult.Err` is
+ * `ErrAsync`; `AsyncResult.all` is `allAsync`; `AsyncResult.allFromDict` is
+ * `allFromDictAsync`). Like {@link Result}, the free functions remain the
+ * primary, tree-shakeable API; the value `AsyncResult` and the type
+ * {@link AsyncResult} share one name.
  *
  * @category Facade
  *
@@ -1164,10 +1415,12 @@ type Result<T, E> = Result$1<T, E>;
  * ```ts
  * import { AsyncResult } from "unthrown";
  * const user = await AsyncResult.fromPromise(fetchUser(id), (c, defect) => defect(c));
- * user.unwrap(); // => the fetched user (on success)
+ * user.get(); // => the fetched user (on success)
  * ```
  */
 declare const AsyncResult: {
+  readonly Ok: typeof OkAsync;
+  readonly Err: typeof ErrAsync;
   readonly fromPromise: typeof fromPromise;
   readonly fromSafePromise: typeof fromSafePromise;
   readonly all: typeof allAsync;
@@ -1180,7 +1433,7 @@ declare const AsyncResult: {
  *
  * @remarks
  * `AsyncResult` carries the async fluent surface; its combinators (`map`,
- * `flatMap`, `match`, `unwrap`, …) are documented one per entry — with their
+ * `flatMap`, `match`, `get`, …) are documented one per entry — with their
  * async signatures — on {@link AsyncResultMethods}. For "which one do I reach
  * for?", see the [Choosing a combinator](/guide/choosing-a-combinator) guide.
  *
@@ -1199,7 +1452,7 @@ type Props = Record<string, unknown>;
  *
  * @category Types
  */
-type TaggedErrorInstance<Tag extends string, A extends Props> = Error & Readonly<Omit<A, "name">> & {
+type TaggedErrorInstance<Tag extends string, A extends Props> = Error & Readonly<Omit<A, "name" | "message">> & {
   readonly _tag: Tag;
 };
 /**
@@ -1208,10 +1461,13 @@ type TaggedErrorInstance<Tag extends string, A extends Props> = Error & Readonly
  *
  * @remarks
  * When the payload is empty, the constructor takes **no** arguments (the
- * `keyof A extends never ? void : A` trick); otherwise it takes the payload. A
- * `name` key is **rejected** (`name?: never`) because it is reserved for the
- * display label — mirroring how {@link TaggedErrorInstance} excludes it — so the
- * reservation is enforced at the call site, not just ignored at runtime.
+ * `keyof A extends never ? void : A` trick); otherwise it takes the payload. The
+ * `name` and `message` keys are both **rejected** (`name?: never` /
+ * `message?: never`) because both are reserved: `name` is the display label, and
+ * `message` is the human string owned by `Error`. Set the message the standard
+ * way — `override message = "…"` (or a constructor override) on the subclass —
+ * never as a free-form per-call payload field. The reservations are enforced at
+ * the call site, mirroring how {@link TaggedErrorInstance} excludes both.
  *
  * @typeParam Tag - the string literal discriminant.
  *
@@ -1220,6 +1476,7 @@ type TaggedErrorInstance<Tag extends string, A extends Props> = Error & Readonly
 type TaggedErrorConstructor<Tag extends string> = {
   new <A extends Props = {}>(args: keyof A extends never ? void : A & {
     readonly name?: never;
+    readonly message?: never;
   }): TaggedErrorInstance<Tag, A>;
 };
 /**
@@ -1228,8 +1485,13 @@ type TaggedErrorConstructor<Tag extends string> = {
  *
  * @remarks
  * Extend the returned class to declare a concrete error. Supply the payload with
- * an instantiation expression; omit it for a payload-less error. A `message`
- * field in the payload is forwarded to `Error`. The `_tag` always reflects
+ * an instantiation expression; omit it for a payload-less error. The `message`
+ * is **not** a payload field — it is the human string owned by `Error`, not
+ * structured data, so it is reserved. Define it once per subclass the standard
+ * way, `override message = "…"` (it may interpolate the payload via `this`,
+ * which the base populates before the subclass field initialiser runs); a
+ * payload `message` is rejected at compile time, so contextual detail lives in
+ * typed fields, never baked into per-call prose. The `_tag` always reflects
  * `tag` and cannot be overridden by the payload. `name` is likewise reserved —
  * it is the display label (set it with `options.name`); a payload `name` is
  * rejected at compile time (and excluded from the instance type), so it can't
@@ -1244,11 +1506,14 @@ type TaggedErrorConstructor<Tag extends string> = {
  * ```ts
  * class RetryableError extends TaggedError("@my-lib/RetryableError", {
  *   name: "RetryableError",
- * })<{ message: string }> {}
+ * }) {
+ *   override message = "operation failed; safe to retry";
+ * }
  *
- * const e = new RetryableError({ message: "boom" });
- * e._tag; // "@my-lib/RetryableError" — namespaced discriminant
- * e.name; // "RetryableError"          — clean display name
+ * const e = new RetryableError();
+ * e._tag;    // "@my-lib/RetryableError" — namespaced discriminant
+ * e.name;    // "RetryableError"          — clean display name
+ * e.message; // "operation failed; safe to retry" — the standard Error.message
  * ```
  *
  * @typeParam Tag - the string literal discriminant.
@@ -1344,5 +1609,5 @@ declare function matchTags<T, E extends {
   _tag: string;
 }, R>(result: AsyncResult$1<T, E>, handlers: TagHandlers<T, E, R> & ([Extract<E["_tag"], "Ok" | "Defect">] extends [never] ? unknown : ReservedTagError)): Promise<R>;
 //#endregion
-export { type AsyncErrOf, type AsyncOkOf, AsyncResult, type AsyncResultMethods, type Awaitable, type DefectView, Do, Err, type ErrOf, type ErrView, type NotThenable, Ok, type OkOf, type OkView, Result, type ResultMethods, type TagHandlers, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, UnwrapError, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromThrowable, isDefect, isErr, isOk, isResult, matchTags };
+export { type AsyncErrOf, type AsyncOkOf, AsyncResult, type AsyncResultMethods, type Awaitable, type DefectView, Do, Err, ErrAsync, type ErrOf, type ErrView, type NotThenable, Ok, OkAsync, type OkOf, type OkView, Result, type ResultMethods, type TagHandlers, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, UnwrapError, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, matchTags };
 //# sourceMappingURL=index.d.cts.map