unthrown 5.1.0 → 5.2.0

package/dist/index.cjs

@@ -538,7 +538,11 @@ function defectRes(cause) {
 *   // `E` is `unknown` here — an untyped boundary has no cases to enumerate,
 *   // so the `P._` escape hatch is the only arm that can terminate the match:
 *   // oxlint-disable-next-line unthrown/no-catch-all-pattern -- untyped boundary: `E` is `unknown`
-*   x.match({ ok: () => 1, errCases: (m) => m.with(P._, () => 0), defect: () => -1 });
+*   x.match({
+*     ok: () => 1,
+*     errCases: (m) => m.with(P._, () => 0),
+*     defect: () => -1,
+*   });
 * ```
 *
 * @category Guards
@@ -1452,7 +1456,10 @@ function allFromDict(results) {
 * ```ts
 * import { allAsync, fromSafePromise } from "unthrown";
 *
-* const both = allAsync([fromSafePromise(Promise.resolve(1)), fromSafePromise(Promise.resolve(2))]);
+* const both = allAsync([
+*   fromSafePromise(Promise.resolve(1)),
+*   fromSafePromise(Promise.resolve(2)),
+* ]);
 * (await both).get(); // => [1, 2]
 * ```
 */
@@ -1556,7 +1563,10 @@ const Result = {
 * @example
 * ```ts
 * import { AsyncResult } from "unthrown";
-* const user = await AsyncResult.fromPromise(fetchUser(id), (c, defect) => defect(c));
+* const user = await AsyncResult.fromPromise(
+*   fetchUser(id),
+*   (c, defect) => defect(c),
+* );
 * user.get(); // => the fetched user (on success)
 * ```
 */

package/dist/index.d.cts

@@ -766,12 +766,20 @@ type ResultMethods<out T, out E> = {
    *
    * @remarks
    * A deliberate escape hatch off the errors-as-values model — it **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.recoverErrCases | recoverErrCases} /
-   * {@link ResultMethods.flatMapErrCases | flatMapErrCases}.
+   * `Err` value as-is** at the call site, so a caller of the enclosing function
+   * sees a throw rather than a channel. Its home is **tests and scripts**,
+   * where "this `Result` had better be `Ok`" is the assertion and a throw is
+   * the correct failure mode.
+   *
+   * In production code, fold the error channel instead:
+   * {@link ResultMethods.recoverErrCases | recoverErrCases} empties `E`, so
+   * {@link ResultMethods.get | get} compiles and a case routed to the injected
+   * `defect(...)` panics with its original cause — with every case still named.
+   * {@link ResultMethods.match | match} and
+   * {@link ResultMethods.flatMapErrCases | flatMapErrCases} are the other two
+   * ways to keep the error a value. `@unthrown/oxlint`'s opt-in
+   * `no-get-or-throw` rule enforces this, exempting test files through an
+   * oxlint `overrides` entry.
    *
    * Type-gated as the **complement** of {@link ResultMethods.get | get}: it
    * compiles only when the error channel is **non-empty** (`E` is not `never`) —
@@ -1450,7 +1458,11 @@ declare class GetError<E = unknown> extends Error {
  *   // `E` is `unknown` here — an untyped boundary has no cases to enumerate,
  *   // so the `P._` escape hatch is the only arm that can terminate the match:
  *   // oxlint-disable-next-line unthrown/no-catch-all-pattern -- untyped boundary: `E` is `unknown`
- *   x.match({ ok: () => 1, errCases: (m) => m.with(P._, () => 0), defect: () => -1 });
+ *   x.match({
+ *     ok: () => 1,
+ *     errCases: (m) => m.with(P._, () => 0),
+ *     defect: () => -1,
+ *   });
  * ```
  *
  * @category Guards
@@ -1790,7 +1802,10 @@ declare function allFromDict<R extends ResultRecord>(results: R): Result$1<{ [K
  * ```ts
  * import { allAsync, fromSafePromise } from "unthrown";
  *
- * const both = allAsync([fromSafePromise(Promise.resolve(1)), fromSafePromise(Promise.resolve(2))]);
+ * const both = allAsync([
+ *   fromSafePromise(Promise.resolve(1)),
+ *   fromSafePromise(Promise.resolve(2)),
+ * ]);
  * (await both).get(); // => [1, 2]
  * ```
  */
@@ -1898,7 +1913,10 @@ type Result<T, E> = Result$1<T, E>;
  * @example
  * ```ts
  * import { AsyncResult } from "unthrown";
- * const user = await AsyncResult.fromPromise(fetchUser(id), (c, defect) => defect(c));
+ * const user = await AsyncResult.fromPromise(
+ *   fetchUser(id),
+ *   (c, defect) => defect(c),
+ * );
  * user.get(); // => the fetched user (on success)
  * ```
  */

package/dist/index.d.mts

@@ -766,12 +766,20 @@ type ResultMethods<out T, out E> = {
    *
    * @remarks
    * A deliberate escape hatch off the errors-as-values model — it **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.recoverErrCases | recoverErrCases} /
-   * {@link ResultMethods.flatMapErrCases | flatMapErrCases}.
+   * `Err` value as-is** at the call site, so a caller of the enclosing function
+   * sees a throw rather than a channel. Its home is **tests and scripts**,
+   * where "this `Result` had better be `Ok`" is the assertion and a throw is
+   * the correct failure mode.
+   *
+   * In production code, fold the error channel instead:
+   * {@link ResultMethods.recoverErrCases | recoverErrCases} empties `E`, so
+   * {@link ResultMethods.get | get} compiles and a case routed to the injected
+   * `defect(...)` panics with its original cause — with every case still named.
+   * {@link ResultMethods.match | match} and
+   * {@link ResultMethods.flatMapErrCases | flatMapErrCases} are the other two
+   * ways to keep the error a value. `@unthrown/oxlint`'s opt-in
+   * `no-get-or-throw` rule enforces this, exempting test files through an
+   * oxlint `overrides` entry.
    *
    * Type-gated as the **complement** of {@link ResultMethods.get | get}: it
    * compiles only when the error channel is **non-empty** (`E` is not `never`) —
@@ -1450,7 +1458,11 @@ declare class GetError<E = unknown> extends Error {
  *   // `E` is `unknown` here — an untyped boundary has no cases to enumerate,
  *   // so the `P._` escape hatch is the only arm that can terminate the match:
  *   // oxlint-disable-next-line unthrown/no-catch-all-pattern -- untyped boundary: `E` is `unknown`
- *   x.match({ ok: () => 1, errCases: (m) => m.with(P._, () => 0), defect: () => -1 });
+ *   x.match({
+ *     ok: () => 1,
+ *     errCases: (m) => m.with(P._, () => 0),
+ *     defect: () => -1,
+ *   });
  * ```
  *
  * @category Guards
@@ -1790,7 +1802,10 @@ declare function allFromDict<R extends ResultRecord>(results: R): Result$1<{ [K
  * ```ts
  * import { allAsync, fromSafePromise } from "unthrown";
  *
- * const both = allAsync([fromSafePromise(Promise.resolve(1)), fromSafePromise(Promise.resolve(2))]);
+ * const both = allAsync([
+ *   fromSafePromise(Promise.resolve(1)),
+ *   fromSafePromise(Promise.resolve(2)),
+ * ]);
  * (await both).get(); // => [1, 2]
  * ```
  */
@@ -1898,7 +1913,10 @@ type Result<T, E> = Result$1<T, E>;
  * @example
  * ```ts
  * import { AsyncResult } from "unthrown";
- * const user = await AsyncResult.fromPromise(fetchUser(id), (c, defect) => defect(c));
+ * const user = await AsyncResult.fromPromise(
+ *   fetchUser(id),
+ *   (c, defect) => defect(c),
+ * );
  * user.get(); // => the fetched user (on success)
  * ```
  */

package/dist/index.mjs

@@ -537,7 +537,11 @@ function defectRes(cause) {
 *   // `E` is `unknown` here — an untyped boundary has no cases to enumerate,
 *   // so the `P._` escape hatch is the only arm that can terminate the match:
 *   // oxlint-disable-next-line unthrown/no-catch-all-pattern -- untyped boundary: `E` is `unknown`
-*   x.match({ ok: () => 1, errCases: (m) => m.with(P._, () => 0), defect: () => -1 });
+*   x.match({
+*     ok: () => 1,
+*     errCases: (m) => m.with(P._, () => 0),
+*     defect: () => -1,
+*   });
 * ```
 *
 * @category Guards
@@ -1451,7 +1455,10 @@ function allFromDict(results) {
 * ```ts
 * import { allAsync, fromSafePromise } from "unthrown";
 *
-* const both = allAsync([fromSafePromise(Promise.resolve(1)), fromSafePromise(Promise.resolve(2))]);
+* const both = allAsync([
+*   fromSafePromise(Promise.resolve(1)),
+*   fromSafePromise(Promise.resolve(2)),
+* ]);
 * (await both).get(); // => [1, 2]
 * ```
 */
@@ -1555,7 +1562,10 @@ const Result = {
 * @example
 * ```ts
 * import { AsyncResult } from "unthrown";
-* const user = await AsyncResult.fromPromise(fetchUser(id), (c, defect) => defect(c));
+* const user = await AsyncResult.fromPromise(
+*   fetchUser(id),
+*   (c, defect) => defect(c),
+* );
 * user.get(); // => the fetched user (on success)
 * ```
 */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unthrown",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "description": "Explicit errors as values, with a separate defect (panic) channel",
   "keywords": [
     "defect",
@@ -47,13 +47,10 @@
   },
   "devDependencies": {
     "@btravstack/tsconfig": "0.2.0",
-    "@btravstack/typedoc": "0.1.0",
-    "@types/node": "26.1.1",
+    "@types/node": "26.1.2",
     "@vitest/coverage-v8": "4.1.10",
-    "tsdown": "0.22.12",
-    "typedoc": "0.28.20",
-    "typedoc-plugin-markdown": "4.12.0",
-    "typescript": "6.0.3",
+    "tsdown": "0.22.14",
+    "typescript": "7.0.2",
     "vitest": "4.1.10"
   },
   "engines": {
@@ -61,7 +58,6 @@
   },
   "scripts": {
     "build": "tsdown src/index.ts --format cjs,esm --dts --clean",
-    "build:docs": "typedoc",
     "dev": "tsdown src/index.ts --format cjs,esm --dts --watch",
     "test": "vitest run",
     "test:types": "tsc --noEmit -p tsconfig.test-d.json",