@unthrown/neverthrow 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Benoit Travers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# @unthrown/neverthrow
+
+> [neverthrow](https://github.com/supermacro/neverthrow) interop for
+> [unthrown](https://github.com/btravstack/unthrown)'s `Result`.
+
+📖 **[Documentation](https://btravstack.github.io/unthrown/guide/interop)** ·
+[API Reference](https://btravstack.github.io/unthrown/api/neverthrow/)
+
+```sh
+pnpm add @unthrown/neverthrow neverthrow
+```
+
+neverthrow has two channels (`Ok`/`Err`) and no defect channel. Coming **in**,
+every neverthrow result is an `Ok` or `Err` — never a `Defect`. Going **out**, a
+`Defect` has nowhere to live, so `toNeverthrow` **forces** you to triage it with
+`onDefect` — no defect is ever silently folded into your domain error type.
+
+```ts
+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)
+fromNeverthrow(ntOk(1)); // Result<number, never>
+```
+
+- `toNeverthrow(r, onDefect)` / `fromNeverthrow(r)` — sync `Result ↔ Result`.
+- `toNeverthrowAsync(ar, onDefect)` / `fromNeverthrowAsync(ra)` — async
+  `AsyncResult ↔ ResultAsync`. An unexpected rejection inside a `ResultAsync`
+  becomes a `Defect` on the way in.
+
+`neverthrow` is a peer dependency.
+
+## License
+
+[MIT](../../LICENSE) © Benoit TRAVERS

package/dist/index.cjs

@@ -0,0 +1,78 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let neverthrow = require("neverthrow");
+let unthrown = require("unthrown");
+//#region src/index.ts
+/**
+* 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))`.
+*
+* @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`.
+*/
+function toNeverthrow(result, onDefect) {
+	return result.match({
+		ok: (value) => (0, neverthrow.ok)(value),
+		err: (error) => (0, neverthrow.err)(error),
+		defect: (cause) => (0, neverthrow.err)(onDefect(cause))
+	});
+}
+/**
+* Convert a neverthrow `Result` into a `Result`.
+*
+* @remarks
+* `ok → Ok`, `err → Err`. neverthrow carries no defect, so the result is never a
+* `Defect`.
+*
+* @typeParam T - the success value type.
+* @typeParam E - the modeled error type.
+* @param result - the neverthrow result to convert.
+*/
+function fromNeverthrow(result) {
+	return result.isOk() ? (0, unthrown.ok)(result.value) : (0, unthrown.err)(result.error);
+}
+/**
+* Convert an `AsyncResult` into a neverthrow `ResultAsync`, triaging any
+* defect.
+*
+* @remarks
+* The async counterpart of {@link toNeverthrow}: `onDefect` is required for the
+* same reason. The `AsyncResult` is awaited (it never rejects) and each settled
+* `Result` is converted.
+*
+* @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`.
+*/
+function toNeverthrowAsync(asyncResult, onDefect) {
+	return neverthrow.ResultAsync.fromSafePromise(settle(asyncResult)).andThen((result) => toNeverthrow(result, onDefect));
+}
+/**
+* Convert a neverthrow `ResultAsync` into an `AsyncResult`.
+*
+* @remarks
+* The async counterpart of {@link fromNeverthrow}. A modeled `Err` stays an
+* `Err`; an *unexpected* rejection inside the neverthrow chain becomes a
+* `Defect`. The returned `AsyncResult` never throws when awaited.
+*
+* @typeParam T - the success value type.
+* @typeParam E - the modeled error type.
+* @param resultAsync - the neverthrow async result to convert.
+*/
+function fromNeverthrowAsync(resultAsync) {
+	return (0, unthrown.fromSafePromise)(Promise.resolve(resultAsync)).flatMap((result) => fromNeverthrow(result));
+}
+function settle(asyncResult) {
+	return (async () => await asyncResult)();
+}
+//#endregion
+exports.fromNeverthrow = fromNeverthrow;
+exports.fromNeverthrowAsync = fromNeverthrowAsync;
+exports.toNeverthrow = toNeverthrow;
+exports.toNeverthrowAsync = toNeverthrowAsync;

package/dist/index.d.cts

@@ -0,0 +1,61 @@
+import { Result, ResultAsync } from "neverthrow";
+import { AsyncResult, Result as Result$1 } from "unthrown";
+
+//#region src/index.d.ts
+/**
+ * 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))`.
+ *
+ * @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`.
+ */
+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
+ * `Defect`.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param result - the neverthrow result to convert.
+ */
+declare function fromNeverthrow<T, E>(result: Result<T, E>): Result$1<T, E>;
+/**
+ * Convert an `AsyncResult` into a neverthrow `ResultAsync`, triaging any
+ * defect.
+ *
+ * @remarks
+ * The async counterpart of {@link toNeverthrow}: `onDefect` is required for the
+ * same reason. The `AsyncResult` is awaited (it never rejects) and each settled
+ * `Result` is converted.
+ *
+ * @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`.
+ */
+declare function toNeverthrowAsync<T, E>(asyncResult: AsyncResult<T, E>, onDefect: (cause: unknown) => E): ResultAsync<T, E>;
+/**
+ * Convert a neverthrow `ResultAsync` into an `AsyncResult`.
+ *
+ * @remarks
+ * The async counterpart of {@link fromNeverthrow}. A modeled `Err` stays an
+ * `Err`; an *unexpected* rejection inside the neverthrow chain becomes a
+ * `Defect`. The returned `AsyncResult` never throws when awaited.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param resultAsync - the neverthrow async result to convert.
+ */
+declare function fromNeverthrowAsync<T, E>(resultAsync: ResultAsync<T, E>): AsyncResult<T, E>;
+//#endregion
+export { fromNeverthrow, fromNeverthrowAsync, toNeverthrow, toNeverthrowAsync };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;AAqCA;;;;;;;;;;;;iBAAgB,YAAA,OACd,MAAA,EAAQ,QAAA,CAAO,CAAA,EAAG,CAAA,GAClB,QAAA,GAAW,KAAA,cAAmB,CAAA,GAC7B,MAAA,CAAiB,CAAA,EAAG,CAAA;;;;;;;;;;;;iBAmBP,cAAA,OAAqB,MAAA,EAAQ,MAAA,CAAiB,CAAA,EAAG,CAAA,IAAK,QAAA,CAAO,CAAA,EAAG,CAAA;AAnBxD;AAmBxB;;;;;;;;;;;;;AAnBwB,iBAqCR,iBAAA,OACd,WAAA,EAAa,WAAA,CAAY,CAAA,EAAG,CAAA,GAC5B,QAAA,GAAW,KAAA,cAAmB,CAAA,GAC7B,WAAA,CAAsB,CAAA,EAAG,CAAA;;;;;;;;AArBqD;AAkBjF;;;;iBAqBgB,mBAAA,OACd,WAAA,EAAa,WAAA,CAAsB,CAAA,EAAG,CAAA,IACrC,WAAA,CAAY,CAAA,EAAG,CAAA"}

package/dist/index.d.mts

@@ -0,0 +1,61 @@
+import { Result, ResultAsync } from "neverthrow";
+import { AsyncResult, Result as Result$1 } from "unthrown";
+
+//#region src/index.d.ts
+/**
+ * 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))`.
+ *
+ * @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`.
+ */
+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
+ * `Defect`.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param result - the neverthrow result to convert.
+ */
+declare function fromNeverthrow<T, E>(result: Result<T, E>): Result$1<T, E>;
+/**
+ * Convert an `AsyncResult` into a neverthrow `ResultAsync`, triaging any
+ * defect.
+ *
+ * @remarks
+ * The async counterpart of {@link toNeverthrow}: `onDefect` is required for the
+ * same reason. The `AsyncResult` is awaited (it never rejects) and each settled
+ * `Result` is converted.
+ *
+ * @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`.
+ */
+declare function toNeverthrowAsync<T, E>(asyncResult: AsyncResult<T, E>, onDefect: (cause: unknown) => E): ResultAsync<T, E>;
+/**
+ * Convert a neverthrow `ResultAsync` into an `AsyncResult`.
+ *
+ * @remarks
+ * The async counterpart of {@link fromNeverthrow}. A modeled `Err` stays an
+ * `Err`; an *unexpected* rejection inside the neverthrow chain becomes a
+ * `Defect`. The returned `AsyncResult` never throws when awaited.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param resultAsync - the neverthrow async result to convert.
+ */
+declare function fromNeverthrowAsync<T, E>(resultAsync: ResultAsync<T, E>): AsyncResult<T, E>;
+//#endregion
+export { fromNeverthrow, fromNeverthrowAsync, toNeverthrow, toNeverthrowAsync };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;AAqCA;;;;;;;;;;;;iBAAgB,YAAA,OACd,MAAA,EAAQ,QAAA,CAAO,CAAA,EAAG,CAAA,GAClB,QAAA,GAAW,KAAA,cAAmB,CAAA,GAC7B,MAAA,CAAiB,CAAA,EAAG,CAAA;;;;;;;;;;;;iBAmBP,cAAA,OAAqB,MAAA,EAAQ,MAAA,CAAiB,CAAA,EAAG,CAAA,IAAK,QAAA,CAAO,CAAA,EAAG,CAAA;AAnBxD;AAmBxB;;;;;;;;;;;;;AAnBwB,iBAqCR,iBAAA,OACd,WAAA,EAAa,WAAA,CAAY,CAAA,EAAG,CAAA,GAC5B,QAAA,GAAW,KAAA,cAAmB,CAAA,GAC7B,WAAA,CAAsB,CAAA,EAAG,CAAA;;;;;;;;AArBqD;AAkBjF;;;;iBAqBgB,mBAAA,OACd,WAAA,EAAa,WAAA,CAAsB,CAAA,EAAG,CAAA,IACrC,WAAA,CAAY,CAAA,EAAG,CAAA"}

package/dist/index.mjs

@@ -0,0 +1,76 @@
+import { ResultAsync, err, ok } from "neverthrow";
+import { err as err$1, fromSafePromise, ok as ok$1 } from "unthrown";
+//#region src/index.ts
+/**
+* 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))`.
+*
+* @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`.
+*/
+function toNeverthrow(result, onDefect) {
+	return result.match({
+		ok: (value) => ok(value),
+		err: (error) => err(error),
+		defect: (cause) => err(onDefect(cause))
+	});
+}
+/**
+* Convert a neverthrow `Result` into a `Result`.
+*
+* @remarks
+* `ok → Ok`, `err → Err`. neverthrow carries no defect, so the result is never a
+* `Defect`.
+*
+* @typeParam T - the success value type.
+* @typeParam E - the modeled error type.
+* @param result - the neverthrow result to convert.
+*/
+function fromNeverthrow(result) {
+	return result.isOk() ? ok$1(result.value) : err$1(result.error);
+}
+/**
+* Convert an `AsyncResult` into a neverthrow `ResultAsync`, triaging any
+* defect.
+*
+* @remarks
+* The async counterpart of {@link toNeverthrow}: `onDefect` is required for the
+* same reason. The `AsyncResult` is awaited (it never rejects) and each settled
+* `Result` is converted.
+*
+* @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`.
+*/
+function toNeverthrowAsync(asyncResult, onDefect) {
+	return ResultAsync.fromSafePromise(settle(asyncResult)).andThen((result) => toNeverthrow(result, onDefect));
+}
+/**
+* Convert a neverthrow `ResultAsync` into an `AsyncResult`.
+*
+* @remarks
+* The async counterpart of {@link fromNeverthrow}. A modeled `Err` stays an
+* `Err`; an *unexpected* rejection inside the neverthrow chain becomes a
+* `Defect`. The returned `AsyncResult` never throws when awaited.
+*
+* @typeParam T - the success value type.
+* @typeParam E - the modeled error type.
+* @param resultAsync - the neverthrow async result to convert.
+*/
+function fromNeverthrowAsync(resultAsync) {
+	return fromSafePromise(Promise.resolve(resultAsync)).flatMap((result) => fromNeverthrow(result));
+}
+function settle(asyncResult) {
+	return (async () => await asyncResult)();
+}
+//#endregion
+export { fromNeverthrow, fromNeverthrowAsync, toNeverthrow, toNeverthrowAsync };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +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"}

package/docs/index.md

@@ -0,0 +1,147 @@
+**@unthrown/neverthrow**
+
+***
+
+# @unthrown/neverthrow
+
+## Functions
+
+### fromNeverthrow()
+
+```ts
+function fromNeverthrow<T, E>(result): Result<T, E>;
+```
+
+Defined in: index.ts:60
+
+Convert a neverthrow `Result` into a `Result`.
+
+#### Type Parameters
+
+| Type Parameter | Description |
+| ------ | ------ |
+| `T` | the success value type. |
+| `E` | the modeled error type. |
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `result` | `Result`&lt;`T`, `E`&gt; | the neverthrow result to convert. |
+
+#### Returns
+
+`Result`&lt;`T`, `E`&gt;
+
+#### Remarks
+
+`ok → Ok`, `err → Err`. neverthrow carries no defect, so the result is never a
+`Defect`.
+
+***
+
+### fromNeverthrowAsync()
+
+```ts
+function fromNeverthrowAsync<T, E>(resultAsync): AsyncResult<T, E>;
+```
+
+Defined in: index.ts:99
+
+Convert a neverthrow `ResultAsync` into an `AsyncResult`.
+
+#### Type Parameters
+
+| Type Parameter | Description |
+| ------ | ------ |
+| `T` | the success value type. |
+| `E` | the modeled error type. |
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `resultAsync` | `ResultAsync`&lt;`T`, `E`&gt; | the neverthrow async result to convert. |
+
+#### Returns
+
+`AsyncResult`&lt;`T`, `E`&gt;
+
+#### Remarks
+
+The async counterpart of [fromNeverthrow](#fromneverthrow). A modeled `Err` stays an
+`Err`; an *unexpected* rejection inside the neverthrow chain becomes a
+`Defect`. The returned `AsyncResult` never throws when awaited.
+
+***
+
+### toNeverthrow()
+
+```ts
+function toNeverthrow<T, E>(result, onDefect): Result<T, E>;
+```
+
+Defined in: index.ts:38
+
+Convert a `Result` into a neverthrow `Result`, triaging any defect.
+
+#### Type Parameters
+
+| Type Parameter | Description |
+| ------ | ------ |
+| `T` | the success value type. |
+| `E` | the modeled error type. |
+
+#### Parameters
+
+| 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`. |
+
+#### Returns
+
+`Result`&lt;`T`, `E`&gt;
+
+#### 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))`.
+
+***
+
+### toNeverthrowAsync()
+
+```ts
+function toNeverthrowAsync<T, E>(asyncResult, onDefect): ResultAsync<T, E>;
+```
+
+Defined in: index.ts:78
+
+Convert an `AsyncResult` into a neverthrow `ResultAsync`, triaging any
+defect.
+
+#### Type Parameters
+
+| Type Parameter | Description |
+| ------ | ------ |
+| `T` | the success value type. |
+| `E` | the modeled error type. |
+
+#### Parameters
+
+| 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`. |
+
+#### Returns
+
+`ResultAsync`&lt;`T`, `E`&gt;
+
+#### Remarks
+
+The async counterpart of [toNeverthrow](#toneverthrow): `onDefect` is required for the
+same reason. The `AsyncResult` is awaited (it never rejects) and each settled
+`Result` is converted.

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@unthrown/neverthrow",
+  "version": "0.1.0",
+  "description": "neverthrow interop for unthrown",
+  "keywords": [
+    "errors-as-values",
+    "neverthrow",
+    "result",
+    "resultasync",
+    "typescript",
+    "unthrown"
+  ],
+  "homepage": "https://github.com/btravstack/unthrown#readme",
+  "bugs": {
+    "url": "https://github.com/btravstack/unthrown/issues"
+  },
+  "license": "MIT",
+  "author": "Benoit TRAVERS <benoit.travers.fr@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/btravstack/unthrown.git",
+    "directory": "packages/neverthrow"
+  },
+  "files": [
+    "dist",
+    "docs"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "unthrown": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.13.2",
+    "@vitest/coverage-v8": "4.1.8",
+    "neverthrow": "8.2.0",
+    "tsdown": "0.22.2",
+    "typedoc": "0.28.19",
+    "typedoc-plugin-markdown": "4.12.0",
+    "typescript": "6.0.3",
+    "vitest": "4.1.8",
+    "@unthrown/typedoc": "0.1.0",
+    "@unthrown/tsconfig": "0.1.0"
+  },
+  "peerDependencies": {
+    "neverthrow": "^8"
+  },
+  "engines": {
+    "node": ">=22.19"
+  },
+  "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",
+    "typecheck": "tsc --noEmit"
+  }
+}