@unthrown/boxed 0.3.0 → 1.1.0

package/README.md

@@ -16,11 +16,11 @@ Boxed's `Result` has two channels (`Ok`/`Error`) and no defect channel. Coming
 with `onDefect` — no defect is ever silently folded into your domain error type.
 
 ```ts
-import { ok } from "unthrown";
+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)
+toBoxed(Ok(1), (cause) => ({ _tag: "Bug", cause })); // Result.Ok(1)
 fromBoxed(Result.Ok(1)); // Result<number, never>
 ```
 

package/dist/index.cjs

@@ -3,17 +3,17 @@ let _bloodyowl_boxed = require("@bloodyowl/boxed");
 let unthrown = require("unthrown");
 //#region src/index.ts
 /**
-* Convert a `Result` into a Boxed `Result`, triaging any defect.
+* Convert a `Result` into a Boxed `Result`, triaging any Defect.
 *
 * @remarks
-* Boxed's `Result` has no defect channel, so `onDefect` **must** fold a
+* 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`.
+* @param onDefect - folds a Defect's unknown cause into a modeled `E`.
 */
 function toBoxed(result, onDefect) {
 	return result.match({
@@ -26,7 +26,7 @@ function toBoxed(result, onDefect) {
 * Convert a Boxed `Result` into a `Result`.
 *
 * @remarks
-* `Result.Ok → Ok`, `Result.Error → Err`. Boxed's `Result` carries no defect, so
+* `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.
@@ -35,13 +35,13 @@ function toBoxed(result, onDefect) {
 */
 function fromBoxed(result) {
 	return result.match({
-		Ok: (value) => (0, unthrown.ok)(value),
-		Error: (error) => (0, unthrown.err)(error)
+		Ok: (value) => (0, unthrown.Ok)(value),
+		Error: (error) => (0, unthrown.Err)(error)
 	});
 }
 /**
 * Convert an `AsyncResult` into a Boxed `Future<Result>`, triaging any
-* defect.
+* Defect.
 *
 * @remarks
 * The async counterpart of {@link toBoxed}: `onDefect` is required for the same
@@ -51,7 +51,7 @@ function fromBoxed(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 toBoxedFuture(asyncResult, onDefect) {
 	return _bloodyowl_boxed.Future.make((resolve) => {

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 Boxed `Result`, triaging any defect.
+ * Convert a `Result` into a Boxed `Result`, triaging any Defect.
  *
  * @remarks
- * Boxed's `Result` has no defect channel, so `onDefect` **must** fold a
+ * 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`.
+ * @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
+ * `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.
@@ -30,7 +30,7 @@ declare function toBoxed<T, E>(result: Result$1<T, E>, onDefect: (cause: unknown
 declare function fromBoxed<T, E>(result: Result<T, E>): Result$1<T, E>;
 /**
  * Convert an `AsyncResult` into a Boxed `Future<Result>`, triaging any
- * defect.
+ * Defect.
  *
  * @remarks
  * The async counterpart of {@link toBoxed}: `onDefect` is required for the same
@@ -40,7 +40,7 @@ declare function fromBoxed<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 toBoxedFuture<T, E>(asyncResult: AsyncResult<T, E>, onDefect: (cause: unknown) => E): Future<Result<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 Boxed `Result`, triaging any defect.
+ * Convert a `Result` into a Boxed `Result`, triaging any Defect.
  *
  * @remarks
- * Boxed's `Result` has no defect channel, so `onDefect` **must** fold a
+ * 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`.
+ * @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
+ * `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.
@@ -30,7 +30,7 @@ declare function toBoxed<T, E>(result: Result$1<T, E>, onDefect: (cause: unknown
 declare function fromBoxed<T, E>(result: Result<T, E>): Result$1<T, E>;
 /**
  * Convert an `AsyncResult` into a Boxed `Future<Result>`, triaging any
- * defect.
+ * Defect.
  *
  * @remarks
  * The async counterpart of {@link toBoxed}: `onDefect` is required for the same
@@ -40,7 +40,7 @@ declare function fromBoxed<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 toBoxedFuture<T, E>(asyncResult: AsyncResult<T, E>, onDefect: (cause: unknown) => E): Future<Result<T, E>>;
 /**

package/dist/index.mjs

@@ -1,18 +1,18 @@
 import { Future, Result } from "@bloodyowl/boxed";
-import { err, fromSafePromise, ok } from "unthrown";
+import { Err, Ok, fromSafePromise } from "unthrown";
 //#region src/index.ts
 /**
-* Convert a `Result` into a Boxed `Result`, triaging any defect.
+* Convert a `Result` into a Boxed `Result`, triaging any Defect.
 *
 * @remarks
-* Boxed's `Result` has no defect channel, so `onDefect` **must** fold a
+* 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`.
+* @param onDefect - folds a Defect's unknown cause into a modeled `E`.
 */
 function toBoxed(result, onDefect) {
 	return result.match({
@@ -25,7 +25,7 @@ function toBoxed(result, onDefect) {
 * Convert a Boxed `Result` into a `Result`.
 *
 * @remarks
-* `Result.Ok → Ok`, `Result.Error → Err`. Boxed's `Result` carries no defect, so
+* `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.
@@ -34,13 +34,13 @@ function toBoxed(result, onDefect) {
 */
 function fromBoxed(result) {
 	return result.match({
-		Ok: (value) => ok(value),
-		Error: (error) => err(error)
+		Ok: (value) => Ok(value),
+		Error: (error) => Err(error)
 	});
 }
 /**
 * Convert an `AsyncResult` into a Boxed `Future<Result>`, triaging any
-* defect.
+* Defect.
 *
 * @remarks
 * The async counterpart of {@link toBoxed}: `onDefect` is required for the same
@@ -50,7 +50,7 @@ function fromBoxed(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 toBoxedFuture(asyncResult, onDefect) {
 	return Future.make((resolve) => {

package/dist/index.mjs.map

@@ -1 +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"}
+{"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

@@ -12,7 +12,7 @@
 function fromBoxed<T, E>(result): Result<T, E>;
 ```
 
-Defined in: [index.ts:55](https://github.com/btravstack/unthrown/blob/1e34025e0177665dde9c50faca313fd1b95e5545/packages/boxed/src/index.ts#L55)
+Defined in: [index.ts:55](https://github.com/btravstack/unthrown/blob/8424c0f1e5d5b49a3cb6853d52fb8d5085bd4701/packages/boxed/src/index.ts#L55)
 
 Convert a Boxed `Result` into a `Result`.
 
@@ -35,7 +35,7 @@ Convert a Boxed `Result` into a `Result`.
 
 #### Remarks
 
-`Result.Ok → Ok`, `Result.Error → Err`. Boxed's `Result` carries no defect, so
+`Result.Ok → Ok`, `Result.Error → Err`. Boxed's `Result` carries no Defect, so
 the result is never a `Defect`.
 
 ***
@@ -46,7 +46,7 @@ the result is never a `Defect`.
 function fromBoxedFuture<T, E>(future): AsyncResult<T, E>;
 ```
 
-Defined in: [index.ts:99](https://github.com/btravstack/unthrown/blob/1e34025e0177665dde9c50faca313fd1b95e5545/packages/boxed/src/index.ts#L99)
+Defined in: [index.ts:99](https://github.com/btravstack/unthrown/blob/8424c0f1e5d5b49a3cb6853d52fb8d5085bd4701/packages/boxed/src/index.ts#L99)
 
 Convert a Boxed `Future<Result>` into an `AsyncResult`.
 
@@ -81,9 +81,9 @@ returned `AsyncResult` never throws when awaited.
 function toBoxed<T, E>(result, onDefect): Result<T, E>;
 ```
 
-Defined in: [index.ts:33](https://github.com/btravstack/unthrown/blob/1e34025e0177665dde9c50faca313fd1b95e5545/packages/boxed/src/index.ts#L33)
+Defined in: [index.ts:33](https://github.com/btravstack/unthrown/blob/8424c0f1e5d5b49a3cb6853d52fb8d5085bd4701/packages/boxed/src/index.ts#L33)
 
-Convert a `Result` into a Boxed `Result`, triaging any defect.
+Convert a `Result` into a Boxed `Result`, triaging any Defect.
 
 #### Type Parameters
 
@@ -97,7 +97,7 @@ Convert a `Result` into a Boxed `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,7 +105,7 @@ Convert a `Result` into a Boxed `Result`, triaging any defect.
 
 #### Remarks
 
-Boxed's `Result` has no defect channel, so `onDefect` **must** fold a
+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))`.
 
@@ -117,10 +117,10 @@ Boxed's `Result` has no defect channel, so `onDefect` **must** fold a
 function toBoxedFuture<T, E>(asyncResult, onDefect): Future<Result<T, E>>;
 ```
 
-Defined in: [index.ts:76](https://github.com/btravstack/unthrown/blob/1e34025e0177665dde9c50faca313fd1b95e5545/packages/boxed/src/index.ts#L76)
+Defined in: [index.ts:76](https://github.com/btravstack/unthrown/blob/8424c0f1e5d5b49a3cb6853d52fb8d5085bd4701/packages/boxed/src/index.ts#L76)
 
 Convert an `AsyncResult` into a Boxed `Future<Result>`, 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/boxed",
-  "version": "0.3.0",
+  "version": "1.1.0",
   "description": "Boxed interop for unthrown",
   "keywords": [
     "boxed",
@@ -44,7 +44,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "unthrown": "0.3.0"
+    "unthrown": "1.1.0"
   },
   "devDependencies": {
     "@bloodyowl/boxed": "3.4.0",