@temporal-contract/worker 2.4.0 → 3.0.0

package/README.md

@@ -15,13 +15,13 @@ pnpm add @temporal-contract/worker @temporal-contract/contract @temporalio/workf
 ```typescript
 // activities.ts
 import { declareActivitiesHandler, ApplicationFailure } from "@temporal-contract/worker/activity";
-import { ResultAsync } from "neverthrow";
+import { fromPromise } from "unthrown";
 
 export const activities = declareActivitiesHandler({
   contract: myContract,
   activities: {
     sendEmail: ({ to, body }) =>
-      ResultAsync.fromPromise(emailService.send({ to, body }), (error) =>
+      fromPromise(emailService.send({ to, body }), (error) =>
         ApplicationFailure.create({
           type: "EMAIL_FAILED",
           message: error instanceof Error ? error.message : "Failed to send email",
@@ -65,7 +65,7 @@ run().catch(console.error);
 
 ### Child Workflows
 
-Execute child workflows with type-safe `ResultAsync`. Supports both same-contract and cross-contract child workflows:
+Execute child workflows with type-safe `AsyncResult`. Supports both same-contract and cross-contract child workflows:
 
 ```typescript
 // workflows.ts
@@ -158,11 +158,11 @@ typos surface as TypeScript errors rather than silently running with defaults.
 
 ## 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/worker)
-- [Worker Implementation Guide](https://btravers.github.io/temporal-contract/guide/worker-implementation)
-- [Examples](https://btravers.github.io/temporal-contract/examples/)
+- [API Reference](https://btravstack.github.io/temporal-contract/api/worker)
+- [Worker Implementation Guide](https://btravstack.github.io/temporal-contract/guide/worker-implementation)
+- [Examples](https://btravstack.github.io/temporal-contract/examples/)
 
 ## License
 

package/dist/activity.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_internal = require("./internal-o5vk6e1H.cjs");
+const require_internal = require("./internal-Clwokr1z.cjs");
 let _temporalio_common = require("@temporalio/common");
 //#region src/activity.ts
 /**
@@ -7,7 +7,7 @@ let _temporalio_common = require("@temporalio/common");
 *
 * This wraps all activity implementations with:
 * - Validation at network boundaries
-* - `ResultAsync<T, ApplicationFailure>` pattern for explicit error handling
+* - `AsyncResult<T, ApplicationFailure>` pattern for explicit error handling
 * - Automatic conversion from Result to Promise (throwing on Error)
 *
 * TypeScript ensures ALL activities (global + workflow-specific) are implemented.
@@ -17,15 +17,15 @@ let _temporalio_common = require("@temporalio/common");
 * @example
 * ```ts
 * import { declareActivitiesHandler, ApplicationFailure } from '@temporal-contract/worker/activity';
-* import { ResultAsync, errAsync, okAsync } from 'neverthrow';
+* import { fromPromise } from 'unthrown';
 * import myContract from './contract';
 *
 * export const activities = declareActivitiesHandler({
 *   contract: myContract,
 *   activities: {
-*     // Activity returns ResultAsync instead of throwing.
+*     // Activity returns AsyncResult instead of throwing.
 *     sendEmail: (args) =>
-*       ResultAsync.fromPromise(
+*       fromPromise(
 *         emailService.send(args),
 *         (error) =>
 *           // Wrap technical errors in ApplicationFailure. `nonRetryable`
@@ -53,10 +53,11 @@ let _temporalio_common = require("@temporalio/common");
 *
 * @remarks
 * The wrapper accepts implementations in the
-* `ResultAsync<T, ApplicationFailure>` shape and produces ordinary
+* `AsyncResult<T, ApplicationFailure>` shape and produces ordinary
 * Promise-returning Temporal handlers (`err(...)` → thrown
 * `ApplicationFailure`; `ok(...)` → output validated against the
-* contract and resolved). It does **not** hide Temporal's
+* contract and resolved; `defect` → original cause re-thrown). It does
+* **not** hide Temporal's
 * `@temporalio/activity` runtime: inside the body you can still call
 * `Context.current()` from `@temporalio/activity` to access heartbeats
 * (`heartbeat(details)`, `heartbeatDetails`), activity info (attempt
@@ -72,12 +73,19 @@ function declareActivitiesHandler(options) {
 			const input = require_internal.extractHandlerInput(args);
 			const inputResult = await activityDef.input["~standard"].validate(input);
 			if (inputResult.issues) throw new require_internal.ActivityInputValidationError(activityName, inputResult.issues);
-			const result = await activityImpl(inputResult.value);
-			if (result.isOk()) {
-				const outputResult = await activityDef.output["~standard"].validate(result.value);
-				if (outputResult.issues) throw new require_internal.ActivityOutputValidationError(activityName, outputResult.issues);
-				return outputResult.value;
-			} else throw result.error;
+			return (await activityImpl(inputResult.value)).match({
+				ok: async (value) => {
+					const outputResult = await activityDef.output["~standard"].validate(value);
+					if (outputResult.issues) throw new require_internal.ActivityOutputValidationError(activityName, outputResult.issues);
+					return outputResult.value;
+				},
+				err: (error) => {
+					throw error;
+				},
+				defect: (cause) => {
+					throw cause;
+				}
+			});
 		};
 	}
 	if (contract.activities) for (const [activityName, impl] of Object.entries(activities)) {

package/dist/activity.d.cts

@@ -1,19 +1,20 @@
-import { b as WorkerInferOutput, f as ValidationError, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError, y as WorkerInferInput } from "./errors-CE56feY1.cjs";
+import { f as ValidationError, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError, v as WorkerInferInput, y as WorkerInferOutput } from "./errors-BNnNzSwE.cjs";
 import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
-import { ResultAsync } from "neverthrow";
+import { AsyncResult } from "unthrown";
 import { ApplicationFailure, ApplicationFailure as ApplicationFailure$1 } from "@temporalio/common";
 
 //#region src/activity.d.ts
 /**
- * Activity implementation using neverthrow's `ResultAsync`.
+ * Activity implementation using unthrown's `AsyncResult`.
  *
- * Returns `ResultAsync<Output, ApplicationFailure>` for explicit error
+ * Returns `AsyncResult<Output, ApplicationFailure>` for explicit error
  * handling instead of throwing. The wrapper rethrows `err()` payloads at
  * the activity boundary; Temporal recognizes `ApplicationFailure` natively
  * and applies the configured retry policy (with `nonRetryable: true`
- * opting an instance out per-call).
+ * opting an instance out per-call). An unexpected throw surfaces as a
+ * `defect` and is re-thrown with its original cause.
  */
-type ResultActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => ResultAsync<WorkerInferOutput<TActivity>, ApplicationFailure$1>;
+type ResultActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => AsyncResult<WorkerInferOutput<TActivity>, ApplicationFailure$1>;
 /**
  * Map of all activity implementations for a contract (global + all workflow-specific).
  *
@@ -63,7 +64,7 @@ type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activ
  *
  * This wraps all activity implementations with:
  * - Validation at network boundaries
- * - `ResultAsync<T, ApplicationFailure>` pattern for explicit error handling
+ * - `AsyncResult<T, ApplicationFailure>` pattern for explicit error handling
  * - Automatic conversion from Result to Promise (throwing on Error)
  *
  * TypeScript ensures ALL activities (global + workflow-specific) are implemented.
@@ -73,15 +74,15 @@ type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activ
  * @example
  * ```ts
  * import { declareActivitiesHandler, ApplicationFailure } from '@temporal-contract/worker/activity';
- * import { ResultAsync, errAsync, okAsync } from 'neverthrow';
+ * import { fromPromise } from 'unthrown';
  * import myContract from './contract';
  *
  * export const activities = declareActivitiesHandler({
  *   contract: myContract,
  *   activities: {
- *     // Activity returns ResultAsync instead of throwing.
+ *     // Activity returns AsyncResult instead of throwing.
  *     sendEmail: (args) =>
- *       ResultAsync.fromPromise(
+ *       fromPromise(
  *         emailService.send(args),
  *         (error) =>
  *           // Wrap technical errors in ApplicationFailure. `nonRetryable`
@@ -109,10 +110,11 @@ type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activ
  *
  * @remarks
  * The wrapper accepts implementations in the
- * `ResultAsync<T, ApplicationFailure>` shape and produces ordinary
+ * `AsyncResult<T, ApplicationFailure>` shape and produces ordinary
  * Promise-returning Temporal handlers (`err(...)` → thrown
  * `ApplicationFailure`; `ok(...)` → output validated against the
- * contract and resolved). It does **not** hide Temporal's
+ * contract and resolved; `defect` → original cause re-thrown). It does
+ * **not** hide Temporal's
  * `@temporalio/activity` runtime: inside the body you can still call
  * `Context.current()` from `@temporalio/activity` to access heartbeats
  * (`heartbeat(details)`, `heartbeatDetails`), activity info (attempt

package/dist/activity.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"activity.d.cts","names":[],"sources":["../src/activity.ts"],"mappings":";;;;;;AAgCwD;;;;;;;;;AAAA,KAWnD,4BAAA,mBAA+C,kBAAA,KAClD,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,WAAA,CAAY,iBAAA,CAAkB,SAAA,GAAY,oBAAA;;;;;;;;;;;;;AAAkB;AAAA;;;;;;;;;;KAyB5D,uCAAA,mBAA0D,kBAAA,KAE5D,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,+BAAA,CAAgC,SAAA,8CAIZ,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,+BAAA,CAAgC,SAAA,cAAuB,SAAA;AAAA,KAI5D,+BAAA,qBAAoD,MAAA,SAAe,kBAAA,mBAC1D,WAAA,GAAc,4BAAA,CAA6B,WAAA,CAAY,CAAA;;;;KAMhE,+BAAA,mBAAkD,kBAAA;EACrD,QAAA,EAAU,SAAA;EACV,UAAA,EAAY,uCAAA,CAAwC,SAAA;AAAA;AAAA,KAGjD,sBAAA,mBAAyC,kBAAA,KAC5C,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,OAAA,CAAQ,iBAAA,CAAkB,SAAA;AAAA,KAE1B,yBAAA,qBAA8C,MAAA,SAAe,kBAAA,mBACpD,WAAA,GAAc,sBAAA,CAAuB,WAAA,CAAY,CAAA;AAAA,KAG1D,mBAAA,OAA0B,CAAA,oBAAqB,CAAA,EAAG,CAAC,6BACtD,CAAA,sBAEE,CAAA;;;;;;;;;KAWQ,iBAAA,mBAAoC,kBAAA,KAE7C,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,yBAAA,CAA0B,SAAA,wBAG5B,mBAAA,uBAEwB,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,yBAAA,CAA0B,SAAA,cAAuB,SAAA,8BAE/C,SAAA;;;;;;;;;;;;;;;;;;;AA/CwD;AAAA;;;;;;;;;;;;;;;;;AAQP;AAAA;;;;;;;;;;;;;;;;;;;;AAKvB;AAAA;;;;iBAmGxB,wBAAA,mBAA2C,kBAAA,EACzD,OAAA,EAAS,+BAAA,CAAgC,SAAA,IACxC,iBAAA,CAAkB,SAAA"}
+{"version":3,"file":"activity.d.cts","names":[],"sources":["../src/activity.ts"],"mappings":";;;;;;AAgCwD;;;;;;;;;;AAAA,KAYnD,4BAAA,mBAA+C,kBAAA,KAClD,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,WAAA,CAAY,iBAAA,CAAkB,SAAA,GAAY,oBAAA;;;;;;;;;;;;AAAkB;AAAA;;;;;;;;;;;KAyB5D,uCAAA,mBAA0D,kBAAA,KAE5D,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,+BAAA,CAAgC,SAAA,8CAIZ,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,+BAAA,CAAgC,SAAA,cAAuB,SAAA;AAAA,KAI5D,+BAAA,qBAAoD,MAAA,SAAe,kBAAA,mBAC1D,WAAA,GAAc,4BAAA,CAA6B,WAAA,CAAY,CAAA;;;;KAMhE,+BAAA,mBAAkD,kBAAA;EACrD,QAAA,EAAU,SAAA;EACV,UAAA,EAAY,uCAAA,CAAwC,SAAA;AAAA;AAAA,KAGjD,sBAAA,mBAAyC,kBAAA,KAC5C,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,OAAA,CAAQ,iBAAA,CAAkB,SAAA;AAAA,KAE1B,yBAAA,qBAA8C,MAAA,SAAe,kBAAA,mBACpD,WAAA,GAAc,sBAAA,CAAuB,WAAA,CAAY,CAAA;AAAA,KAG1D,mBAAA,OAA0B,CAAA,oBAAqB,CAAA,EAAG,CAAC,6BACtD,CAAA,sBAEE,CAAA;;;;;;;;AA3BsE;KAsC9D,iBAAA,mBAAoC,kBAAA,KAE7C,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,yBAAA,CAA0B,SAAA,wBAG5B,mBAAA,uBAEwB,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,yBAAA,CAA0B,SAAA,cAAuB,SAAA,8BAE/C,SAAA;;;;;;;;;;;;;;;;;;AA/CwD;AAAA;;;;;;;;;;;;;;;;;AAQP;AAAA;;;;;;;;;;;;;;;;;;;;AAKvB;AAAA;;;;;;iBAoGxB,wBAAA,mBAA2C,kBAAA,EACzD,OAAA,EAAS,+BAAA,CAAgC,SAAA,IACxC,iBAAA,CAAkB,SAAA"}

package/dist/activity.d.mts

@@ -1,19 +1,20 @@
-import { b as WorkerInferOutput, f as ValidationError, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError, y as WorkerInferInput } from "./errors-CE56feY1.mjs";
+import { f as ValidationError, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError, v as WorkerInferInput, y as WorkerInferOutput } from "./errors-BNnNzSwE.mjs";
 import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
 import { ApplicationFailure, ApplicationFailure as ApplicationFailure$1 } from "@temporalio/common";
-import { ResultAsync } from "neverthrow";
+import { AsyncResult } from "unthrown";
 
 //#region src/activity.d.ts
 /**
- * Activity implementation using neverthrow's `ResultAsync`.
+ * Activity implementation using unthrown's `AsyncResult`.
  *
- * Returns `ResultAsync<Output, ApplicationFailure>` for explicit error
+ * Returns `AsyncResult<Output, ApplicationFailure>` for explicit error
  * handling instead of throwing. The wrapper rethrows `err()` payloads at
  * the activity boundary; Temporal recognizes `ApplicationFailure` natively
  * and applies the configured retry policy (with `nonRetryable: true`
- * opting an instance out per-call).
+ * opting an instance out per-call). An unexpected throw surfaces as a
+ * `defect` and is re-thrown with its original cause.
  */
-type ResultActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => ResultAsync<WorkerInferOutput<TActivity>, ApplicationFailure$1>;
+type ResultActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => AsyncResult<WorkerInferOutput<TActivity>, ApplicationFailure$1>;
 /**
  * Map of all activity implementations for a contract (global + all workflow-specific).
  *
@@ -63,7 +64,7 @@ type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activ
  *
  * This wraps all activity implementations with:
  * - Validation at network boundaries
- * - `ResultAsync<T, ApplicationFailure>` pattern for explicit error handling
+ * - `AsyncResult<T, ApplicationFailure>` pattern for explicit error handling
  * - Automatic conversion from Result to Promise (throwing on Error)
  *
  * TypeScript ensures ALL activities (global + workflow-specific) are implemented.
@@ -73,15 +74,15 @@ type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activ
  * @example
  * ```ts
  * import { declareActivitiesHandler, ApplicationFailure } from '@temporal-contract/worker/activity';
- * import { ResultAsync, errAsync, okAsync } from 'neverthrow';
+ * import { fromPromise } from 'unthrown';
  * import myContract from './contract';
  *
  * export const activities = declareActivitiesHandler({
  *   contract: myContract,
  *   activities: {
- *     // Activity returns ResultAsync instead of throwing.
+ *     // Activity returns AsyncResult instead of throwing.
  *     sendEmail: (args) =>
- *       ResultAsync.fromPromise(
+ *       fromPromise(
  *         emailService.send(args),
  *         (error) =>
  *           // Wrap technical errors in ApplicationFailure. `nonRetryable`
@@ -109,10 +110,11 @@ type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activ
  *
  * @remarks
  * The wrapper accepts implementations in the
- * `ResultAsync<T, ApplicationFailure>` shape and produces ordinary
+ * `AsyncResult<T, ApplicationFailure>` shape and produces ordinary
  * Promise-returning Temporal handlers (`err(...)` → thrown
  * `ApplicationFailure`; `ok(...)` → output validated against the
- * contract and resolved). It does **not** hide Temporal's
+ * contract and resolved; `defect` → original cause re-thrown). It does
+ * **not** hide Temporal's
  * `@temporalio/activity` runtime: inside the body you can still call
  * `Context.current()` from `@temporalio/activity` to access heartbeats
  * (`heartbeat(details)`, `heartbeatDetails`), activity info (attempt

package/dist/activity.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"activity.d.mts","names":[],"sources":["../src/activity.ts"],"mappings":";;;;;;AAgCwD;;;;;;;;;AAAA,KAWnD,4BAAA,mBAA+C,kBAAA,KAClD,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,WAAA,CAAY,iBAAA,CAAkB,SAAA,GAAY,oBAAA;;;;;;;;;;;;;AAAkB;AAAA;;;;;;;;;;KAyB5D,uCAAA,mBAA0D,kBAAA,KAE5D,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,+BAAA,CAAgC,SAAA,8CAIZ,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,+BAAA,CAAgC,SAAA,cAAuB,SAAA;AAAA,KAI5D,+BAAA,qBAAoD,MAAA,SAAe,kBAAA,mBAC1D,WAAA,GAAc,4BAAA,CAA6B,WAAA,CAAY,CAAA;;;;KAMhE,+BAAA,mBAAkD,kBAAA;EACrD,QAAA,EAAU,SAAA;EACV,UAAA,EAAY,uCAAA,CAAwC,SAAA;AAAA;AAAA,KAGjD,sBAAA,mBAAyC,kBAAA,KAC5C,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,OAAA,CAAQ,iBAAA,CAAkB,SAAA;AAAA,KAE1B,yBAAA,qBAA8C,MAAA,SAAe,kBAAA,mBACpD,WAAA,GAAc,sBAAA,CAAuB,WAAA,CAAY,CAAA;AAAA,KAG1D,mBAAA,OAA0B,CAAA,oBAAqB,CAAA,EAAG,CAAC,6BACtD,CAAA,sBAEE,CAAA;;;;;;;;;KAWQ,iBAAA,mBAAoC,kBAAA,KAE7C,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,yBAAA,CAA0B,SAAA,wBAG5B,mBAAA,uBAEwB,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,yBAAA,CAA0B,SAAA,cAAuB,SAAA,8BAE/C,SAAA;;;;;;;;;;;;;;;;;;;AA/CwD;AAAA;;;;;;;;;;;;;;;;;AAQP;AAAA;;;;;;;;;;;;;;;;;;;;AAKvB;AAAA;;;;iBAmGxB,wBAAA,mBAA2C,kBAAA,EACzD,OAAA,EAAS,+BAAA,CAAgC,SAAA,IACxC,iBAAA,CAAkB,SAAA"}
+{"version":3,"file":"activity.d.mts","names":[],"sources":["../src/activity.ts"],"mappings":";;;;;;AAgCwD;;;;;;;;;;AAAA,KAYnD,4BAAA,mBAA+C,kBAAA,KAClD,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,WAAA,CAAY,iBAAA,CAAkB,SAAA,GAAY,oBAAA;;;;;;;;;;;;AAAkB;AAAA;;;;;;;;;;;KAyB5D,uCAAA,mBAA0D,kBAAA,KAE5D,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,+BAAA,CAAgC,SAAA,8CAIZ,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,+BAAA,CAAgC,SAAA,cAAuB,SAAA;AAAA,KAI5D,+BAAA,qBAAoD,MAAA,SAAe,kBAAA,mBAC1D,WAAA,GAAc,4BAAA,CAA6B,WAAA,CAAY,CAAA;;;;KAMhE,+BAAA,mBAAkD,kBAAA;EACrD,QAAA,EAAU,SAAA;EACV,UAAA,EAAY,uCAAA,CAAwC,SAAA;AAAA;AAAA,KAGjD,sBAAA,mBAAyC,kBAAA,KAC5C,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,OAAA,CAAQ,iBAAA,CAAkB,SAAA;AAAA,KAE1B,yBAAA,qBAA8C,MAAA,SAAe,kBAAA,mBACpD,WAAA,GAAc,sBAAA,CAAuB,WAAA,CAAY,CAAA;AAAA,KAG1D,mBAAA,OAA0B,CAAA,oBAAqB,CAAA,EAAG,CAAC,6BACtD,CAAA,sBAEE,CAAA;;;;;;;;AA3BsE;KAsC9D,iBAAA,mBAAoC,kBAAA,KAE7C,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,yBAAA,CAA0B,SAAA,wBAG5B,mBAAA,uBAEwB,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,yBAAA,CAA0B,SAAA,cAAuB,SAAA,8BAE/C,SAAA;;;;;;;;;;;;;;;;;;AA/CwD;AAAA;;;;;;;;;;;;;;;;;AAQP;AAAA;;;;;;;;;;;;;;;;;;;;AAKvB;AAAA;;;;;;iBAoGxB,wBAAA,mBAA2C,kBAAA,EACzD,OAAA,EAAS,+BAAA,CAAgC,SAAA,IACxC,iBAAA,CAAkB,SAAA"}

package/dist/activity.mjs

@@ -1,4 +1,4 @@
-import { c as ActivityInputValidationError, i as extractHandlerInput, l as ActivityOutputValidationError, s as ActivityDefinitionNotFoundError, v as ValidationError } from "./internal-D0wfFl0y.mjs";
+import { a as extractHandlerInput, c as ActivityDefinitionNotFoundError, l as ActivityInputValidationError, u as ActivityOutputValidationError, y as ValidationError } from "./internal-DqYK4YQK.mjs";
 import { ApplicationFailure } from "@temporalio/common";
 //#region src/activity.ts
 /**
@@ -6,7 +6,7 @@ import { ApplicationFailure } from "@temporalio/common";
 *
 * This wraps all activity implementations with:
 * - Validation at network boundaries
-* - `ResultAsync<T, ApplicationFailure>` pattern for explicit error handling
+* - `AsyncResult<T, ApplicationFailure>` pattern for explicit error handling
 * - Automatic conversion from Result to Promise (throwing on Error)
 *
 * TypeScript ensures ALL activities (global + workflow-specific) are implemented.
@@ -16,15 +16,15 @@ import { ApplicationFailure } from "@temporalio/common";
 * @example
 * ```ts
 * import { declareActivitiesHandler, ApplicationFailure } from '@temporal-contract/worker/activity';
-* import { ResultAsync, errAsync, okAsync } from 'neverthrow';
+* import { fromPromise } from 'unthrown';
 * import myContract from './contract';
 *
 * export const activities = declareActivitiesHandler({
 *   contract: myContract,
 *   activities: {
-*     // Activity returns ResultAsync instead of throwing.
+*     // Activity returns AsyncResult instead of throwing.
 *     sendEmail: (args) =>
-*       ResultAsync.fromPromise(
+*       fromPromise(
 *         emailService.send(args),
 *         (error) =>
 *           // Wrap technical errors in ApplicationFailure. `nonRetryable`
@@ -52,10 +52,11 @@ import { ApplicationFailure } from "@temporalio/common";
 *
 * @remarks
 * The wrapper accepts implementations in the
-* `ResultAsync<T, ApplicationFailure>` shape and produces ordinary
+* `AsyncResult<T, ApplicationFailure>` shape and produces ordinary
 * Promise-returning Temporal handlers (`err(...)` → thrown
 * `ApplicationFailure`; `ok(...)` → output validated against the
-* contract and resolved). It does **not** hide Temporal's
+* contract and resolved; `defect` → original cause re-thrown). It does
+* **not** hide Temporal's
 * `@temporalio/activity` runtime: inside the body you can still call
 * `Context.current()` from `@temporalio/activity` to access heartbeats
 * (`heartbeat(details)`, `heartbeatDetails`), activity info (attempt
@@ -71,12 +72,19 @@ function declareActivitiesHandler(options) {
 			const input = extractHandlerInput(args);
 			const inputResult = await activityDef.input["~standard"].validate(input);
 			if (inputResult.issues) throw new ActivityInputValidationError(activityName, inputResult.issues);
-			const result = await activityImpl(inputResult.value);
-			if (result.isOk()) {
-				const outputResult = await activityDef.output["~standard"].validate(result.value);
-				if (outputResult.issues) throw new ActivityOutputValidationError(activityName, outputResult.issues);
-				return outputResult.value;
-			} else throw result.error;
+			return (await activityImpl(inputResult.value)).match({
+				ok: async (value) => {
+					const outputResult = await activityDef.output["~standard"].validate(value);
+					if (outputResult.issues) throw new ActivityOutputValidationError(activityName, outputResult.issues);
+					return outputResult.value;
+				},
+				err: (error) => {
+					throw error;
+				},
+				defect: (cause) => {
+					throw cause;
+				}
+			});
 		};
 	}
 	if (contract.activities) for (const [activityName, impl] of Object.entries(activities)) {

package/dist/activity.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"activity.mjs","names":[],"sources":["../src/activity.ts"],"sourcesContent":["// Entry point for activity implementations.\n//\n// Activities run *outside* the workflow sandbox, so they use neverthrow's\n// `ResultAsync` directly. Workflow code (see workflow.ts) uses the same\n// neverthrow API — neverthrow's evaluation is compatible with Temporal's\n// deterministic replay machinery.\n//\n// Errors flow through Temporal's `ApplicationFailure` (re-exported from\n// `@temporalio/common`) — it's the SDK's first-class failure shape, so we\n// don't wrap it in a custom class. `ApplicationFailure` exposes\n// `nonRetryable`, `type`, `details`, and `category` natively, and survives\n// the activity → workflow serialization boundary unchanged.\nimport { ActivityDefinition, ContractDefinition } from \"@temporal-contract/contract\";\nimport type { ResultAsync } from \"neverthrow\";\nimport { ApplicationFailure } from \"@temporalio/common\";\nimport { WorkerInferInput, WorkerInferOutput } from \"./types.js\";\nimport {\n  ActivityDefinitionNotFoundError,\n  ActivityInputValidationError,\n  ActivityOutputValidationError,\n} from \"./errors.js\";\nimport { extractHandlerInput } from \"./internal.js\";\n\nexport {\n  ActivityDefinitionNotFoundError,\n  ActivityInputValidationError,\n  ActivityOutputValidationError,\n  ValidationError,\n} from \"./errors.js\";\n\n// Re-export the canonical activity-failure class so consumers don't need\n// a separate `@temporalio/common` import to construct one.\nexport { ApplicationFailure } from \"@temporalio/common\";\n\n/**\n * Activity implementation using neverthrow's `ResultAsync`.\n *\n * Returns `ResultAsync<Output, ApplicationFailure>` for explicit error\n * handling instead of throwing. The wrapper rethrows `err()` payloads at\n * the activity boundary; Temporal recognizes `ApplicationFailure` natively\n * and applies the configured retry policy (with `nonRetryable: true`\n * opting an instance out per-call).\n */\ntype ResultActivityImplementation<TActivity extends ActivityDefinition> = (\n  args: WorkerInferInput<TActivity>,\n) => ResultAsync<WorkerInferOutput<TActivity>, ApplicationFailure>;\n\n/**\n * Map of all activity implementations for a contract (global + all workflow-specific).\n *\n * **Shape note — input is nested by workflow, output is flat.** This\n * asymmetry is deliberate:\n *\n * - The implementation map you write **mirrors the contract's structure**:\n *   global activities sit at the root, workflow-local activities nest\n *   under their owning workflow's name. Mirroring the contract gives\n *   IDE autocomplete that matches `defineContract`, prevents typos that\n *   put a workflow-local activity at the global level, and makes\n *   ownership visible at definition time.\n * - The handler returned by {@link declareActivitiesHandler} (see\n *   {@link ActivitiesHandler}) is **flat** because Temporal's worker\n *   sees a single activity namespace at runtime —\n *   `proxyActivities<...>()` resolves names from one map regardless of\n *   which workflow consumes them. `defineContract` enforces no name\n *   collisions across global + workflow-local scopes, so the flat\n *   output has no ambiguity to resolve.\n *\n * In short: write nested (mirror the contract); the wrapper flattens\n * for Temporal.\n */\ntype ContractResultActivitiesImplementations<TContract extends ContractDefinition> =\n  // Global activities\n  (TContract[\"activities\"] extends Record<string, ActivityDefinition>\n    ? ResultActivitiesImplementations<TContract[\"activities\"]>\n    : {}) &\n    // All workflow-specific activities merged\n    {\n      [TWorkflow in keyof TContract[\"workflows\"]]: TContract[\"workflows\"][TWorkflow][\"activities\"] extends Record<\n        string,\n        ActivityDefinition\n      >\n        ? ResultActivitiesImplementations<TContract[\"workflows\"][TWorkflow][\"activities\"]>\n        : {};\n    };\n\ntype ResultActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = {\n  [K in keyof TActivities]: ResultActivityImplementation<TActivities[K]>;\n};\n\n/**\n * Options for creating activities handler\n */\ntype DeclareActivitiesHandlerOptions<TContract extends ContractDefinition> = {\n  contract: TContract;\n  activities: ContractResultActivitiesImplementations<TContract>;\n};\n\ntype ActivityImplementation<TActivity extends ActivityDefinition> = (\n  args: WorkerInferInput<TActivity>,\n) => Promise<WorkerInferOutput<TActivity>>;\n\ntype ActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = {\n  [K in keyof TActivities]: ActivityImplementation<TActivities[K]>;\n};\n\ntype UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (\n  k: infer I,\n) => void\n  ? I\n  : never;\n\n/**\n * Activities handler ready for Temporal's `Worker.create({ activities })`.\n *\n * Flat shape: every activity (global + all workflow-local) lives at the\n * root of the returned map. See the doc comment on\n * {@link ContractResultActivitiesImplementations} for why the input you\n * write is nested by workflow while this output is flat.\n */\nexport type ActivitiesHandler<TContract extends ContractDefinition> =\n  // Global activities\n  (TContract[\"activities\"] extends Record<string, ActivityDefinition>\n    ? ActivitiesImplementations<TContract[\"activities\"]>\n    : {}) &\n    // All workflow-specific activities merged at root level (flat)\n    UnionToIntersection<\n      {\n        [TWorkflow in keyof TContract[\"workflows\"]]: TContract[\"workflows\"][TWorkflow][\"activities\"] extends Record<\n          string,\n          ActivityDefinition\n        >\n          ? ActivitiesImplementations<TContract[\"workflows\"][TWorkflow][\"activities\"]>\n          : {};\n      }[keyof TContract[\"workflows\"]]\n    >;\n\n/**\n * Create a typed activities handler with automatic validation and Result pattern.\n *\n * This wraps all activity implementations with:\n * - Validation at network boundaries\n * - `ResultAsync<T, ApplicationFailure>` pattern for explicit error handling\n * - Automatic conversion from Result to Promise (throwing on Error)\n *\n * TypeScript ensures ALL activities (global + workflow-specific) are implemented.\n *\n * Use this to create the activities object for the Temporal Worker.\n *\n * @example\n * ```ts\n * import { declareActivitiesHandler, ApplicationFailure } from '@temporal-contract/worker/activity';\n * import { ResultAsync, errAsync, okAsync } from 'neverthrow';\n * import myContract from './contract';\n *\n * export const activities = declareActivitiesHandler({\n *   contract: myContract,\n *   activities: {\n *     // Activity returns ResultAsync instead of throwing.\n *     sendEmail: (args) =>\n *       ResultAsync.fromPromise(\n *         emailService.send(args),\n *         (error) =>\n *           // Wrap technical errors in ApplicationFailure. `nonRetryable`\n *           // is per-instance: set it to true on permanent failures so\n *           // Temporal stops retrying immediately.\n *           ApplicationFailure.create({\n *             type: 'EMAIL_SEND_FAILED',\n *             message: 'Failed to send email',\n *             nonRetryable: false,\n *             cause: error instanceof Error ? error : undefined,\n *           }),\n *       ).map(() => ({ sent: true })),\n *   },\n * });\n *\n * // Use with Temporal Worker\n * import { Worker } from '@temporalio/worker';\n *\n * const worker = await Worker.create({\n *   workflowsPath: require.resolve('./workflows'),\n *   activities: activities,\n *   taskQueue: contract.taskQueue,\n * });\n * ```\n *\n * @remarks\n * The wrapper accepts implementations in the\n * `ResultAsync<T, ApplicationFailure>` shape and produces ordinary\n * Promise-returning Temporal handlers (`err(...)` → thrown\n * `ApplicationFailure`; `ok(...)` → output validated against the\n * contract and resolved). It does **not** hide Temporal's\n * `@temporalio/activity` runtime: inside the body you can still call\n * `Context.current()` from `@temporalio/activity` to access heartbeats\n * (`heartbeat(details)`, `heartbeatDetails`), activity info (attempt\n * number, workflow IDs), and the async-completion task token. See the\n * \"Working with the Activity Context\" section of the worker\n * implementation guide for end-to-end examples.\n */\nexport function declareActivitiesHandler<TContract extends ContractDefinition>(\n  options: DeclareActivitiesHandlerOptions<TContract>,\n): ActivitiesHandler<TContract> {\n  const { contract, activities } = options;\n\n  // Prepare Temporal-compatible activities with validation and Result unwrapping\n  const wrappedActivities = {} as ActivitiesHandler<TContract>;\n\n  // Helper to create a wrapped implementation from a definition and impl\n  function makeWrapped(\n    activityName: string,\n    activityDef: ActivityDefinition,\n    activityImpl: (args: unknown) => ResultAsync<unknown, ApplicationFailure>,\n  ) {\n    return async (...args: unknown[]) => {\n      const input = extractHandlerInput(args);\n\n      // Validate input\n      const inputResult = await activityDef.input[\"~standard\"].validate(input);\n      if (inputResult.issues) {\n        throw new ActivityInputValidationError(activityName, inputResult.issues);\n      }\n\n      // Execute neverthrow activity (returns ResultAsync<T, ApplicationFailure>);\n      // awaiting yields a Result<T, ApplicationFailure>.\n      const result = await activityImpl(inputResult.value);\n\n      // Process result: validate output or throw error\n      if (result.isOk()) {\n        // Validate output on success\n        const outputResult = await activityDef.output[\"~standard\"].validate(result.value);\n        if (outputResult.issues) {\n          throw new ActivityOutputValidationError(activityName, outputResult.issues);\n        }\n        return outputResult.value;\n      } else {\n        // Convert err(...) payload to thrown ApplicationFailure for Temporal.\n        // Temporal recognizes this class natively and applies the\n        // configured retry policy (honoring `nonRetryable: true`).\n        throw result.error;\n      }\n    };\n  }\n\n  // 1) Wrap global activities defined directly under contract.activities\n  if (contract.activities) {\n    for (const [activityName, impl] of Object.entries(activities)) {\n      // Skip workflow namespaces if present at root\n      if (contract.workflows && activityName in contract.workflows) {\n        continue;\n      }\n\n      const activityDef = contract.activities[activityName];\n      if (!activityDef) {\n        throw new ActivityDefinitionNotFoundError(activityName, Object.keys(contract.activities));\n      }\n\n      // Assign wrapped global activity\n      (wrappedActivities as Record<string, unknown>)[activityName] = makeWrapped(\n        activityName,\n        activityDef,\n        impl as (args: unknown) => ResultAsync<unknown, ApplicationFailure>,\n      );\n    }\n  }\n\n  // 2) Wrap workflow-scoped activities at root level (flat)\n  if (contract.workflows) {\n    for (const [workflowName, workflowDef] of Object.entries(contract.workflows)) {\n      const wfActivitiesImpl = (activities as Record<string, unknown>)[workflowName] as\n        | Record<string, unknown>\n        | undefined;\n      if (!wfActivitiesImpl) {\n        // If no implementations provided for this workflow, skip (TypeScript typing should enforce completeness for declared ones)\n        continue;\n      }\n\n      const wfDefs = workflowDef.activities ?? {};\n\n      for (const [activityName, impl] of Object.entries(wfActivitiesImpl)) {\n        const activityDef = wfDefs[activityName];\n        if (!activityDef) {\n          throw new ActivityDefinitionNotFoundError(\n            `${workflowName}.${activityName}`,\n            Object.keys(wfDefs),\n          );\n        }\n\n        // Assign workflow activity directly at root level (flat structure)\n        (wrappedActivities as Record<string, unknown>)[activityName] = makeWrapped(\n          `${workflowName}.${activityName}`,\n          activityDef,\n          impl as (args: unknown) => ResultAsync<unknown, ApplicationFailure>,\n        );\n      }\n    }\n  }\n\n  return wrappedActivities;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsMA,SAAgB,yBACd,SAC8B;CAC9B,MAAM,EAAE,UAAU,eAAe;CAGjC,MAAM,oBAAoB,CAAC;CAG3B,SAAS,YACP,cACA,aACA,cACA;EACA,OAAO,OAAO,GAAG,SAAoB;GACnC,MAAM,QAAQ,oBAAoB,IAAI;GAGtC,MAAM,cAAc,MAAM,YAAY,MAAM,YAAY,CAAC,SAAS,KAAK;GACvE,IAAI,YAAY,QACd,MAAM,IAAI,6BAA6B,cAAc,YAAY,MAAM;GAKzE,MAAM,SAAS,MAAM,aAAa,YAAY,KAAK;GAGnD,IAAI,OAAO,KAAK,GAAG;IAEjB,MAAM,eAAe,MAAM,YAAY,OAAO,YAAY,CAAC,SAAS,OAAO,KAAK;IAChF,IAAI,aAAa,QACf,MAAM,IAAI,8BAA8B,cAAc,aAAa,MAAM;IAE3E,OAAO,aAAa;GACtB,OAIE,MAAM,OAAO;EAEjB;CACF;CAGA,IAAI,SAAS,YACX,KAAK,MAAM,CAAC,cAAc,SAAS,OAAO,QAAQ,UAAU,GAAG;EAE7D,IAAI,SAAS,aAAa,gBAAgB,SAAS,WACjD;EAGF,MAAM,cAAc,SAAS,WAAW;EACxC,IAAI,CAAC,aACH,MAAM,IAAI,gCAAgC,cAAc,OAAO,KAAK,SAAS,UAAU,CAAC;EAI1F,kBAA+C,gBAAgB,YAC7D,cACA,aACA,IACF;CACF;CAIF,IAAI,SAAS,WACX,KAAK,MAAM,CAAC,cAAc,gBAAgB,OAAO,QAAQ,SAAS,SAAS,GAAG;EAC5E,MAAM,mBAAoB,WAAuC;EAGjE,IAAI,CAAC,kBAEH;EAGF,MAAM,SAAS,YAAY,cAAc,CAAC;EAE1C,KAAK,MAAM,CAAC,cAAc,SAAS,OAAO,QAAQ,gBAAgB,GAAG;GACnE,MAAM,cAAc,OAAO;GAC3B,IAAI,CAAC,aACH,MAAM,IAAI,gCACR,GAAG,aAAa,GAAG,gBACnB,OAAO,KAAK,MAAM,CACpB;GAIF,kBAA+C,gBAAgB,YAC7D,GAAG,aAAa,GAAG,gBACnB,aACA,IACF;EACF;CACF;CAGF,OAAO;AACT"}
+{"version":3,"file":"activity.mjs","names":[],"sources":["../src/activity.ts"],"sourcesContent":["// Entry point for activity implementations.\n//\n// Activities run *outside* the workflow sandbox, so they use unthrown's\n// `AsyncResult` directly. Workflow code (see workflow.ts) uses the same\n// unthrown API — unthrown's evaluation is compatible with Temporal's\n// deterministic replay machinery.\n//\n// Errors flow through Temporal's `ApplicationFailure` (re-exported from\n// `@temporalio/common`) — it's the SDK's first-class failure shape, so we\n// don't wrap it in a custom class. `ApplicationFailure` exposes\n// `nonRetryable`, `type`, `details`, and `category` natively, and survives\n// the activity → workflow serialization boundary unchanged.\nimport { ActivityDefinition, ContractDefinition } from \"@temporal-contract/contract\";\nimport type { AsyncResult } from \"unthrown\";\nimport { ApplicationFailure } from \"@temporalio/common\";\nimport { WorkerInferInput, WorkerInferOutput } from \"./types.js\";\nimport {\n  ActivityDefinitionNotFoundError,\n  ActivityInputValidationError,\n  ActivityOutputValidationError,\n} from \"./errors.js\";\nimport { extractHandlerInput } from \"./internal.js\";\n\nexport {\n  ActivityDefinitionNotFoundError,\n  ActivityInputValidationError,\n  ActivityOutputValidationError,\n  ValidationError,\n} from \"./errors.js\";\n\n// Re-export the canonical activity-failure class so consumers don't need\n// a separate `@temporalio/common` import to construct one.\nexport { ApplicationFailure } from \"@temporalio/common\";\n\n/**\n * Activity implementation using unthrown's `AsyncResult`.\n *\n * Returns `AsyncResult<Output, ApplicationFailure>` for explicit error\n * handling instead of throwing. The wrapper rethrows `err()` payloads at\n * the activity boundary; Temporal recognizes `ApplicationFailure` natively\n * and applies the configured retry policy (with `nonRetryable: true`\n * opting an instance out per-call). An unexpected throw surfaces as a\n * `defect` and is re-thrown with its original cause.\n */\ntype ResultActivityImplementation<TActivity extends ActivityDefinition> = (\n  args: WorkerInferInput<TActivity>,\n) => AsyncResult<WorkerInferOutput<TActivity>, ApplicationFailure>;\n\n/**\n * Map of all activity implementations for a contract (global + all workflow-specific).\n *\n * **Shape note — input is nested by workflow, output is flat.** This\n * asymmetry is deliberate:\n *\n * - The implementation map you write **mirrors the contract's structure**:\n *   global activities sit at the root, workflow-local activities nest\n *   under their owning workflow's name. Mirroring the contract gives\n *   IDE autocomplete that matches `defineContract`, prevents typos that\n *   put a workflow-local activity at the global level, and makes\n *   ownership visible at definition time.\n * - The handler returned by {@link declareActivitiesHandler} (see\n *   {@link ActivitiesHandler}) is **flat** because Temporal's worker\n *   sees a single activity namespace at runtime —\n *   `proxyActivities<...>()` resolves names from one map regardless of\n *   which workflow consumes them. `defineContract` enforces no name\n *   collisions across global + workflow-local scopes, so the flat\n *   output has no ambiguity to resolve.\n *\n * In short: write nested (mirror the contract); the wrapper flattens\n * for Temporal.\n */\ntype ContractResultActivitiesImplementations<TContract extends ContractDefinition> =\n  // Global activities\n  (TContract[\"activities\"] extends Record<string, ActivityDefinition>\n    ? ResultActivitiesImplementations<TContract[\"activities\"]>\n    : {}) &\n    // All workflow-specific activities merged\n    {\n      [TWorkflow in keyof TContract[\"workflows\"]]: TContract[\"workflows\"][TWorkflow][\"activities\"] extends Record<\n        string,\n        ActivityDefinition\n      >\n        ? ResultActivitiesImplementations<TContract[\"workflows\"][TWorkflow][\"activities\"]>\n        : {};\n    };\n\ntype ResultActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = {\n  [K in keyof TActivities]: ResultActivityImplementation<TActivities[K]>;\n};\n\n/**\n * Options for creating activities handler\n */\ntype DeclareActivitiesHandlerOptions<TContract extends ContractDefinition> = {\n  contract: TContract;\n  activities: ContractResultActivitiesImplementations<TContract>;\n};\n\ntype ActivityImplementation<TActivity extends ActivityDefinition> = (\n  args: WorkerInferInput<TActivity>,\n) => Promise<WorkerInferOutput<TActivity>>;\n\ntype ActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = {\n  [K in keyof TActivities]: ActivityImplementation<TActivities[K]>;\n};\n\ntype UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (\n  k: infer I,\n) => void\n  ? I\n  : never;\n\n/**\n * Activities handler ready for Temporal's `Worker.create({ activities })`.\n *\n * Flat shape: every activity (global + all workflow-local) lives at the\n * root of the returned map. See the doc comment on\n * {@link ContractResultActivitiesImplementations} for why the input you\n * write is nested by workflow while this output is flat.\n */\nexport type ActivitiesHandler<TContract extends ContractDefinition> =\n  // Global activities\n  (TContract[\"activities\"] extends Record<string, ActivityDefinition>\n    ? ActivitiesImplementations<TContract[\"activities\"]>\n    : {}) &\n    // All workflow-specific activities merged at root level (flat)\n    UnionToIntersection<\n      {\n        [TWorkflow in keyof TContract[\"workflows\"]]: TContract[\"workflows\"][TWorkflow][\"activities\"] extends Record<\n          string,\n          ActivityDefinition\n        >\n          ? ActivitiesImplementations<TContract[\"workflows\"][TWorkflow][\"activities\"]>\n          : {};\n      }[keyof TContract[\"workflows\"]]\n    >;\n\n/**\n * Create a typed activities handler with automatic validation and Result pattern.\n *\n * This wraps all activity implementations with:\n * - Validation at network boundaries\n * - `AsyncResult<T, ApplicationFailure>` pattern for explicit error handling\n * - Automatic conversion from Result to Promise (throwing on Error)\n *\n * TypeScript ensures ALL activities (global + workflow-specific) are implemented.\n *\n * Use this to create the activities object for the Temporal Worker.\n *\n * @example\n * ```ts\n * import { declareActivitiesHandler, ApplicationFailure } from '@temporal-contract/worker/activity';\n * import { fromPromise } from 'unthrown';\n * import myContract from './contract';\n *\n * export const activities = declareActivitiesHandler({\n *   contract: myContract,\n *   activities: {\n *     // Activity returns AsyncResult instead of throwing.\n *     sendEmail: (args) =>\n *       fromPromise(\n *         emailService.send(args),\n *         (error) =>\n *           // Wrap technical errors in ApplicationFailure. `nonRetryable`\n *           // is per-instance: set it to true on permanent failures so\n *           // Temporal stops retrying immediately.\n *           ApplicationFailure.create({\n *             type: 'EMAIL_SEND_FAILED',\n *             message: 'Failed to send email',\n *             nonRetryable: false,\n *             cause: error instanceof Error ? error : undefined,\n *           }),\n *       ).map(() => ({ sent: true })),\n *   },\n * });\n *\n * // Use with Temporal Worker\n * import { Worker } from '@temporalio/worker';\n *\n * const worker = await Worker.create({\n *   workflowsPath: require.resolve('./workflows'),\n *   activities: activities,\n *   taskQueue: contract.taskQueue,\n * });\n * ```\n *\n * @remarks\n * The wrapper accepts implementations in the\n * `AsyncResult<T, ApplicationFailure>` shape and produces ordinary\n * Promise-returning Temporal handlers (`err(...)` → thrown\n * `ApplicationFailure`; `ok(...)` → output validated against the\n * contract and resolved; `defect` → original cause re-thrown). It does\n * **not** hide Temporal's\n * `@temporalio/activity` runtime: inside the body you can still call\n * `Context.current()` from `@temporalio/activity` to access heartbeats\n * (`heartbeat(details)`, `heartbeatDetails`), activity info (attempt\n * number, workflow IDs), and the async-completion task token. See the\n * \"Working with the Activity Context\" section of the worker\n * implementation guide for end-to-end examples.\n */\nexport function declareActivitiesHandler<TContract extends ContractDefinition>(\n  options: DeclareActivitiesHandlerOptions<TContract>,\n): ActivitiesHandler<TContract> {\n  const { contract, activities } = options;\n\n  // Prepare Temporal-compatible activities with validation and Result unwrapping\n  const wrappedActivities = {} as ActivitiesHandler<TContract>;\n\n  // Helper to create a wrapped implementation from a definition and impl\n  function makeWrapped(\n    activityName: string,\n    activityDef: ActivityDefinition,\n    activityImpl: (args: unknown) => AsyncResult<unknown, ApplicationFailure>,\n  ) {\n    return async (...args: unknown[]) => {\n      const input = extractHandlerInput(args);\n\n      // Validate input\n      const inputResult = await activityDef.input[\"~standard\"].validate(input);\n      if (inputResult.issues) {\n        throw new ActivityInputValidationError(activityName, inputResult.issues);\n      }\n\n      // Execute unthrown activity (returns AsyncResult<T, ApplicationFailure>);\n      // awaiting yields a Result<T, ApplicationFailure>.\n      const result = await activityImpl(inputResult.value);\n\n      // Fold the three channels: validate output on `ok`, surface the modeled\n      // `ApplicationFailure` on `err`, and re-throw a `defect`'s original cause\n      // (an unexpected throw inside the activity is a bug, not a domain error).\n      return result.match({\n        ok: async (value) => {\n          const outputResult = await activityDef.output[\"~standard\"].validate(value);\n          if (outputResult.issues) {\n            throw new ActivityOutputValidationError(activityName, outputResult.issues);\n          }\n          return outputResult.value;\n        },\n        // Convert err(...) payload to thrown ApplicationFailure for Temporal.\n        // Temporal recognizes this class natively and applies the configured\n        // retry policy (honoring `nonRetryable: true`).\n        err: (error) => {\n          throw error;\n        },\n        // A defect is an *unanticipated* throw inside the activity. Re-throw the\n        // original cause unwrapped: Temporal wraps a non-`ApplicationFailure`\n        // error as `ApplicationFailure(type: \"Error\")` and applies the default\n        // (retryable) policy — preserving the pre-unthrown behaviour where an\n        // uncaught activity throw was simply retried. We deliberately do NOT\n        // coerce it to `nonRetryable`: not every unexpected throw is permanent\n        // (a transient I/O fault is also \"unmodeled\"), and forcing fail-fast\n        // here would silently change retry semantics. An activity that wants a\n        // permanent failure should return `err(ApplicationFailure.create({\n        // nonRetryable: true }))` explicitly.\n        defect: (cause) => {\n          throw cause;\n        },\n      });\n    };\n  }\n\n  // 1) Wrap global activities defined directly under contract.activities\n  if (contract.activities) {\n    for (const [activityName, impl] of Object.entries(activities)) {\n      // Skip workflow namespaces if present at root\n      if (contract.workflows && activityName in contract.workflows) {\n        continue;\n      }\n\n      const activityDef = contract.activities[activityName];\n      if (!activityDef) {\n        throw new ActivityDefinitionNotFoundError(activityName, Object.keys(contract.activities));\n      }\n\n      // Assign wrapped global activity\n      (wrappedActivities as Record<string, unknown>)[activityName] = makeWrapped(\n        activityName,\n        activityDef,\n        impl as (args: unknown) => AsyncResult<unknown, ApplicationFailure>,\n      );\n    }\n  }\n\n  // 2) Wrap workflow-scoped activities at root level (flat)\n  if (contract.workflows) {\n    for (const [workflowName, workflowDef] of Object.entries(contract.workflows)) {\n      const wfActivitiesImpl = (activities as Record<string, unknown>)[workflowName] as\n        | Record<string, unknown>\n        | undefined;\n      if (!wfActivitiesImpl) {\n        // If no implementations provided for this workflow, skip (TypeScript typing should enforce completeness for declared ones)\n        continue;\n      }\n\n      const wfDefs = workflowDef.activities ?? {};\n\n      for (const [activityName, impl] of Object.entries(wfActivitiesImpl)) {\n        const activityDef = wfDefs[activityName];\n        if (!activityDef) {\n          throw new ActivityDefinitionNotFoundError(\n            `${workflowName}.${activityName}`,\n            Object.keys(wfDefs),\n          );\n        }\n\n        // Assign workflow activity directly at root level (flat structure)\n        (wrappedActivities as Record<string, unknown>)[activityName] = makeWrapped(\n          `${workflowName}.${activityName}`,\n          activityDef,\n          impl as (args: unknown) => AsyncResult<unknown, ApplicationFailure>,\n        );\n      }\n    }\n  }\n\n  return wrappedActivities;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwMA,SAAgB,yBACd,SAC8B;CAC9B,MAAM,EAAE,UAAU,eAAe;CAGjC,MAAM,oBAAoB,CAAC;CAG3B,SAAS,YACP,cACA,aACA,cACA;EACA,OAAO,OAAO,GAAG,SAAoB;GACnC,MAAM,QAAQ,oBAAoB,IAAI;GAGtC,MAAM,cAAc,MAAM,YAAY,MAAM,YAAY,CAAC,SAAS,KAAK;GACvE,IAAI,YAAY,QACd,MAAM,IAAI,6BAA6B,cAAc,YAAY,MAAM;GAUzE,QAAO,MALc,aAAa,YAAY,KAAK,EAAA,CAKrC,MAAM;IAClB,IAAI,OAAO,UAAU;KACnB,MAAM,eAAe,MAAM,YAAY,OAAO,YAAY,CAAC,SAAS,KAAK;KACzE,IAAI,aAAa,QACf,MAAM,IAAI,8BAA8B,cAAc,aAAa,MAAM;KAE3E,OAAO,aAAa;IACtB;IAIA,MAAM,UAAU;KACd,MAAM;IACR;IAWA,SAAS,UAAU;KACjB,MAAM;IACR;GACF,CAAC;EACH;CACF;CAGA,IAAI,SAAS,YACX,KAAK,MAAM,CAAC,cAAc,SAAS,OAAO,QAAQ,UAAU,GAAG;EAE7D,IAAI,SAAS,aAAa,gBAAgB,SAAS,WACjD;EAGF,MAAM,cAAc,SAAS,WAAW;EACxC,IAAI,CAAC,aACH,MAAM,IAAI,gCAAgC,cAAc,OAAO,KAAK,SAAS,UAAU,CAAC;EAI1F,kBAA+C,gBAAgB,YAC7D,cACA,aACA,IACF;CACF;CAIF,IAAI,SAAS,WACX,KAAK,MAAM,CAAC,cAAc,gBAAgB,OAAO,QAAQ,SAAS,SAAS,GAAG;EAC5E,MAAM,mBAAoB,WAAuC;EAGjE,IAAI,CAAC,kBAEH;EAGF,MAAM,SAAS,YAAY,cAAc,CAAC;EAE1C,KAAK,MAAM,CAAC,cAAc,SAAS,OAAO,QAAQ,gBAAgB,GAAG;GACnE,MAAM,cAAc,OAAO;GAC3B,IAAI,CAAC,aACH,MAAM,IAAI,gCACR,GAAG,aAAa,GAAG,gBACnB,OAAO,KAAK,MAAM,CACpB;GAIF,kBAA+C,gBAAgB,YAC7D,GAAG,aAAa,GAAG,gBACnB,aACA,IACF;EACF;CACF;CAGF,OAAO;AACT"}

package/dist/{errors-CE56feY1.d.cts → errors-BNnNzSwE.d.cts}

@@ -33,12 +33,6 @@ type ClientInferOutput<T extends {
 }> = StandardSchemaV1.InferOutput<T["output"]>;
 //#endregion
 //#region src/errors.d.ts
-/**
- * Base error class for worker errors
- */
-declare abstract class WorkerError extends Error {
-  protected constructor(message: string, cause?: unknown);
-}
 /**
  * Base class for the contract's runtime validation failures — workflow and
  * activity input/output, plus signal/query/update payloads.
@@ -71,12 +65,15 @@ declare abstract class ValidationError extends ApplicationFailure {
   readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
   protected constructor(message: string, type: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
 }
+declare const ActivityDefinitionNotFoundError_base: import("unthrown").TaggedErrorConstructor<"@temporal-contract/ActivityDefinitionNotFoundError">;
 /**
  * Error thrown when an activity definition is not found in the contract
  */
-declare class ActivityDefinitionNotFoundError extends WorkerError {
-  readonly activityName: string;
-  readonly availableDefinitions: readonly string[];
+declare class ActivityDefinitionNotFoundError extends ActivityDefinitionNotFoundError_base<{
+  activityName: string;
+  availableDefinitions: readonly string[];
+  message: string;
+}> {
   constructor(activityName: string, availableDefinitions?: readonly string[]);
 }
 /**
@@ -142,14 +139,18 @@ declare class UpdateOutputValidationError extends ValidationError {
   readonly updateName: string;
   constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
 }
+declare const ChildWorkflowNotFoundError_base: import("unthrown").TaggedErrorConstructor<"@temporal-contract/ChildWorkflowNotFoundError">;
 /**
  * Error thrown when a child workflow is not found in the contract
  */
-declare class ChildWorkflowNotFoundError extends WorkerError {
-  readonly workflowName: string;
-  readonly availableWorkflows: readonly string[];
+declare class ChildWorkflowNotFoundError extends ChildWorkflowNotFoundError_base<{
+  workflowName: string;
+  availableWorkflows: readonly string[];
+  message: string;
+}> {
   constructor(workflowName: string, availableWorkflows?: readonly string[]);
 }
+declare const ChildWorkflowError_base: import("unthrown").TaggedErrorConstructor<"@temporal-contract/ChildWorkflowError">;
 /**
  * Generic error for child workflow operations.
  *
@@ -159,74 +160,54 @@ declare class ChildWorkflowNotFoundError extends WorkerError {
  * mirroring the client-side `WorkflowFailedError.cause` behavior, so callers
  * can branch on the failure category in one step instead of unwrapping twice.
  */
-declare class ChildWorkflowError extends WorkerError {
+declare class ChildWorkflowError extends ChildWorkflowError_base<{
+  message: string;
+  cause?: unknown;
+}> {
   constructor(message: string, cause?: unknown);
 }
+declare const ChildWorkflowCancelledError_base: import("unthrown").TaggedErrorConstructor<"@temporal-contract/ChildWorkflowCancelledError">;
 /**
- * Discriminated variant of {@link ChildWorkflowError} surfaced when a child
- * workflow operation (start, execute, or wait-for-result) was cancelled —
- * either because the parent workflow itself was cancelled, the child was
- * explicitly cancelled, or its enclosing cancellation scope was. Detected via
- * `@temporalio/workflow`'s `isCancellation(...)`, which sees through nested
- * `ChildWorkflowFailure` / `CancelledFailure` chains.
+ * Discriminated variant surfaced when a child workflow operation (start,
+ * execute, or wait-for-result) was cancelled — either because the parent
+ * workflow itself was cancelled, the child was explicitly cancelled, or its
+ * enclosing cancellation scope was. Detected via `@temporalio/workflow`'s
+ * `isCancellation(...)`, which sees through nested `ChildWorkflowFailure` /
+ * `CancelledFailure` chains.
  *
- * Extends {@link ChildWorkflowError} so existing `instanceof ChildWorkflowError`
- * checks still match cancellation, while `instanceof ChildWorkflowCancelledError`
- * lets call sites narrow further when they need to branch on cancellation
- * explicitly without inspecting `error.cause` against a Temporal SDK class —
- * the worker-side analogue of the client-side cause-forwarding pattern.
- */
-declare class ChildWorkflowCancelledError extends ChildWorkflowError {
-  readonly workflowName: string;
+ * A sibling of {@link ChildWorkflowError} rather than a subclass: both are
+ * distinct {@link TaggedError}s, so call sites discriminate on the `_tag`
+ * (or `instanceof ChildWorkflowCancelledError`) instead of relying on an
+ * `instanceof ChildWorkflowError` that also matches cancellation. `matchTags`
+ * folds the `ChildWorkflowError | ChildWorkflowCancelledError` union
+ * exhaustively.
+ */
+declare class ChildWorkflowCancelledError extends ChildWorkflowCancelledError_base<{
+  workflowName: string;
+  cause?: unknown;
+  message: string;
+}> {
   constructor(workflowName: string, cause?: unknown);
 }
+declare const WorkflowCancelledError_base: import("unthrown").TaggedErrorConstructor<"@temporal-contract/WorkflowCancelledError">;
 /**
- * Error surfaced in the `err(...)` branch of a `ResultAsync` when a typed
+ * Error surfaced in the `err(...)` branch of an `AsyncResult` when a typed
  * cancellation scope is cancelled via Temporal's cancellation propagation.
  * Returned by both `context.cancellableScope` (when the workflow or an
  * ancestor scope cancels) and `context.nonCancellableScope` (when
  * cancellation is raised from inside the scope). Distinct from arbitrary
  * thrown errors so call sites can branch on cancellation explicitly.
  *
- * Non-cancellation errors thrown inside a scope surface as a sibling
- * {@link WorkflowScopeError} on the same `err(...)` channel, so callers can
- * use `instanceof` to discriminate without falling back to `try/catch`.
- */
-declare class WorkflowCancelledError extends WorkerError {
+ * Non-cancellation errors thrown inside a scope are *unmodeled* failures: they
+ * surface on the scope's `defect` channel (re-thrown at the edge / inspectable
+ * via `result.isDefect()` and `result.cause`), not as a typed `err(...)`.
+ */
+declare class WorkflowCancelledError extends WorkflowCancelledError_base<{
+  cause?: unknown;
+  message: string;
+}> {
   constructor(cause?: unknown);
 }
-/**
- * Error surfaced in the `err(...)` branch of a `ResultAsync` when the
- * function passed to `cancellableScope` / `nonCancellableScope` throws a
- * non-cancellation error.
- *
- * The original error is preserved on `cause` so call sites can introspect
- * it without losing identity:
- *
- * @example
- * ```ts
- * const result = await context.cancellableScope(async () => {
- *   return await context.activities.processStep(args);
- * });
- *
- * if (result.isErr()) {
- *   if (result.error instanceof WorkflowCancelledError) {
- *     // graceful cancellation
- *   } else if (result.error instanceof WorkflowScopeError) {
- *     // domain error — `result.error.cause` is the original throwable
- *   }
- * }
- * ```
- *
- * Introduced so the scope helpers route every failure through neverthrow's
- * railway. Previously, non-cancellation errors were re-thrown out of the
- * helper, which became a `ResultAsync` rejection (`new ResultAsync(promise)`
- * does not catch) — they leaked as unhandled rejections rather than
- * surfacing on the typed error channel callers actually inspect.
- */
-declare class WorkflowScopeError extends WorkerError {
-  constructor(cause: unknown);
-}
 //#endregion
-export { ClientInferInput as _, ChildWorkflowError as a, WorkerInferOutput as b, QueryOutputValidationError as c, UpdateOutputValidationError as d, ValidationError as f, WorkflowScopeError as g, WorkflowOutputValidationError as h, ChildWorkflowCancelledError as i, SignalInputValidationError as l, WorkflowInputValidationError as m, ActivityInputValidationError as n, ChildWorkflowNotFoundError as o, WorkflowCancelledError as p, ActivityOutputValidationError as r, QueryInputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateInputValidationError as u, ClientInferOutput as v, WorkerInferInput as y };
-//# sourceMappingURL=errors-CE56feY1.d.cts.map
+export { ClientInferOutput as _, ChildWorkflowError as a, QueryOutputValidationError as c, UpdateOutputValidationError as d, ValidationError as f, ClientInferInput as g, WorkflowOutputValidationError as h, ChildWorkflowCancelledError as i, SignalInputValidationError as l, WorkflowInputValidationError as m, ActivityInputValidationError as n, ChildWorkflowNotFoundError as o, WorkflowCancelledError as p, ActivityOutputValidationError as r, QueryInputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateInputValidationError as u, WorkerInferInput as v, WorkerInferOutput as y };
+//# sourceMappingURL=errors-BNnNzSwE.d.cts.map

package/dist/errors-BNnNzSwE.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-BNnNzSwE.d.cts","names":[],"sources":["../src/types.ts","../src/errors.ts"],"mappings":";;;;;;;;AAOA;KAAY,gBAAA;EAA6B,KAAA,EAAO,SAAA;AAAA,KAAe,gBAAA,CAAiB,WAAA,CAC9E,CAAA;;;;;KAOU,iBAAA;EAA8B,MAAA,EAAQ,SAAA;AAAA,KAAe,gBAAA,CAAiB,UAAA,CAChF,CAAA;;;;;KAOU,gBAAA;EAA6B,KAAA,EAAO,SAAA;AAAA,KAAe,gBAAA,CAAiB,UAAA,CAC9E,CAAA;;;;;KAOU,iBAAA;EAA8B,MAAA,EAAQ,SAAA;AAAA,KAAe,gBAAA,CAAiB,WAAA,CAChF,CAAA;;;;;;AAzBF;;;;;;;;;;;;;;;AACG;AAOH;;;;;;;;;uBCkBsB,eAAA,SAAwB,kBAAA;EAAA,SAI1B,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;EAAA,UAHhD,WAAA,CACP,OAAA,UACA,IAAA,UACgB,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;AAAA,cAqB1D,oCAAA;;AD1CE;AAOH;cCwCa,+BAAA,SAAwC,oCAAA;EAInD,YAAA;EACA,oBAAA;EACA,OAAA;AAAA;cAEY,YAAA,UAAsB,oBAAA;AAAA;;;;cAavB,4BAAA,SAAqC,eAAA;EAAA,SAE9B,YAAA;cAAA,YAAA,UAChB,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;AD/DxC;AAOH;;AAPG,cC6EU,6BAAA,SAAsC,eAAA;EAAA,SAE/B,YAAA;cAAA,YAAA,UAChB,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAc9B,4BAAA,SAAqC,eAAA;EAAA,SAE9B,YAAA;cAAA,YAAA,UAChB,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;ADzFxC;cCuGU,6BAAA,SAAsC,eAAA;EAAA,SAE/B,YAAA;cAAA,YAAA,UAChB,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAc9B,0BAAA,SAAmC,eAAA;EAAA,SAE5B,UAAA;cAAA,UAAA,UAChB,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAc9B,yBAAA,SAAkC,eAAA;EAAA,SAE3B,SAAA;cAAA,SAAA,UAChB,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAc9B,0BAAA,SAAmC,eAAA;EAAA,SAE5B,SAAA;cAAA,SAAA,UAChB,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;AAxJsB;AAqBhE;cAiJY,0BAAA,SAAmC,eAAA;EAAA,SAE5B,UAAA;cAAA,UAAA,UAChB,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;AA/I3C;;;AAAA,cA6Ja,2BAAA,SAAoC,eAAA;EAAA,SAE7B,UAAA;cAAA,UAAA,UAChB,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;AAAA,cAS1C,+BAAA;;;;cAKY,0BAAA,SAAmC,+BAAA;EAI9C,YAAA;EACA,kBAAA;EACA,OAAA;AAAA;cAEY,YAAA,UAAsB,kBAAA;AAAA;AAAA,cAQnC,uBAAA;;;;;;;;;;cAWY,kBAAA,SAA2B,uBAAA;EAGtC,OAAA;EACA,KAAA;AAAA;cAEY,OAAA,UAAiB,KAAA;AAAA;AAAA,cAG9B,gCAAA;;;;;;;;;;;;;;AAzKgD;AAcjD;cA4Ka,2BAAA,SAAoC,gCAAA;EAI/C,YAAA;EACA,KAAA;EACA,OAAA;AAAA;cAEY,YAAA,UAAsB,KAAA;AAAA;AAAA,cAGnC,2BAAA;;;;;;;;;AApLgD;AAcjD;;;cAoLa,sBAAA,SAA+B,2BAAA;EAI1C,KAAA;EACA,OAAA;AAAA;cAEY,KAAA;AAAA"}