@unthrown/neverthrow 0.3.0 → 1.1.0

package/README.md

@@ -16,11 +16,11 @@ every neverthrow result is an `Ok` or `Err` — never a `Defect`. Going **out**,
 `onDefect` — no defect is ever silently folded into your domain error type.
 
 ```ts
-import { ok } from "unthrown";
+import { Ok } from "unthrown";
 import { toNeverthrow, fromNeverthrow } from "@unthrown/neverthrow";
 import { ok as ntOk } from "neverthrow";
 
-toNeverthrow(ok(1), (cause) => ({ _tag: "Bug", cause })); // neverthrow Ok(1)
+toNeverthrow(Ok(1), (cause) => ({ _tag: "Bug", cause })); // neverthrow Ok(1)
 fromNeverthrow(ntOk(1)); // Result<number, never>
 ```
 

package/dist/index.cjs

@@ -3,17 +3,17 @@ let neverthrow = require("neverthrow");
 let unthrown = require("unthrown");
 //#region src/index.ts
 /**
-* Convert a `Result` into a neverthrow `Result`, triaging any defect.
+* Convert a `Result` into a neverthrow `Result`, triaging any Defect.
 *
 * @remarks
-* neverthrow has no defect channel, so `onDefect` **must** fold a `Defect`'s
-* cause into a modeled error `E` (an `Err`). `Ok → ok`, `Err → err`,
-* `Defect → err(onDefect(cause))`.
+* neverthrow has no Defect channel, so `onDefect` **must** fold a `Defect`'s
+* cause into a modeled error `E` (an `Err`). `Ok → Ok`, `Err → Err`,
+* `Defect → Err(onDefect(cause))`.
 *
 * @typeParam T - the success value type.
 * @typeParam E - the modeled error type.
 * @param result - the result to convert.
-* @param onDefect - folds a defect's unknown cause into a modeled `E`.
+* @param onDefect - folds a Defect's unknown cause into a modeled `E`.
 */
 function toNeverthrow(result, onDefect) {
 	return result.match({
@@ -26,7 +26,7 @@ function toNeverthrow(result, onDefect) {
 * Convert a neverthrow `Result` into a `Result`.
 *
 * @remarks
-* `ok → Ok`, `err → Err`. neverthrow carries no defect, so the result is never a
+* `Ok → Ok`, `Err → Err`. neverthrow carries no Defect, so the result is never a
 * `Defect`.
 *
 * @typeParam T - the success value type.
@@ -34,11 +34,11 @@ function toNeverthrow(result, onDefect) {
 * @param result - the neverthrow result to convert.
 */
 function fromNeverthrow(result) {
-	return result.isOk() ? (0, unthrown.ok)(result.value) : (0, unthrown.err)(result.error);
+	return result.isOk() ? (0, unthrown.Ok)(result.value) : (0, unthrown.Err)(result.error);
 }
 /**
 * Convert an `AsyncResult` into a neverthrow `ResultAsync`, triaging any
-* defect.
+* Defect.
 *
 * @remarks
 * The async counterpart of {@link toNeverthrow}: `onDefect` is required for the
@@ -48,7 +48,7 @@ function fromNeverthrow(result) {
 * @typeParam T - the success value type.
 * @typeParam E - the modeled error type.
 * @param asyncResult - the async result to convert.
-* @param onDefect - folds a defect's unknown cause into a modeled `E`.
+* @param onDefect - folds a Defect's unknown cause into a modeled `E`.
 */
 function toNeverthrowAsync(asyncResult, onDefect) {
 	return neverthrow.ResultAsync.fromSafePromise(settle(asyncResult)).andThen((result) => toNeverthrow(result, onDefect));

package/dist/index.d.cts

@@ -3,24 +3,24 @@ import { AsyncResult, Result as Result$1 } from "unthrown";
 
 //#region src/index.d.ts
 /**
- * Convert a `Result` into a neverthrow `Result`, triaging any defect.
+ * Convert a `Result` into a neverthrow `Result`, triaging any Defect.
  *
  * @remarks
- * neverthrow has no defect channel, so `onDefect` **must** fold a `Defect`'s
- * cause into a modeled error `E` (an `Err`). `Ok → ok`, `Err → err`,
- * `Defect → err(onDefect(cause))`.
+ * neverthrow has no Defect channel, so `onDefect` **must** fold a `Defect`'s
+ * cause into a modeled error `E` (an `Err`). `Ok → Ok`, `Err → Err`,
+ * `Defect → Err(onDefect(cause))`.
  *
  * @typeParam T - the success value type.
  * @typeParam E - the modeled error type.
  * @param result - the result to convert.
- * @param onDefect - folds a defect's unknown cause into a modeled `E`.
+ * @param onDefect - folds a Defect's unknown cause into a modeled `E`.
  */
 declare function toNeverthrow<T, E>(result: Result$1<T, E>, onDefect: (cause: unknown) => E): Result<T, E>;
 /**
  * Convert a neverthrow `Result` into a `Result`.
  *
  * @remarks
- * `ok → Ok`, `err → Err`. neverthrow carries no defect, so the result is never a
+ * `Ok → Ok`, `Err → Err`. neverthrow carries no Defect, so the result is never a
  * `Defect`.
  *
  * @typeParam T - the success value type.
@@ -30,7 +30,7 @@ declare function toNeverthrow<T, E>(result: Result$1<T, E>, onDefect: (cause: un
 declare function fromNeverthrow<T, E>(result: Result<T, E>): Result$1<T, E>;
 /**
  * Convert an `AsyncResult` into a neverthrow `ResultAsync`, triaging any
- * defect.
+ * Defect.
  *
  * @remarks
  * The async counterpart of {@link toNeverthrow}: `onDefect` is required for the
@@ -40,7 +40,7 @@ declare function fromNeverthrow<T, E>(result: Result<T, E>): Result$1<T, E>;
  * @typeParam T - the success value type.
  * @typeParam E - the modeled error type.
  * @param asyncResult - the async result to convert.
- * @param onDefect - folds a defect's unknown cause into a modeled `E`.
+ * @param onDefect - folds a Defect's unknown cause into a modeled `E`.
  */
 declare function toNeverthrowAsync<T, E>(asyncResult: AsyncResult<T, E>, onDefect: (cause: unknown) => E): ResultAsync<T, E>;
 /**

package/dist/index.d.mts

@@ -3,24 +3,24 @@ import { AsyncResult, Result as Result$1 } from "unthrown";
 
 //#region src/index.d.ts
 /**
- * Convert a `Result` into a neverthrow `Result`, triaging any defect.
+ * Convert a `Result` into a neverthrow `Result`, triaging any Defect.
  *
  * @remarks
- * neverthrow has no defect channel, so `onDefect` **must** fold a `Defect`'s
- * cause into a modeled error `E` (an `Err`). `Ok → ok`, `Err → err`,
- * `Defect → err(onDefect(cause))`.
+ * neverthrow has no Defect channel, so `onDefect` **must** fold a `Defect`'s
+ * cause into a modeled error `E` (an `Err`). `Ok → Ok`, `Err → Err`,
+ * `Defect → Err(onDefect(cause))`.
  *
  * @typeParam T - the success value type.
  * @typeParam E - the modeled error type.
  * @param result - the result to convert.
- * @param onDefect - folds a defect's unknown cause into a modeled `E`.
+ * @param onDefect - folds a Defect's unknown cause into a modeled `E`.
  */
 declare function toNeverthrow<T, E>(result: Result$1<T, E>, onDefect: (cause: unknown) => E): Result<T, E>;
 /**
  * Convert a neverthrow `Result` into a `Result`.
  *
  * @remarks
- * `ok → Ok`, `err → Err`. neverthrow carries no defect, so the result is never a
+ * `Ok → Ok`, `Err → Err`. neverthrow carries no Defect, so the result is never a
  * `Defect`.
  *
  * @typeParam T - the success value type.
@@ -30,7 +30,7 @@ declare function toNeverthrow<T, E>(result: Result$1<T, E>, onDefect: (cause: un
 declare function fromNeverthrow<T, E>(result: Result<T, E>): Result$1<T, E>;
 /**
  * Convert an `AsyncResult` into a neverthrow `ResultAsync`, triaging any
- * defect.
+ * Defect.
  *
  * @remarks
  * The async counterpart of {@link toNeverthrow}: `onDefect` is required for the
@@ -40,7 +40,7 @@ declare function fromNeverthrow<T, E>(result: Result<T, E>): Result$1<T, E>;
  * @typeParam T - the success value type.
  * @typeParam E - the modeled error type.
  * @param asyncResult - the async result to convert.
- * @param onDefect - folds a defect's unknown cause into a modeled `E`.
+ * @param onDefect - folds a Defect's unknown cause into a modeled `E`.
  */
 declare function toNeverthrowAsync<T, E>(asyncResult: AsyncResult<T, E>, onDefect: (cause: unknown) => E): ResultAsync<T, E>;
 /**

package/dist/index.mjs

@@ -1,18 +1,18 @@
 import { ResultAsync, err, ok } from "neverthrow";
-import { err as err$1, fromSafePromise, ok as ok$1 } from "unthrown";
+import { Err, Ok, fromSafePromise } from "unthrown";
 //#region src/index.ts
 /**
-* Convert a `Result` into a neverthrow `Result`, triaging any defect.
+* Convert a `Result` into a neverthrow `Result`, triaging any Defect.
 *
 * @remarks
-* neverthrow has no defect channel, so `onDefect` **must** fold a `Defect`'s
-* cause into a modeled error `E` (an `Err`). `Ok → ok`, `Err → err`,
-* `Defect → err(onDefect(cause))`.
+* neverthrow has no Defect channel, so `onDefect` **must** fold a `Defect`'s
+* cause into a modeled error `E` (an `Err`). `Ok → Ok`, `Err → Err`,
+* `Defect → Err(onDefect(cause))`.
 *
 * @typeParam T - the success value type.
 * @typeParam E - the modeled error type.
 * @param result - the result to convert.
-* @param onDefect - folds a defect's unknown cause into a modeled `E`.
+* @param onDefect - folds a Defect's unknown cause into a modeled `E`.
 */
 function toNeverthrow(result, onDefect) {
 	return result.match({
@@ -25,7 +25,7 @@ function toNeverthrow(result, onDefect) {
 * Convert a neverthrow `Result` into a `Result`.
 *
 * @remarks
-* `ok → Ok`, `err → Err`. neverthrow carries no defect, so the result is never a
+* `Ok → Ok`, `Err → Err`. neverthrow carries no Defect, so the result is never a
 * `Defect`.
 *
 * @typeParam T - the success value type.
@@ -33,11 +33,11 @@ function toNeverthrow(result, onDefect) {
 * @param result - the neverthrow result to convert.
 */
 function fromNeverthrow(result) {
-	return result.isOk() ? ok$1(result.value) : err$1(result.error);
+	return result.isOk() ? Ok(result.value) : Err(result.error);
 }
 /**
 * Convert an `AsyncResult` into a neverthrow `ResultAsync`, triaging any
-* defect.
+* Defect.
 *
 * @remarks
 * The async counterpart of {@link toNeverthrow}: `onDefect` is required for the
@@ -47,7 +47,7 @@ function fromNeverthrow(result) {
 * @typeParam T - the success value type.
 * @typeParam E - the modeled error type.
 * @param asyncResult - the async result to convert.
-* @param onDefect - folds a defect's unknown cause into a modeled `E`.
+* @param onDefect - folds a Defect's unknown cause into a modeled `E`.
 */
 function toNeverthrowAsync(asyncResult, onDefect) {
 	return ResultAsync.fromSafePromise(settle(asyncResult)).andThen((result) => toNeverthrow(result, onDefect));

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["neverthrowOk","neverthrowErr","ok","err","NeverthrowResultAsync"],"sources":["../src/index.ts"],"sourcesContent":["// @unthrown/neverthrow — interop between unthrown's `Result`/`AsyncResult` and\n// neverthrow's `Result`/`ResultAsync`.\n//\n// neverthrow has two channels (`Ok`/`Err`), so it cannot represent unthrown's\n// third one. Coming *in*, every neverthrow result is an `Ok` or `Err` — never a\n// `Defect`. Going *out*, a `Defect` has nowhere to live, so `toNeverthrow`\n// forces you to triage it with `onDefect` (Thesis #3): no defect is ever\n// silently folded into your domain error type.\n//\n//   import { ok } from \"unthrown\";\n//   import { toNeverthrow, fromNeverthrow } from \"@unthrown/neverthrow\";\n//\n//   toNeverthrow(ok(1), (cause) => ({ _tag: \"Bug\", cause }));\n//   fromNeverthrow(neverthrowOk(1)); // Result<number, never>\n\nimport {\n  err as neverthrowErr,\n  ok as neverthrowOk,\n  ResultAsync as NeverthrowResultAsync,\n} from \"neverthrow\";\nimport type { Result as NeverthrowResult } from \"neverthrow\";\nimport { err, fromSafePromise, ok } from \"unthrown\";\nimport type { AsyncResult, Result } from \"unthrown\";\n\n/**\n * Convert a `Result` into a neverthrow `Result`, triaging any defect.\n *\n * @remarks\n * neverthrow has no defect channel, so `onDefect` **must** fold a `Defect`'s\n * cause into a modeled error `E` (an `Err`). `Ok → ok`, `Err → err`,\n * `Defect → err(onDefect(cause))`.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the modeled error type.\n * @param result - the result to convert.\n * @param onDefect - folds a defect's unknown cause into a modeled `E`.\n */\nexport function toNeverthrow<T, E>(\n  result: Result<T, E>,\n  onDefect: (cause: unknown) => E,\n): NeverthrowResult<T, E> {\n  return result.match<NeverthrowResult<T, E>>({\n    ok: (value) => neverthrowOk(value),\n    err: (error) => neverthrowErr(error),\n    defect: (cause) => neverthrowErr(onDefect(cause)),\n  });\n}\n\n/**\n * Convert a neverthrow `Result` into a `Result`.\n *\n * @remarks\n * `ok → Ok`, `err → Err`. neverthrow carries no defect, so the result is never a\n * `Defect`.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the modeled error type.\n * @param result - the neverthrow result to convert.\n */\nexport function fromNeverthrow<T, E>(result: NeverthrowResult<T, E>): Result<T, E> {\n  return result.isOk() ? ok(result.value) : err(result.error);\n}\n\n/**\n * Convert an `AsyncResult` into a neverthrow `ResultAsync`, triaging any\n * defect.\n *\n * @remarks\n * The async counterpart of {@link toNeverthrow}: `onDefect` is required for the\n * same reason. The `AsyncResult` is awaited (it never rejects) and each settled\n * `Result` is converted.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the modeled error type.\n * @param asyncResult - the async result to convert.\n * @param onDefect - folds a defect's unknown cause into a modeled `E`.\n */\nexport function toNeverthrowAsync<T, E>(\n  asyncResult: AsyncResult<T, E>,\n  onDefect: (cause: unknown) => E,\n): NeverthrowResultAsync<T, E> {\n  return NeverthrowResultAsync.fromSafePromise(settle(asyncResult)).andThen((result) =>\n    toNeverthrow(result, onDefect),\n  );\n}\n\n/**\n * Convert a neverthrow `ResultAsync` into an `AsyncResult`.\n *\n * @remarks\n * The async counterpart of {@link fromNeverthrow}. A modeled `Err` stays an\n * `Err`; an *unexpected* rejection inside the neverthrow chain becomes a\n * `Defect`. The returned `AsyncResult` never throws when awaited.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the modeled error type.\n * @param resultAsync - the neverthrow async result to convert.\n */\nexport function fromNeverthrowAsync<T, E>(\n  resultAsync: NeverthrowResultAsync<T, E>,\n): AsyncResult<T, E> {\n  return fromSafePromise(Promise.resolve(resultAsync)).flatMap((result) => fromNeverthrow(result));\n}\n\nfunction settle<T, E>(asyncResult: AsyncResult<T, E>): Promise<Result<T, E>> {\n  return (async () => await asyncResult)();\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAqCA,SAAgB,aACd,QACA,UACwB;CACxB,OAAO,OAAO,MAA8B;EAC1C,KAAK,UAAUA,GAAa,KAAK;EACjC,MAAM,UAAUC,IAAc,KAAK;EACnC,SAAS,UAAUA,IAAc,SAAS,KAAK,CAAC;CAClD,CAAC;AACH;;;;;;;;;;;;AAaA,SAAgB,eAAqB,QAA8C;CACjF,OAAO,OAAO,KAAK,IAAIC,KAAG,OAAO,KAAK,IAAIC,MAAI,OAAO,KAAK;AAC5D;;;;;;;;;;;;;;;AAgBA,SAAgB,kBACd,aACA,UAC6B;CAC7B,OAAOC,YAAsB,gBAAgB,OAAO,WAAW,CAAC,CAAC,CAAC,SAAS,WACzE,aAAa,QAAQ,QAAQ,CAC/B;AACF;;;;;;;;;;;;;AAcA,SAAgB,oBACd,aACmB;CACnB,OAAO,gBAAgB,QAAQ,QAAQ,WAAW,CAAC,CAAC,CAAC,SAAS,WAAW,eAAe,MAAM,CAAC;AACjG;AAEA,SAAS,OAAa,aAAuD;CAC3E,QAAQ,YAAY,MAAM,YAAA,CAAa;AACzC"}
+{"version":3,"file":"index.mjs","names":["neverthrowOk","neverthrowErr","NeverthrowResultAsync"],"sources":["../src/index.ts"],"sourcesContent":["// @unthrown/neverthrow — interop between unthrown's `Result`/`AsyncResult` and\n// neverthrow's `Result`/`ResultAsync`.\n//\n// neverthrow has two channels (`Ok`/`Err`), so it cannot represent unthrown's\n// third one. Coming *in*, every neverthrow result is an `Ok` or `Err` — never a\n// `Defect`. Going *out*, a `Defect` has nowhere to live, so `toNeverthrow`\n// forces you to triage it with `onDefect` (Thesis #3): no Defect is ever\n// silently folded into your domain error type.\n//\n//   import { Ok } from \"unthrown\";\n//   import { toNeverthrow, fromNeverthrow } from \"@unthrown/neverthrow\";\n//\n//   toNeverthrow(Ok(1), (cause) => ({ _tag: \"Bug\", cause }));\n//   fromNeverthrow(neverthrowOk(1)); // Result<number, never>\n\nimport {\n  err as neverthrowErr,\n  ok as neverthrowOk,\n  ResultAsync as NeverthrowResultAsync,\n} from \"neverthrow\";\nimport type { Result as NeverthrowResult } from \"neverthrow\";\nimport { Err, fromSafePromise, Ok } from \"unthrown\";\nimport type { AsyncResult, Result } from \"unthrown\";\n\n/**\n * Convert a `Result` into a neverthrow `Result`, triaging any Defect.\n *\n * @remarks\n * neverthrow has no Defect channel, so `onDefect` **must** fold a `Defect`'s\n * cause into a modeled error `E` (an `Err`). `Ok → Ok`, `Err → Err`,\n * `Defect → Err(onDefect(cause))`.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the modeled error type.\n * @param result - the result to convert.\n * @param onDefect - folds a Defect's unknown cause into a modeled `E`.\n */\nexport function toNeverthrow<T, E>(\n  result: Result<T, E>,\n  onDefect: (cause: unknown) => E,\n): NeverthrowResult<T, E> {\n  return result.match<NeverthrowResult<T, E>>({\n    ok: (value) => neverthrowOk(value),\n    err: (error) => neverthrowErr(error),\n    defect: (cause) => neverthrowErr(onDefect(cause)),\n  });\n}\n\n/**\n * Convert a neverthrow `Result` into a `Result`.\n *\n * @remarks\n * `Ok → Ok`, `Err → Err`. neverthrow carries no Defect, so the result is never a\n * `Defect`.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the modeled error type.\n * @param result - the neverthrow result to convert.\n */\nexport function fromNeverthrow<T, E>(result: NeverthrowResult<T, E>): Result<T, E> {\n  return result.isOk() ? Ok(result.value) : Err(result.error);\n}\n\n/**\n * Convert an `AsyncResult` into a neverthrow `ResultAsync`, triaging any\n * Defect.\n *\n * @remarks\n * The async counterpart of {@link toNeverthrow}: `onDefect` is required for the\n * same reason. The `AsyncResult` is awaited (it never rejects) and each settled\n * `Result` is converted.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the modeled error type.\n * @param asyncResult - the async result to convert.\n * @param onDefect - folds a Defect's unknown cause into a modeled `E`.\n */\nexport function toNeverthrowAsync<T, E>(\n  asyncResult: AsyncResult<T, E>,\n  onDefect: (cause: unknown) => E,\n): NeverthrowResultAsync<T, E> {\n  return NeverthrowResultAsync.fromSafePromise(settle(asyncResult)).andThen((result) =>\n    toNeverthrow(result, onDefect),\n  );\n}\n\n/**\n * Convert a neverthrow `ResultAsync` into an `AsyncResult`.\n *\n * @remarks\n * The async counterpart of {@link fromNeverthrow}. A modeled `Err` stays an\n * `Err`; an *unexpected* rejection inside the neverthrow chain becomes a\n * `Defect`. The returned `AsyncResult` never throws when awaited.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the modeled error type.\n * @param resultAsync - the neverthrow async result to convert.\n */\nexport function fromNeverthrowAsync<T, E>(\n  resultAsync: NeverthrowResultAsync<T, E>,\n): AsyncResult<T, E> {\n  return fromSafePromise(Promise.resolve(resultAsync)).flatMap((result) => fromNeverthrow(result));\n}\n\nfunction settle<T, E>(asyncResult: AsyncResult<T, E>): Promise<Result<T, E>> {\n  return (async () => await asyncResult)();\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAqCA,SAAgB,aACd,QACA,UACwB;CACxB,OAAO,OAAO,MAA8B;EAC1C,KAAK,UAAUA,GAAa,KAAK;EACjC,MAAM,UAAUC,IAAc,KAAK;EACnC,SAAS,UAAUA,IAAc,SAAS,KAAK,CAAC;CAClD,CAAC;AACH;;;;;;;;;;;;AAaA,SAAgB,eAAqB,QAA8C;CACjF,OAAO,OAAO,KAAK,IAAI,GAAG,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK;AAC5D;;;;;;;;;;;;;;;AAgBA,SAAgB,kBACd,aACA,UAC6B;CAC7B,OAAOC,YAAsB,gBAAgB,OAAO,WAAW,CAAC,CAAC,CAAC,SAAS,WACzE,aAAa,QAAQ,QAAQ,CAC/B;AACF;;;;;;;;;;;;;AAcA,SAAgB,oBACd,aACmB;CACnB,OAAO,gBAAgB,QAAQ,QAAQ,WAAW,CAAC,CAAC,CAAC,SAAS,WAAW,eAAe,MAAM,CAAC;AACjG;AAEA,SAAS,OAAa,aAAuD;CAC3E,QAAQ,YAAY,MAAM,YAAA,CAAa;AACzC"}

package/docs/index.md

@@ -12,7 +12,7 @@
 function fromNeverthrow<T, E>(result): Result<T, E>;
 ```
 
-Defined in: [index.ts:60](https://github.com/btravstack/unthrown/blob/1e34025e0177665dde9c50faca313fd1b95e5545/packages/neverthrow/src/index.ts#L60)
+Defined in: [index.ts:60](https://github.com/btravstack/unthrown/blob/8424c0f1e5d5b49a3cb6853d52fb8d5085bd4701/packages/neverthrow/src/index.ts#L60)
 
 Convert a neverthrow `Result` into a `Result`.
 
@@ -35,7 +35,7 @@ Convert a neverthrow `Result` into a `Result`.
 
 #### Remarks
 
-`ok → Ok`, `err → Err`. neverthrow carries no defect, so the result is never a
+`Ok → Ok`, `Err → Err`. neverthrow carries no Defect, so the result is never a
 `Defect`.
 
 ***
@@ -46,7 +46,7 @@ Convert a neverthrow `Result` into a `Result`.
 function fromNeverthrowAsync<T, E>(resultAsync): AsyncResult<T, E>;
 ```
 
-Defined in: [index.ts:99](https://github.com/btravstack/unthrown/blob/1e34025e0177665dde9c50faca313fd1b95e5545/packages/neverthrow/src/index.ts#L99)
+Defined in: [index.ts:99](https://github.com/btravstack/unthrown/blob/8424c0f1e5d5b49a3cb6853d52fb8d5085bd4701/packages/neverthrow/src/index.ts#L99)
 
 Convert a neverthrow `ResultAsync` into an `AsyncResult`.
 
@@ -81,9 +81,9 @@ The async counterpart of [fromNeverthrow](#fromneverthrow). A modeled `Err` stay
 function toNeverthrow<T, E>(result, onDefect): Result<T, E>;
 ```
 
-Defined in: [index.ts:38](https://github.com/btravstack/unthrown/blob/1e34025e0177665dde9c50faca313fd1b95e5545/packages/neverthrow/src/index.ts#L38)
+Defined in: [index.ts:38](https://github.com/btravstack/unthrown/blob/8424c0f1e5d5b49a3cb6853d52fb8d5085bd4701/packages/neverthrow/src/index.ts#L38)
 
-Convert a `Result` into a neverthrow `Result`, triaging any defect.
+Convert a `Result` into a neverthrow `Result`, triaging any Defect.
 
 #### Type Parameters
 
@@ -97,7 +97,7 @@ Convert a `Result` into a neverthrow `Result`, triaging any defect.
 | Parameter | Type | Description |
 | ------ | ------ | ------ |
 | `result` | `Result`&lt;`T`, `E`&gt; | the result to convert. |
-| `onDefect` | (`cause`) => `E` | folds a defect's unknown cause into a modeled `E`. |
+| `onDefect` | (`cause`) => `E` | folds a Defect's unknown cause into a modeled `E`. |
 
 #### Returns
 
@@ -105,9 +105,9 @@ Convert a `Result` into a neverthrow `Result`, triaging any defect.
 
 #### Remarks
 
-neverthrow has no defect channel, so `onDefect` **must** fold a `Defect`'s
-cause into a modeled error `E` (an `Err`). `Ok → ok`, `Err → err`,
-`Defect → err(onDefect(cause))`.
+neverthrow has no Defect channel, so `onDefect` **must** fold a `Defect`'s
+cause into a modeled error `E` (an `Err`). `Ok → Ok`, `Err → Err`,
+`Defect → Err(onDefect(cause))`.
 
 ***
 
@@ -117,10 +117,10 @@ cause into a modeled error `E` (an `Err`). `Ok → ok`, `Err → err`,
 function toNeverthrowAsync<T, E>(asyncResult, onDefect): ResultAsync<T, E>;
 ```
 
-Defined in: [index.ts:78](https://github.com/btravstack/unthrown/blob/1e34025e0177665dde9c50faca313fd1b95e5545/packages/neverthrow/src/index.ts#L78)
+Defined in: [index.ts:78](https://github.com/btravstack/unthrown/blob/8424c0f1e5d5b49a3cb6853d52fb8d5085bd4701/packages/neverthrow/src/index.ts#L78)
 
 Convert an `AsyncResult` into a neverthrow `ResultAsync`, triaging any
-defect.
+Defect.
 
 #### Type Parameters
 
@@ -134,7 +134,7 @@ defect.
 | Parameter | Type | Description |
 | ------ | ------ | ------ |
 | `asyncResult` | `AsyncResult`&lt;`T`, `E`&gt; | the async result to convert. |
-| `onDefect` | (`cause`) => `E` | folds a defect's unknown cause into a modeled `E`. |
+| `onDefect` | (`cause`) => `E` | folds a Defect's unknown cause into a modeled `E`. |
 
 #### Returns
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unthrown/neverthrow",
-  "version": "0.3.0",
+  "version": "1.1.0",
   "description": "neverthrow interop for unthrown",
   "keywords": [
     "errors-as-values",
@@ -43,7 +43,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "unthrown": "0.3.0"
+    "unthrown": "1.1.0"
   },
   "devDependencies": {
     "@types/node": "24.13.2",