@unthrown/boxed 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,40 @@
+# @unthrown/boxed
+
+> [Boxed](https://boxed.cool) 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/boxed/)
+
+```sh
+pnpm add @unthrown/boxed @bloodyowl/boxed
+```
+
+Boxed's `Result` has two channels (`Ok`/`Error`) and no defect channel. Coming
+**in**, every Boxed result is an `Ok` or `Error` — never a `Defect`. Going
+**out**, a `Defect` has nowhere to live, so `toBoxed` **forces** you to triage it
+with `onDefect` — no defect is ever silently folded into your domain error type.
+
+```ts
+import { ok } from "unthrown";
+import { toBoxed, fromBoxed } from "@unthrown/boxed";
+import { Result } from "@bloodyowl/boxed";
+
+toBoxed(ok(1), (cause) => ({ _tag: "Bug", cause })); // Result.Ok(1)
+fromBoxed(Result.Ok(1)); // Result<number, never>
+```
+
+- `toBoxed(r, onDefect)` / `fromBoxed(r)` — sync `Result ↔ Result`.
+- `toBoxedFuture(ar, onDefect)` / `fromBoxedFuture(future)` — async
+  `AsyncResult ↔ Future<Result>`.
+
+> Boxed's `Option` has no analogue here — per unthrown's design, absence is
+> expressed with `T | undefined` or `Result<T, NotFound>` (see `fromNullable`),
+> not a dedicated `Option` type.
+
+`@bloodyowl/boxed` is a peer dependency. (Boxed was formerly published as
+`@swan-io/boxed`, now deprecated in favour of this maintained scope.)
+
+## License
+
+[MIT](../../LICENSE) © Benoit TRAVERS

package/dist/index.cjs

@@ -0,0 +1,85 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _bloodyowl_boxed = require("@bloodyowl/boxed");
+let unthrown = require("unthrown");
+//#region src/index.ts
+/**
+* Convert a `Result` into a Boxed `Result`, triaging any defect.
+*
+* @remarks
+* Boxed's `Result` has no defect channel, so `onDefect` **must** fold a
+* `Defect`'s cause into a modeled error `E` (an `Error`). `Ok → Result.Ok`,
+* `Err → Result.Error`, `Defect → Result.Error(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 toBoxed(result, onDefect) {
+	return result.match({
+		ok: (value) => _bloodyowl_boxed.Result.Ok(value),
+		err: (error) => _bloodyowl_boxed.Result.Error(error),
+		defect: (cause) => _bloodyowl_boxed.Result.Error(onDefect(cause))
+	});
+}
+/**
+* Convert a Boxed `Result` into a `Result`.
+*
+* @remarks
+* `Result.Ok → Ok`, `Result.Error → Err`. Boxed's `Result` 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 Boxed result to convert.
+*/
+function fromBoxed(result) {
+	return result.match({
+		Ok: (value) => (0, unthrown.ok)(value),
+		Error: (error) => (0, unthrown.err)(error)
+	});
+}
+/**
+* Convert an `AsyncResult` into a Boxed `Future<Result>`, triaging any
+* defect.
+*
+* @remarks
+* The async counterpart of {@link toBoxed}: `onDefect` is required for the same
+* reason. The `AsyncResult` is awaited (it never rejects) and its settled
+* `Result` is converted, then resolved into the `Future`.
+*
+* @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 toBoxedFuture(asyncResult, onDefect) {
+	return _bloodyowl_boxed.Future.make((resolve) => {
+		settle(asyncResult).then((result) => {
+			resolve(toBoxed(result, onDefect));
+		});
+	});
+}
+/**
+* Convert a Boxed `Future<Result>` into an `AsyncResult`.
+*
+* @remarks
+* The async counterpart of {@link fromBoxed}. A `Result.Error` stays an `Err`;
+* an *unexpected* rejection of the underlying promise becomes a `Defect`. The
+* returned `AsyncResult` never throws when awaited.
+*
+* @typeParam T - the success value type.
+* @typeParam E - the modeled error type.
+* @param future - the Boxed future to convert.
+*/
+function fromBoxedFuture(future) {
+	return (0, unthrown.fromSafePromise)(future.toPromise()).flatMap((result) => fromBoxed(result));
+}
+function settle(asyncResult) {
+	return (async () => await asyncResult)();
+}
+//#endregion
+exports.fromBoxed = fromBoxed;
+exports.fromBoxedFuture = fromBoxedFuture;
+exports.toBoxed = toBoxed;
+exports.toBoxedFuture = toBoxedFuture;

package/dist/index.d.cts

@@ -0,0 +1,61 @@
+import { Future, Result } from "@bloodyowl/boxed";
+import { AsyncResult, Result as Result$1 } from "unthrown";
+
+//#region src/index.d.ts
+/**
+ * Convert a `Result` into a Boxed `Result`, triaging any defect.
+ *
+ * @remarks
+ * Boxed's `Result` has no defect channel, so `onDefect` **must** fold a
+ * `Defect`'s cause into a modeled error `E` (an `Error`). `Ok → Result.Ok`,
+ * `Err → Result.Error`, `Defect → Result.Error(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 toBoxed<T, E>(result: Result$1<T, E>, onDefect: (cause: unknown) => E): Result<T, E>;
+/**
+ * Convert a Boxed `Result` into a `Result`.
+ *
+ * @remarks
+ * `Result.Ok → Ok`, `Result.Error → Err`. Boxed's `Result` 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 Boxed result to convert.
+ */
+declare function fromBoxed<T, E>(result: Result<T, E>): Result$1<T, E>;
+/**
+ * Convert an `AsyncResult` into a Boxed `Future<Result>`, triaging any
+ * defect.
+ *
+ * @remarks
+ * The async counterpart of {@link toBoxed}: `onDefect` is required for the same
+ * reason. The `AsyncResult` is awaited (it never rejects) and its settled
+ * `Result` is converted, then resolved into the `Future`.
+ *
+ * @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 toBoxedFuture<T, E>(asyncResult: AsyncResult<T, E>, onDefect: (cause: unknown) => E): Future<Result<T, E>>;
+/**
+ * Convert a Boxed `Future<Result>` into an `AsyncResult`.
+ *
+ * @remarks
+ * The async counterpart of {@link fromBoxed}. A `Result.Error` stays an `Err`;
+ * an *unexpected* rejection of the underlying promise becomes a `Defect`. The
+ * returned `AsyncResult` never throws when awaited.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param future - the Boxed future to convert.
+ */
+declare function fromBoxedFuture<T, E>(future: Future<Result<T, E>>): AsyncResult<T, E>;
+//#endregion
+export { fromBoxed, fromBoxedFuture, toBoxed, toBoxedFuture };
+//# 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":";;;;;;AAgCA;;;;;;;;;;;iBAAgB,OAAA,OACd,MAAA,EAAQ,QAAA,CAAO,CAAA,EAAG,CAAA,GAClB,QAAA,GAAW,KAAA,cAAmB,CAAA,GAC7B,MAAA,CAAY,CAAA,EAAG,CAAA;;;;;;;;;;;;iBAmBF,SAAA,OAAgB,MAAA,EAAQ,MAAA,CAAY,CAAA,EAAG,CAAA,IAAK,QAAA,CAAO,CAAA,EAAG,CAAA;;AAnBnD;AAmBnB;;;;;;;;;;;;iBAqBgB,aAAA,OACd,WAAA,EAAa,WAAA,CAAY,CAAA,EAAG,CAAA,GAC5B,QAAA,GAAW,KAAA,cAAmB,CAAA,GAC7B,MAAA,CAAO,MAAA,CAAY,CAAA,EAAG,CAAA;;;;;;;;;AAxB8C;AAqBvE;;;iBAuBgB,eAAA,OAAsB,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAY,CAAA,EAAG,CAAA,KAAM,WAAA,CAAY,CAAA,EAAG,CAAA"}

package/dist/index.d.mts

@@ -0,0 +1,61 @@
+import { Future, Result } from "@bloodyowl/boxed";
+import { AsyncResult, Result as Result$1 } from "unthrown";
+
+//#region src/index.d.ts
+/**
+ * Convert a `Result` into a Boxed `Result`, triaging any defect.
+ *
+ * @remarks
+ * Boxed's `Result` has no defect channel, so `onDefect` **must** fold a
+ * `Defect`'s cause into a modeled error `E` (an `Error`). `Ok → Result.Ok`,
+ * `Err → Result.Error`, `Defect → Result.Error(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 toBoxed<T, E>(result: Result$1<T, E>, onDefect: (cause: unknown) => E): Result<T, E>;
+/**
+ * Convert a Boxed `Result` into a `Result`.
+ *
+ * @remarks
+ * `Result.Ok → Ok`, `Result.Error → Err`. Boxed's `Result` 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 Boxed result to convert.
+ */
+declare function fromBoxed<T, E>(result: Result<T, E>): Result$1<T, E>;
+/**
+ * Convert an `AsyncResult` into a Boxed `Future<Result>`, triaging any
+ * defect.
+ *
+ * @remarks
+ * The async counterpart of {@link toBoxed}: `onDefect` is required for the same
+ * reason. The `AsyncResult` is awaited (it never rejects) and its settled
+ * `Result` is converted, then resolved into the `Future`.
+ *
+ * @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 toBoxedFuture<T, E>(asyncResult: AsyncResult<T, E>, onDefect: (cause: unknown) => E): Future<Result<T, E>>;
+/**
+ * Convert a Boxed `Future<Result>` into an `AsyncResult`.
+ *
+ * @remarks
+ * The async counterpart of {@link fromBoxed}. A `Result.Error` stays an `Err`;
+ * an *unexpected* rejection of the underlying promise becomes a `Defect`. The
+ * returned `AsyncResult` never throws when awaited.
+ *
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @param future - the Boxed future to convert.
+ */
+declare function fromBoxedFuture<T, E>(future: Future<Result<T, E>>): AsyncResult<T, E>;
+//#endregion
+export { fromBoxed, fromBoxedFuture, toBoxed, toBoxedFuture };
+//# 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":";;;;;;AAgCA;;;;;;;;;;;iBAAgB,OAAA,OACd,MAAA,EAAQ,QAAA,CAAO,CAAA,EAAG,CAAA,GAClB,QAAA,GAAW,KAAA,cAAmB,CAAA,GAC7B,MAAA,CAAY,CAAA,EAAG,CAAA;;;;;;;;;;;;iBAmBF,SAAA,OAAgB,MAAA,EAAQ,MAAA,CAAY,CAAA,EAAG,CAAA,IAAK,QAAA,CAAO,CAAA,EAAG,CAAA;;AAnBnD;AAmBnB;;;;;;;;;;;;iBAqBgB,aAAA,OACd,WAAA,EAAa,WAAA,CAAY,CAAA,EAAG,CAAA,GAC5B,QAAA,GAAW,KAAA,cAAmB,CAAA,GAC7B,MAAA,CAAO,MAAA,CAAY,CAAA,EAAG,CAAA;;;;;;;;;AAxB8C;AAqBvE;;;iBAuBgB,eAAA,OAAsB,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAY,CAAA,EAAG,CAAA,KAAM,WAAA,CAAY,CAAA,EAAG,CAAA"}

package/dist/index.mjs

@@ -0,0 +1,83 @@
+import { Future, Result } from "@bloodyowl/boxed";
+import { err, fromSafePromise, ok } from "unthrown";
+//#region src/index.ts
+/**
+* Convert a `Result` into a Boxed `Result`, triaging any defect.
+*
+* @remarks
+* Boxed's `Result` has no defect channel, so `onDefect` **must** fold a
+* `Defect`'s cause into a modeled error `E` (an `Error`). `Ok → Result.Ok`,
+* `Err → Result.Error`, `Defect → Result.Error(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 toBoxed(result, onDefect) {
+	return result.match({
+		ok: (value) => Result.Ok(value),
+		err: (error) => Result.Error(error),
+		defect: (cause) => Result.Error(onDefect(cause))
+	});
+}
+/**
+* Convert a Boxed `Result` into a `Result`.
+*
+* @remarks
+* `Result.Ok → Ok`, `Result.Error → Err`. Boxed's `Result` 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 Boxed result to convert.
+*/
+function fromBoxed(result) {
+	return result.match({
+		Ok: (value) => ok(value),
+		Error: (error) => err(error)
+	});
+}
+/**
+* Convert an `AsyncResult` into a Boxed `Future<Result>`, triaging any
+* defect.
+*
+* @remarks
+* The async counterpart of {@link toBoxed}: `onDefect` is required for the same
+* reason. The `AsyncResult` is awaited (it never rejects) and its settled
+* `Result` is converted, then resolved into the `Future`.
+*
+* @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 toBoxedFuture(asyncResult, onDefect) {
+	return Future.make((resolve) => {
+		settle(asyncResult).then((result) => {
+			resolve(toBoxed(result, onDefect));
+		});
+	});
+}
+/**
+* Convert a Boxed `Future<Result>` into an `AsyncResult`.
+*
+* @remarks
+* The async counterpart of {@link fromBoxed}. A `Result.Error` stays an `Err`;
+* an *unexpected* rejection of the underlying promise becomes a `Defect`. The
+* returned `AsyncResult` never throws when awaited.
+*
+* @typeParam T - the success value type.
+* @typeParam E - the modeled error type.
+* @param future - the Boxed future to convert.
+*/
+function fromBoxedFuture(future) {
+	return fromSafePromise(future.toPromise()).flatMap((result) => fromBoxed(result));
+}
+function settle(asyncResult) {
+	return (async () => await asyncResult)();
+}
+//#endregion
+export { fromBoxed, fromBoxedFuture, toBoxed, toBoxedFuture };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["BoxedResult"],"sources":["../src/index.ts"],"sourcesContent":["// @unthrown/boxed — interop between unthrown's `Result`/`AsyncResult` and\n// Boxed's `Result`/`Future<Result>`.\n//\n// Boxed's `Result` has two channels (`Ok`/`Error`) and no defect channel.\n// Coming *in*, every Boxed result is an `Ok` or `Error` — never a `Defect`.\n// Going *out*, a `Defect` has nowhere to live, so `toBoxed` forces you to triage\n// it with `onDefect` (Thesis #3): no defect is ever silently folded into your\n// domain error type.\n//\n//   import { ok } from \"unthrown\";\n//   import { toBoxed, fromBoxed } from \"@unthrown/boxed\";\n//\n//   toBoxed(ok(1), (cause) => ({ _tag: \"Bug\", cause })); // Result.Ok(1)\n//   fromBoxed(Result.Ok(1));                              // Result<number, never>\n\nimport { Future, Result as BoxedResult } from \"@bloodyowl/boxed\";\nimport { err, fromSafePromise, ok } from \"unthrown\";\nimport type { AsyncResult, Result } from \"unthrown\";\n\n/**\n * Convert a `Result` into a Boxed `Result`, triaging any defect.\n *\n * @remarks\n * Boxed's `Result` has no defect channel, so `onDefect` **must** fold a\n * `Defect`'s cause into a modeled error `E` (an `Error`). `Ok → Result.Ok`,\n * `Err → Result.Error`, `Defect → Result.Error(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 toBoxed<T, E>(\n  result: Result<T, E>,\n  onDefect: (cause: unknown) => E,\n): BoxedResult<T, E> {\n  return result.match<BoxedResult<T, E>>({\n    ok: (value) => BoxedResult.Ok(value),\n    err: (error) => BoxedResult.Error(error),\n    defect: (cause) => BoxedResult.Error(onDefect(cause)),\n  });\n}\n\n/**\n * Convert a Boxed `Result` into a `Result`.\n *\n * @remarks\n * `Result.Ok → Ok`, `Result.Error → Err`. Boxed's `Result` carries no defect, so\n * the result is never a `Defect`.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the modeled error type.\n * @param result - the Boxed result to convert.\n */\nexport function fromBoxed<T, E>(result: BoxedResult<T, E>): Result<T, E> {\n  return result.match({\n    Ok: (value) => ok(value),\n    Error: (error) => err(error),\n  });\n}\n\n/**\n * Convert an `AsyncResult` into a Boxed `Future<Result>`, triaging any\n * defect.\n *\n * @remarks\n * The async counterpart of {@link toBoxed}: `onDefect` is required for the same\n * reason. The `AsyncResult` is awaited (it never rejects) and its settled\n * `Result` is converted, then resolved into the `Future`.\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 toBoxedFuture<T, E>(\n  asyncResult: AsyncResult<T, E>,\n  onDefect: (cause: unknown) => E,\n): Future<BoxedResult<T, E>> {\n  return Future.make<BoxedResult<T, E>>((resolve) => {\n    void settle(asyncResult).then((result) => {\n      resolve(toBoxed(result, onDefect));\n    });\n  });\n}\n\n/**\n * Convert a Boxed `Future<Result>` into an `AsyncResult`.\n *\n * @remarks\n * The async counterpart of {@link fromBoxed}. A `Result.Error` stays an `Err`;\n * an *unexpected* rejection of the underlying promise becomes a `Defect`. The\n * returned `AsyncResult` never throws when awaited.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the modeled error type.\n * @param future - the Boxed future to convert.\n */\nexport function fromBoxedFuture<T, E>(future: Future<BoxedResult<T, E>>): AsyncResult<T, E> {\n  return fromSafePromise(future.toPromise()).flatMap((result) => fromBoxed(result));\n}\n\nfunction settle<T, E>(asyncResult: AsyncResult<T, E>): Promise<Result<T, E>> {\n  return (async () => await asyncResult)();\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgCA,SAAgB,QACd,QACA,UACmB;CACnB,OAAO,OAAO,MAAyB;EACrC,KAAK,UAAUA,OAAY,GAAG,KAAK;EACnC,MAAM,UAAUA,OAAY,MAAM,KAAK;EACvC,SAAS,UAAUA,OAAY,MAAM,SAAS,KAAK,CAAC;CACtD,CAAC;AACH;;;;;;;;;;;;AAaA,SAAgB,UAAgB,QAAyC;CACvE,OAAO,OAAO,MAAM;EAClB,KAAK,UAAU,GAAG,KAAK;EACvB,QAAQ,UAAU,IAAI,KAAK;CAC7B,CAAC;AACH;;;;;;;;;;;;;;;AAgBA,SAAgB,cACd,aACA,UAC2B;CAC3B,OAAO,OAAO,MAAyB,YAAY;EACjD,OAAY,WAAW,CAAC,CAAC,MAAM,WAAW;GACxC,QAAQ,QAAQ,QAAQ,QAAQ,CAAC;EACnC,CAAC;CACH,CAAC;AACH;;;;;;;;;;;;;AAcA,SAAgB,gBAAsB,QAAsD;CAC1F,OAAO,gBAAgB,OAAO,UAAU,CAAC,CAAC,CAAC,SAAS,WAAW,UAAU,MAAM,CAAC;AAClF;AAEA,SAAS,OAAa,aAAuD;CAC3E,QAAQ,YAAY,MAAM,YAAA,CAAa;AACzC"}

package/docs/index.md

@@ -0,0 +1,147 @@
+**@unthrown/boxed**
+
+***
+
+# @unthrown/boxed
+
+## Functions
+
+### fromBoxed()
+
+```ts
+function fromBoxed<T, E>(result): Result<T, E>;
+```
+
+Defined in: index.ts:55
+
+Convert a Boxed `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 Boxed result to convert. |
+
+#### Returns
+
+`Result`&lt;`T`, `E`&gt;
+
+#### Remarks
+
+`Result.Ok → Ok`, `Result.Error → Err`. Boxed's `Result` carries no defect, so
+the result is never a `Defect`.
+
+***
+
+### fromBoxedFuture()
+
+```ts
+function fromBoxedFuture<T, E>(future): AsyncResult<T, E>;
+```
+
+Defined in: index.ts:99
+
+Convert a Boxed `Future<Result>` into an `AsyncResult`.
+
+#### Type Parameters
+
+| Type Parameter | Description |
+| ------ | ------ |
+| `T` | the success value type. |
+| `E` | the modeled error type. |
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `future` | `Future`&lt;`Result`&lt;`T`, `E`&gt;&gt; | the Boxed future to convert. |
+
+#### Returns
+
+`AsyncResult`&lt;`T`, `E`&gt;
+
+#### Remarks
+
+The async counterpart of [fromBoxed](#fromboxed). A `Result.Error` stays an `Err`;
+an *unexpected* rejection of the underlying promise becomes a `Defect`. The
+returned `AsyncResult` never throws when awaited.
+
+***
+
+### toBoxed()
+
+```ts
+function toBoxed<T, E>(result, onDefect): Result<T, E>;
+```
+
+Defined in: index.ts:33
+
+Convert a `Result` into a Boxed `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
+
+Boxed's `Result` has no defect channel, so `onDefect` **must** fold a
+`Defect`'s cause into a modeled error `E` (an `Error`). `Ok → Result.Ok`,
+`Err → Result.Error`, `Defect → Result.Error(onDefect(cause))`.
+
+***
+
+### toBoxedFuture()
+
+```ts
+function toBoxedFuture<T, E>(asyncResult, onDefect): Future<Result<T, E>>;
+```
+
+Defined in: index.ts:76
+
+Convert an `AsyncResult` into a Boxed `Future<Result>`, 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
+
+`Future`&lt;`Result`&lt;`T`, `E`&gt;&gt;
+
+#### Remarks
+
+The async counterpart of [toBoxed](#toboxed): `onDefect` is required for the same
+reason. The `AsyncResult` is awaited (it never rejects) and its settled
+`Result` is converted, then resolved into the `Future`.

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@unthrown/boxed",
+  "version": "0.1.0",
+  "description": "Boxed interop for unthrown",
+  "keywords": [
+    "boxed",
+    "errors-as-values",
+    "future",
+    "result",
+    "swan-io",
+    "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/boxed"
+  },
+  "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": {
+    "@bloodyowl/boxed": "3.4.0",
+    "@types/node": "24.13.2",
+    "@vitest/coverage-v8": "4.1.8",
+    "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": {
+    "@bloodyowl/boxed": "^3"
+  },
+  "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"
+  }
+}