@temporal-contract/contract 2.3.1 → 3.0.0

package/README.md

@@ -32,11 +32,11 @@ export const myContract = defineContract({
 
 ## Documentation
 
-📖 **[Read the full documentation →](https://btravers.github.io/temporal-contract)**
+📖 **[Read the full documentation →](https://btravstack.github.io/temporal-contract)**
 
-- [API Reference](https://btravers.github.io/temporal-contract/api/contract)
-- [Getting Started](https://btravers.github.io/temporal-contract/guide/getting-started)
-- [Core Concepts](https://btravers.github.io/temporal-contract/guide/core-concepts)
+- [API Reference](https://btravstack.github.io/temporal-contract/api/contract)
+- [Getting Started](https://btravstack.github.io/temporal-contract/guide/getting-started)
+- [Core Concepts](https://btravstack.github.io/temporal-contract/guide/core-concepts)
 
 ## License
 

package/dist/result-async.cjs

@@ -1,41 +1,57 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-let neverthrow = require("neverthrow");
+let unthrown = require("unthrown");
 //#region src/result-async.ts
 /**
 * Internal helper shared across `@temporal-contract/client` and
 * `@temporal-contract/worker` for wrapping a result-producing async function
-* in a `ResultAsync` while routing any unhandled rejection through a typed
-* mapper.
+* in an `AsyncResult`, routing any unanticipated rejection through unthrown's
+* `defect` channel.
 *
 * Lives in `@temporal-contract/contract` so the two consuming packages don't
 * each carry their own copy. Exported from the package's public surface
-* under a deliberately-internal-looking name (`_internal_makeResultAsync`)
+* under a deliberately-internal-looking name (`_internal_makeAsyncResult`)
 * so users don't import it by accident — there is no semver guarantee on
 * this entry point.
 */
 /**
-* Wrap an async function returning `Promise<Result<T, E>>` in a
-* `ResultAsync<T, E>`, catching synchronous throws and rejected promises
-* and routing them through `mapRejection` so they surface as typed
-* `err(...)` instead of unhandled rejections.
+* Wrap an async function returning `Promise<Result<T, E>>` in an
+* `AsyncResult<T, E>`, catching synchronous throws and rejected promises and
+* routing them through unthrown's `defect` channel — so an *unanticipated*
+* failure surfaces as a defect (a bug, re-thrown at the edge) rather than an
+* unhandled rejection, while the work function's own domain `err(...)` flows
+* through untouched.
 *
-* `new ResultAsync(promise)` does **not** catch rejections — the resulting
-* `ResultAsync` rejects, escaping neverthrow's railway. This helper closes
-* that gap. The work function is expected to handle its own domain errors
-* and return `err(...)` for them; `mapRejection` is a safety net for
-* thrown exceptions the work didn't anticipate.
+* `fromSafePromise(thunk)` invokes the thunk, capturing both a synchronous
+* throw before the promise is produced and an eventual rejection as a `defect`
+* (its error channel is `never`) — the work function is expected to model its
+* own domain errors as `err(...)`, so any *thrown* failure is by definition
+* unmodeled. The `.flatMap((inner) => inner)` flattens the nested
+* `Result<T, E>` the thunk resolves with, surfacing its modeled error channel.
 *
-* @internal — exported under `_internal_makeResultAsync` for use by the
+* @internal — exported under `_internal_makeAsyncResult` for use by the
 * sibling client and worker packages. Not part of the public API.
 */
-function _internal_makeResultAsync(work, mapRejection) {
-	let promise;
-	try {
-		promise = work();
-	} catch (error) {
-		promise = Promise.resolve((0, neverthrow.err)(mapRejection(error)));
-	}
-	return new neverthrow.ResultAsync(promise.catch((e) => (0, neverthrow.err)(mapRejection(e))));
+function _internal_makeAsyncResult(work) {
+	return (0, unthrown.fromSafePromise)(work).flatMap((inner) => inner);
+}
+/**
+* Assert that a `Result` is not a `Defect`, narrowing it to `Ok | Err`.
+*
+* unthrown's `Result<T, E>` type always includes the out-of-band `Defect`
+* variant, so `if (r.isErr()) … else r.value` does not type-check — the `else`
+* branch is still `Ok | Defect`. For an internally-produced result that is
+* *known* to be built only from `ok(...)` / `err(...)`, this collapses the
+* "impossible defect" case in one call: it re-throws a present defect's cause
+* (so a genuine bug still rides the defect channel at the boundary) and
+* narrows the result to `Ok | Err` for the caller, which can then branch on
+* `isErr` / `isOk` and reach `.value` / `.error` cleanly.
+*
+* @internal — exported under `_internal_assertNoDefect` for the sibling client
+* and worker packages. Not part of the public API.
+*/
+function _internal_assertNoDefect(result) {
+	if (result.isDefect()) throw result.cause;
 }
 //#endregion
-exports._internal_makeResultAsync = _internal_makeResultAsync;
+exports._internal_assertNoDefect = _internal_assertNoDefect;
+exports._internal_makeAsyncResult = _internal_makeAsyncResult;

package/dist/result-async.d.cts

@@ -1,22 +1,41 @@
-import { Result, ResultAsync } from "neverthrow";
+import { AsyncResult, ErrView, OkView, Result } from "unthrown";
 
 //#region src/result-async.d.ts
 /**
- * Wrap an async function returning `Promise<Result<T, E>>` in a
- * `ResultAsync<T, E>`, catching synchronous throws and rejected promises
- * and routing them through `mapRejection` so they surface as typed
- * `err(...)` instead of unhandled rejections.
+ * Wrap an async function returning `Promise<Result<T, E>>` in an
+ * `AsyncResult<T, E>`, catching synchronous throws and rejected promises and
+ * routing them through unthrown's `defect` channel — so an *unanticipated*
+ * failure surfaces as a defect (a bug, re-thrown at the edge) rather than an
+ * unhandled rejection, while the work function's own domain `err(...)` flows
+ * through untouched.
  *
- * `new ResultAsync(promise)` does **not** catch rejections — the resulting
- * `ResultAsync` rejects, escaping neverthrow's railway. This helper closes
- * that gap. The work function is expected to handle its own domain errors
- * and return `err(...)` for them; `mapRejection` is a safety net for
- * thrown exceptions the work didn't anticipate.
+ * `fromSafePromise(thunk)` invokes the thunk, capturing both a synchronous
+ * throw before the promise is produced and an eventual rejection as a `defect`
+ * (its error channel is `never`) — the work function is expected to model its
+ * own domain errors as `err(...)`, so any *thrown* failure is by definition
+ * unmodeled. The `.flatMap((inner) => inner)` flattens the nested
+ * `Result<T, E>` the thunk resolves with, surfacing its modeled error channel.
  *
- * @internal — exported under `_internal_makeResultAsync` for use by the
+ * @internal — exported under `_internal_makeAsyncResult` for use by the
  * sibling client and worker packages. Not part of the public API.
  */
-declare function _internal_makeResultAsync<T, E>(work: () => Promise<Result<T, E>>, mapRejection: (error: unknown) => E): ResultAsync<T, E>;
+declare function _internal_makeAsyncResult<T, E>(work: () => Promise<Result<T, E>>): AsyncResult<T, E>;
+/**
+ * Assert that a `Result` is not a `Defect`, narrowing it to `Ok | Err`.
+ *
+ * unthrown's `Result<T, E>` type always includes the out-of-band `Defect`
+ * variant, so `if (r.isErr()) … else r.value` does not type-check — the `else`
+ * branch is still `Ok | Defect`. For an internally-produced result that is
+ * *known* to be built only from `ok(...)` / `err(...)`, this collapses the
+ * "impossible defect" case in one call: it re-throws a present defect's cause
+ * (so a genuine bug still rides the defect channel at the boundary) and
+ * narrows the result to `Ok | Err` for the caller, which can then branch on
+ * `isErr` / `isOk` and reach `.value` / `.error` cleanly.
+ *
+ * @internal — exported under `_internal_assertNoDefect` for the sibling client
+ * and worker packages. Not part of the public API.
+ */
+declare function _internal_assertNoDefect<T, E>(result: Result<T, E>): asserts result is OkView<T, E> | ErrView<E, T>;
 //#endregion
-export { _internal_makeResultAsync };
+export { _internal_assertNoDefect, _internal_makeAsyncResult };
 //# sourceMappingURL=result-async.d.cts.map

package/dist/result-async.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"result-async.d.cts","names":[],"sources":["../src/result-async.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBA6BgB,yBAAA,OACd,IAAA,QAAY,OAAA,CAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,IAC9B,YAAA,GAAe,KAAA,cAAmB,CAAA,GACjC,WAAA,CAAY,CAAA,EAAG,CAAA"}
+{"version":3,"file":"result-async.d.cts","names":[],"sources":["../src/result-async.ts"],"mappings":";;;;;;;;;;;;;;;;AAwCmB;AAmBnB;;;;iBArBgB,yBAAA,OACd,IAAA,QAAY,OAAA,CAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,KAC7B,WAAA,CAAY,CAAA,EAAG,CAAA;;;;;;;;;;;;;;;;iBAmBF,wBAAA,OACd,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,YACT,MAAA,IAAU,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,OAAA,CAAQ,CAAA,EAAG,CAAA"}

package/dist/result-async.d.mts

@@ -1,22 +1,41 @@
-import { Result, ResultAsync } from "neverthrow";
+import { AsyncResult, ErrView, OkView, Result } from "unthrown";
 
 //#region src/result-async.d.ts
 /**
- * Wrap an async function returning `Promise<Result<T, E>>` in a
- * `ResultAsync<T, E>`, catching synchronous throws and rejected promises
- * and routing them through `mapRejection` so they surface as typed
- * `err(...)` instead of unhandled rejections.
+ * Wrap an async function returning `Promise<Result<T, E>>` in an
+ * `AsyncResult<T, E>`, catching synchronous throws and rejected promises and
+ * routing them through unthrown's `defect` channel — so an *unanticipated*
+ * failure surfaces as a defect (a bug, re-thrown at the edge) rather than an
+ * unhandled rejection, while the work function's own domain `err(...)` flows
+ * through untouched.
  *
- * `new ResultAsync(promise)` does **not** catch rejections — the resulting
- * `ResultAsync` rejects, escaping neverthrow's railway. This helper closes
- * that gap. The work function is expected to handle its own domain errors
- * and return `err(...)` for them; `mapRejection` is a safety net for
- * thrown exceptions the work didn't anticipate.
+ * `fromSafePromise(thunk)` invokes the thunk, capturing both a synchronous
+ * throw before the promise is produced and an eventual rejection as a `defect`
+ * (its error channel is `never`) — the work function is expected to model its
+ * own domain errors as `err(...)`, so any *thrown* failure is by definition
+ * unmodeled. The `.flatMap((inner) => inner)` flattens the nested
+ * `Result<T, E>` the thunk resolves with, surfacing its modeled error channel.
  *
- * @internal — exported under `_internal_makeResultAsync` for use by the
+ * @internal — exported under `_internal_makeAsyncResult` for use by the
  * sibling client and worker packages. Not part of the public API.
  */
-declare function _internal_makeResultAsync<T, E>(work: () => Promise<Result<T, E>>, mapRejection: (error: unknown) => E): ResultAsync<T, E>;
+declare function _internal_makeAsyncResult<T, E>(work: () => Promise<Result<T, E>>): AsyncResult<T, E>;
+/**
+ * Assert that a `Result` is not a `Defect`, narrowing it to `Ok | Err`.
+ *
+ * unthrown's `Result<T, E>` type always includes the out-of-band `Defect`
+ * variant, so `if (r.isErr()) … else r.value` does not type-check — the `else`
+ * branch is still `Ok | Defect`. For an internally-produced result that is
+ * *known* to be built only from `ok(...)` / `err(...)`, this collapses the
+ * "impossible defect" case in one call: it re-throws a present defect's cause
+ * (so a genuine bug still rides the defect channel at the boundary) and
+ * narrows the result to `Ok | Err` for the caller, which can then branch on
+ * `isErr` / `isOk` and reach `.value` / `.error` cleanly.
+ *
+ * @internal — exported under `_internal_assertNoDefect` for the sibling client
+ * and worker packages. Not part of the public API.
+ */
+declare function _internal_assertNoDefect<T, E>(result: Result<T, E>): asserts result is OkView<T, E> | ErrView<E, T>;
 //#endregion
-export { _internal_makeResultAsync };
+export { _internal_assertNoDefect, _internal_makeAsyncResult };
 //# sourceMappingURL=result-async.d.mts.map

package/dist/result-async.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-async.d.mts","names":[],"sources":["../src/result-async.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBA6BgB,yBAAA,OACd,IAAA,QAAY,OAAA,CAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,IAC9B,YAAA,GAAe,KAAA,cAAmB,CAAA,GACjC,WAAA,CAAY,CAAA,EAAG,CAAA"}
+{"version":3,"file":"result-async.d.mts","names":[],"sources":["../src/result-async.ts"],"mappings":";;;;;;;;;;;;;;;;AAwCmB;AAmBnB;;;;iBArBgB,yBAAA,OACd,IAAA,QAAY,OAAA,CAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,KAC7B,WAAA,CAAY,CAAA,EAAG,CAAA;;;;;;;;;;;;;;;;iBAmBF,wBAAA,OACd,MAAA,EAAQ,MAAA,CAAO,CAAA,EAAG,CAAA,YACT,MAAA,IAAU,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,OAAA,CAAQ,CAAA,EAAG,CAAA"}

package/dist/result-async.mjs

@@ -1,42 +1,57 @@
-import { ResultAsync, err } from "neverthrow";
+import { fromSafePromise } from "unthrown";
 //#region src/result-async.ts
 /**
 * Internal helper shared across `@temporal-contract/client` and
 * `@temporal-contract/worker` for wrapping a result-producing async function
-* in a `ResultAsync` while routing any unhandled rejection through a typed
-* mapper.
+* in an `AsyncResult`, routing any unanticipated rejection through unthrown's
+* `defect` channel.
 *
 * Lives in `@temporal-contract/contract` so the two consuming packages don't
 * each carry their own copy. Exported from the package's public surface
-* under a deliberately-internal-looking name (`_internal_makeResultAsync`)
+* under a deliberately-internal-looking name (`_internal_makeAsyncResult`)
 * so users don't import it by accident — there is no semver guarantee on
 * this entry point.
 */
 /**
-* Wrap an async function returning `Promise<Result<T, E>>` in a
-* `ResultAsync<T, E>`, catching synchronous throws and rejected promises
-* and routing them through `mapRejection` so they surface as typed
-* `err(...)` instead of unhandled rejections.
+* Wrap an async function returning `Promise<Result<T, E>>` in an
+* `AsyncResult<T, E>`, catching synchronous throws and rejected promises and
+* routing them through unthrown's `defect` channel — so an *unanticipated*
+* failure surfaces as a defect (a bug, re-thrown at the edge) rather than an
+* unhandled rejection, while the work function's own domain `err(...)` flows
+* through untouched.
 *
-* `new ResultAsync(promise)` does **not** catch rejections — the resulting
-* `ResultAsync` rejects, escaping neverthrow's railway. This helper closes
-* that gap. The work function is expected to handle its own domain errors
-* and return `err(...)` for them; `mapRejection` is a safety net for
-* thrown exceptions the work didn't anticipate.
+* `fromSafePromise(thunk)` invokes the thunk, capturing both a synchronous
+* throw before the promise is produced and an eventual rejection as a `defect`
+* (its error channel is `never`) — the work function is expected to model its
+* own domain errors as `err(...)`, so any *thrown* failure is by definition
+* unmodeled. The `.flatMap((inner) => inner)` flattens the nested
+* `Result<T, E>` the thunk resolves with, surfacing its modeled error channel.
 *
-* @internal — exported under `_internal_makeResultAsync` for use by the
+* @internal — exported under `_internal_makeAsyncResult` for use by the
 * sibling client and worker packages. Not part of the public API.
 */
-function _internal_makeResultAsync(work, mapRejection) {
-	let promise;
-	try {
-		promise = work();
-	} catch (error) {
-		promise = Promise.resolve(err(mapRejection(error)));
-	}
-	return new ResultAsync(promise.catch((e) => err(mapRejection(e))));
+function _internal_makeAsyncResult(work) {
+	return fromSafePromise(work).flatMap((inner) => inner);
+}
+/**
+* Assert that a `Result` is not a `Defect`, narrowing it to `Ok | Err`.
+*
+* unthrown's `Result<T, E>` type always includes the out-of-band `Defect`
+* variant, so `if (r.isErr()) … else r.value` does not type-check — the `else`
+* branch is still `Ok | Defect`. For an internally-produced result that is
+* *known* to be built only from `ok(...)` / `err(...)`, this collapses the
+* "impossible defect" case in one call: it re-throws a present defect's cause
+* (so a genuine bug still rides the defect channel at the boundary) and
+* narrows the result to `Ok | Err` for the caller, which can then branch on
+* `isErr` / `isOk` and reach `.value` / `.error` cleanly.
+*
+* @internal — exported under `_internal_assertNoDefect` for the sibling client
+* and worker packages. Not part of the public API.
+*/
+function _internal_assertNoDefect(result) {
+	if (result.isDefect()) throw result.cause;
 }
 //#endregion
-export { _internal_makeResultAsync };
+export { _internal_assertNoDefect, _internal_makeAsyncResult };
 
 //# sourceMappingURL=result-async.mjs.map

package/dist/result-async.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"result-async.mjs","names":[],"sources":["../src/result-async.ts"],"sourcesContent":["/**\n * Internal helper shared across `@temporal-contract/client` and\n * `@temporal-contract/worker` for wrapping a result-producing async function\n * in a `ResultAsync` while routing any unhandled rejection through a typed\n * mapper.\n *\n * Lives in `@temporal-contract/contract` so the two consuming packages don't\n * each carry their own copy. Exported from the package's public surface\n * under a deliberately-internal-looking name (`_internal_makeResultAsync`)\n * so users don't import it by accident — there is no semver guarantee on\n * this entry point.\n */\nimport { ResultAsync, type Result, err } from \"neverthrow\";\n\n/**\n * Wrap an async function returning `Promise<Result<T, E>>` in a\n * `ResultAsync<T, E>`, catching synchronous throws and rejected promises\n * and routing them through `mapRejection` so they surface as typed\n * `err(...)` instead of unhandled rejections.\n *\n * `new ResultAsync(promise)` does **not** catch rejections — the resulting\n * `ResultAsync` rejects, escaping neverthrow's railway. This helper closes\n * that gap. The work function is expected to handle its own domain errors\n * and return `err(...)` for them; `mapRejection` is a safety net for\n * thrown exceptions the work didn't anticipate.\n *\n * @internal — exported under `_internal_makeResultAsync` for use by the\n * sibling client and worker packages. Not part of the public API.\n */\nexport function _internal_makeResultAsync<T, E>(\n  work: () => Promise<Result<T, E>>,\n  mapRejection: (error: unknown) => E,\n): ResultAsync<T, E> {\n  let promise: Promise<Result<T, E>>;\n  try {\n    promise = work();\n  } catch (error) {\n    // Synchronous throw before the function returned its promise. Without\n    // this branch, `work()` blowing up synchronously would surface as a\n    // thrown error from the constructor call rather than an `err(...)`.\n    promise = Promise.resolve(err(mapRejection(error)));\n  }\n  return new ResultAsync<T, E>(promise.catch((e: unknown) => err(mapRejection(e))));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,0BACd,MACA,cACmB;CACnB,IAAI;CACJ,IAAI;EACF,UAAU,KAAK;CACjB,SAAS,OAAO;EAId,UAAU,QAAQ,QAAQ,IAAI,aAAa,KAAK,CAAC,CAAC;CACpD;CACA,OAAO,IAAI,YAAkB,QAAQ,OAAO,MAAe,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC;AAClF"}
+{"version":3,"file":"result-async.mjs","names":[],"sources":["../src/result-async.ts"],"sourcesContent":["/**\n * Internal helper shared across `@temporal-contract/client` and\n * `@temporal-contract/worker` for wrapping a result-producing async function\n * in an `AsyncResult`, routing any unanticipated rejection through unthrown's\n * `defect` channel.\n *\n * Lives in `@temporal-contract/contract` so the two consuming packages don't\n * each carry their own copy. Exported from the package's public surface\n * under a deliberately-internal-looking name (`_internal_makeAsyncResult`)\n * so users don't import it by accident — there is no semver guarantee on\n * this entry point.\n */\nimport {\n  fromSafePromise,\n  type AsyncResult,\n  type ErrView,\n  type OkView,\n  type Result,\n} from \"unthrown\";\n\n/**\n * Wrap an async function returning `Promise<Result<T, E>>` in an\n * `AsyncResult<T, E>`, catching synchronous throws and rejected promises and\n * routing them through unthrown's `defect` channel — so an *unanticipated*\n * failure surfaces as a defect (a bug, re-thrown at the edge) rather than an\n * unhandled rejection, while the work function's own domain `err(...)` flows\n * through untouched.\n *\n * `fromSafePromise(thunk)` invokes the thunk, capturing both a synchronous\n * throw before the promise is produced and an eventual rejection as a `defect`\n * (its error channel is `never`) — the work function is expected to model its\n * own domain errors as `err(...)`, so any *thrown* failure is by definition\n * unmodeled. The `.flatMap((inner) => inner)` flattens the nested\n * `Result<T, E>` the thunk resolves with, surfacing its modeled error channel.\n *\n * @internal — exported under `_internal_makeAsyncResult` for use by the\n * sibling client and worker packages. Not part of the public API.\n */\nexport function _internal_makeAsyncResult<T, E>(\n  work: () => Promise<Result<T, E>>,\n): AsyncResult<T, E> {\n  return fromSafePromise(work).flatMap((inner) => inner);\n}\n\n/**\n * Assert that a `Result` is not a `Defect`, narrowing it to `Ok | Err`.\n *\n * unthrown's `Result<T, E>` type always includes the out-of-band `Defect`\n * variant, so `if (r.isErr()) … else r.value` does not type-check — the `else`\n * branch is still `Ok | Defect`. For an internally-produced result that is\n * *known* to be built only from `ok(...)` / `err(...)`, this collapses the\n * \"impossible defect\" case in one call: it re-throws a present defect's cause\n * (so a genuine bug still rides the defect channel at the boundary) and\n * narrows the result to `Ok | Err` for the caller, which can then branch on\n * `isErr` / `isOk` and reach `.value` / `.error` cleanly.\n *\n * @internal — exported under `_internal_assertNoDefect` for the sibling client\n * and worker packages. Not part of the public API.\n */\nexport function _internal_assertNoDefect<T, E>(\n  result: Result<T, E>,\n): asserts result is OkView<T, E> | ErrView<E, T> {\n  if (result.isDefect()) {\n    throw result.cause;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,0BACd,MACmB;CACnB,OAAO,gBAAgB,IAAI,CAAC,CAAC,SAAS,UAAU,KAAK;AACvD;;;;;;;;;;;;;;;;AAiBA,SAAgB,yBACd,QACgD;CAChD,IAAI,OAAO,SAAS,GAClB,MAAM,OAAO;AAEjB"}

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@temporal-contract/contract",
-  "version": "2.3.1",
+  "version": "3.0.0",
   "description": "Contract builder for temporal-contract",
   "keywords": [
     "contract",
     "temporal",
     "typescript"
   ],
-  "homepage": "https://github.com/btravers/temporal-contract#readme",
+  "homepage": "https://github.com/btravstack/temporal-contract#readme",
   "bugs": {
-    "url": "https://github.com/btravers/temporal-contract/issues"
+    "url": "https://github.com/btravstack/temporal-contract/issues"
   },
   "license": "MIT",
   "author": "Benoit TRAVERS <benoit.travers.fr@gmail.com>",
   "repository": {
     "type": "git",
-    "url": "https://github.com/btravers/temporal-contract.git",
+    "url": "https://github.com/btravstack/temporal-contract.git",
     "directory": "packages/contract"
   },
   "files": [
@@ -53,26 +53,30 @@
     "zod": "4.4.3"
   },
   "devDependencies": {
+    "@unthrown/vitest": "0.2.0",
     "@vitest/coverage-v8": "4.1.8",
-    "arktype": "2.2.0",
-    "neverthrow": "8.2.0",
-    "tsdown": "0.22.2",
+    "arktype": "2.2.1",
+    "tsdown": "0.22.3",
     "typedoc": "0.28.19",
     "typedoc-plugin-markdown": "4.12.0",
     "typescript": "6.0.3",
+    "unthrown": "0.2.0",
     "valibot": "1.4.1",
     "vitest": "4.1.8",
     "@temporal-contract/tsconfig": "1.0.0",
     "@temporal-contract/typedoc": "0.1.0"
   },
   "peerDependencies": {
-    "neverthrow": "^8"
+    "unthrown": "^0.2"
   },
   "peerDependenciesMeta": {
-    "neverthrow": {
+    "unthrown": {
       "optional": true
     }
   },
+  "engines": {
+    "node": ">=22.19.0"
+  },
   "scripts": {
     "build": "tsdown src/index.ts src/result-async.ts --format cjs,esm --dts --clean",
     "build:docs": "typedoc",