@temporal-contract/worker 0.2.0 → 2.0.0

package/README.md

@@ -14,24 +14,20 @@ pnpm add @temporal-contract/worker @temporal-contract/contract @temporalio/workf
 
 ```typescript
 // activities.ts
-import { declareActivitiesHandler, ActivityError } from "@temporal-contract/worker/activity";
-import { Future, Result } from "@swan-io/boxed";
+import { declareActivitiesHandler, ApplicationFailure } from "@temporal-contract/worker/activity";
+import { ResultAsync } from "neverthrow";
 
 export const activities = declareActivitiesHandler({
   contract: myContract,
   activities: {
-    sendEmail: ({ to, body }) => {
-      return Future.fromPromise(emailService.send({ to, body }))
-        .mapError(
-          (error) =>
-            new ActivityError(
-              "EMAIL_FAILED",
-              error instanceof Error ? error.message : "Failed to send email",
-              error,
-            ),
-        )
-        .mapOk(() => ({ sent: true }));
-    },
+    sendEmail: ({ to, body }) =>
+      ResultAsync.fromPromise(emailService.send({ to, body }), (error) =>
+        ApplicationFailure.create({
+          type: "EMAIL_FAILED",
+          message: error instanceof Error ? error.message : "Failed to send email",
+          cause: error,
+        }),
+      ).map(() => ({ sent: true })),
   },
 });
 
@@ -69,7 +65,7 @@ run().catch(console.error);
 
 ### Child Workflows
 
-Execute child workflows with type-safe Future/Result pattern. Supports both same-contract and cross-contract child workflows:
+Execute child workflows with type-safe `ResultAsync`. Supports both same-contract and cross-contract child workflows:
 
 ```typescript
 // workflows.ts
@@ -86,10 +82,10 @@ export const parentWorkflow = declareWorkflow({
       args: { amount: input.totalAmount },
     });
 
-    childResult.match({
-      Ok: (output) => console.log("Payment processed:", output),
-      Error: (error) => console.error("Payment failed:", error),
-    });
+    childResult.match(
+      (output) => console.log("Payment processed:", output),
+      (error) => console.error("Payment failed:", error),
+    );
 
     // Execute child workflow from another contract (another worker)
     const notificationResult = await context.executeChildWorkflow(
@@ -107,14 +103,14 @@ export const parentWorkflow = declareWorkflow({
       args: { to: "user@example.com", body: "Order received" },
     });
 
-    handleResult.match({
-      Ok: async (handle) => {
+    handleResult.match(
+      async (handle) => {
         // Can wait for result later
         const result = await handle.result();
         // ...
       },
-      Error: (error) => console.error("Failed to start:", error),
-    });
+      (error) => console.error("Failed to start:", error),
+    );
 
     return { success: true };
   },

package/dist/activity.cjs

@@ -1,103 +1,13 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_errors = require('./errors-DjSZg-93.cjs');
-
-//#region src/activity-utils.ts
-/**
-* Extract activity definitions for a specific workflow from a contract
-*
-* This includes both:
-* - Workflow-specific activities defined under workflow.activities
-* - Global activities defined under contract.activities
-*
-* @param contract - The contract definition
-* @param workflowName - The name of the workflow
-* @returns Activity definitions for the workflow (workflow-specific + global activities merged)
-*
-* @example
-* ```ts
-* const orderWorkflowActivities = getWorkflowActivities(myContract, 'processOrder');
-* // Returns: { processPayment: ActivityDef, reserveInventory: ActivityDef, sendEmail: ActivityDef }
-* // where sendEmail is a global activity
-* ```
-*/
-function getWorkflowActivities(contract, workflowName) {
-	const workflowActivities = contract.workflows[workflowName]?.activities || {};
-	return {
-		...contract.activities || {},
-		...workflowActivities
-	};
-}
-/**
-* Extract all activity names for a specific workflow from a contract
-*
-* @param contract - The contract definition
-* @param workflowName - The name of the workflow
-* @returns Array of activity names (strings) available for the workflow
-*
-* @example
-* ```ts
-* const activityNames = getWorkflowActivityNames(myContract, 'processOrder');
-* // Returns: ['processPayment', 'reserveInventory', 'sendEmail']
-* ```
-*/
-function getWorkflowActivityNames(contract, workflowName) {
-	const activities = getWorkflowActivities(contract, workflowName);
-	return Object.keys(activities);
-}
-/**
-* Check if an activity belongs to a specific workflow
-*
-* @param contract - The contract definition
-* @param workflowName - The name of the workflow
-* @param activityName - The name of the activity to check
-* @returns True if the activity is available for the workflow, false otherwise
-*
-* @example
-* ```ts
-* if (isWorkflowActivity(myContract, 'processOrder', 'processPayment')) {
-*   // Activity is available for this workflow
-* }
-* ```
-*/
-function isWorkflowActivity(contract, workflowName, activityName) {
-	return activityName in getWorkflowActivities(contract, workflowName);
-}
-/**
-* Get all workflow names from a contract
-*
-* @param contract - The contract definition
-* @returns Array of workflow names defined in the contract
-*
-* @example
-* ```ts
-* const workflows = getWorkflowNames(myContract);
-* // Returns: ['processOrder', 'processRefund']
-* ```
-*/
-function getWorkflowNames(contract) {
-	return Object.keys(contract.workflows);
-}
-
-//#endregion
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_internal = require("./internal-C8MB-kez.cjs");
+let _temporalio_common = require("@temporalio/common");
 //#region src/activity.ts
 /**
-* Activity error class that should be used to wrap all technical exceptions
-* Forces proper error handling and enables retry policies
-*/
-var ActivityError = class ActivityError extends Error {
-	constructor(code, message, cause) {
-		super(message, { cause });
-		this.code = code;
-		this.name = "ActivityError";
-		if (Error.captureStackTrace) Error.captureStackTrace(this, ActivityError);
-	}
-};
-/**
-* Create a typed activities handler with automatic validation and Result pattern
+* Create a typed activities handler with automatic validation and Result pattern.
 *
 * This wraps all activity implementations with:
 * - Validation at network boundaries
-* - Result<T, ActivityError> pattern for explicit error handling
+* - `ResultAsync<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.
@@ -106,32 +16,28 @@ var ActivityError = class ActivityError extends Error {
 *
 * @example
 * ```ts
-* import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
-* import { Result, Future } from '@swan-io/boxed';
+* import { declareActivitiesHandler, ApplicationFailure } from '@temporal-contract/worker/activity';
+* import { ResultAsync, errAsync, okAsync } from 'neverthrow';
 * import myContract from './contract';
 *
 * export const activities = declareActivitiesHandler({
 *   contract: myContract,
 *   activities: {
-*     // Activity returns Result instead of throwing
-*     // All technical exceptions must be wrapped in ActivityError for retry policies
-*     sendEmail: (args) => {
-*       return Future.make(async resolve => {
-*         try {
-*           await emailService.send(args);
-*           resolve(Result.Ok({ sent: true }));
-*         } catch (error) {
-*           // Wrap technical errors in ActivityError to enable retries
-*           resolve(Result.Error(
-*             new ActivityError(
-*               'EMAIL_SEND_FAILED',
-*               'Failed to send email',
-*               error // Original error as cause for debugging
-*             )
-*           ));
-*         }
-*       });
-*     },
+*     // Activity returns ResultAsync instead of throwing.
+*     sendEmail: (args) =>
+*       ResultAsync.fromPromise(
+*         emailService.send(args),
+*         (error) =>
+*           // Wrap technical errors in ApplicationFailure. `nonRetryable`
+*           // is per-instance: set it to true on permanent failures so
+*           // Temporal stops retrying immediately.
+*           ApplicationFailure.create({
+*             type: 'EMAIL_SEND_FAILED',
+*             message: 'Failed to send email',
+*             nonRetryable: false,
+*             cause: error instanceof Error ? error : undefined,
+*           }),
+*       ).map(() => ({ sent: true })),
 *   },
 * });
 *
@@ -144,19 +50,32 @@ var ActivityError = class ActivityError extends Error {
 *   taskQueue: contract.taskQueue,
 * });
 * ```
+*
+* @remarks
+* The wrapper accepts implementations in the
+* `ResultAsync<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
+* `@temporalio/activity` runtime: inside the body you can still call
+* `Context.current()` from `@temporalio/activity` to access heartbeats
+* (`heartbeat(details)`, `heartbeatDetails`), activity info (attempt
+* number, workflow IDs), and the async-completion task token. See the
+* "Working with the Activity Context" section of the worker
+* implementation guide for end-to-end examples.
 */
 function declareActivitiesHandler(options) {
 	const { contract, activities } = options;
 	const wrappedActivities = {};
 	function makeWrapped(activityName, activityDef, activityImpl) {
 		return async (...args) => {
-			const input = args.length === 1 ? args[0] : args;
+			const input = require_internal.extractHandlerInput(args);
 			const inputResult = await activityDef.input["~standard"].validate(input);
-			if (inputResult.issues) throw new require_errors.ActivityInputValidationError(activityName, inputResult.issues);
+			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_errors.ActivityOutputValidationError(activityName, outputResult.issues);
+				if (outputResult.issues) throw new require_internal.ActivityOutputValidationError(activityName, outputResult.issues);
 				return outputResult.value;
 			} else throw result.error;
 		};
@@ -164,7 +83,7 @@ function declareActivitiesHandler(options) {
 	if (contract.activities) for (const [activityName, impl] of Object.entries(activities)) {
 		if (contract.workflows && activityName in contract.workflows) continue;
 		const activityDef = contract.activities[activityName];
-		if (!activityDef) throw new require_errors.ActivityDefinitionNotFoundError(activityName, Object.keys(contract.activities));
+		if (!activityDef) throw new require_internal.ActivityDefinitionNotFoundError(activityName, Object.keys(contract.activities));
 		wrappedActivities[activityName] = makeWrapped(activityName, activityDef, impl);
 	}
 	if (contract.workflows) for (const [workflowName, workflowDef] of Object.entries(contract.workflows)) {
@@ -173,20 +92,20 @@ function declareActivitiesHandler(options) {
 		const wfDefs = workflowDef.activities ?? {};
 		for (const [activityName, impl] of Object.entries(wfActivitiesImpl)) {
 			const activityDef = wfDefs[activityName];
-			if (!activityDef) throw new require_errors.ActivityDefinitionNotFoundError(`${workflowName}.${activityName}`, Object.keys(wfDefs));
+			if (!activityDef) throw new require_internal.ActivityDefinitionNotFoundError(`${workflowName}.${activityName}`, Object.keys(wfDefs));
 			wrappedActivities[activityName] = makeWrapped(`${workflowName}.${activityName}`, activityDef, impl);
 		}
 	}
 	return wrappedActivities;
 }
-
 //#endregion
-exports.ActivityDefinitionNotFoundError = require_errors.ActivityDefinitionNotFoundError;
-exports.ActivityError = ActivityError;
-exports.ActivityInputValidationError = require_errors.ActivityInputValidationError;
-exports.ActivityOutputValidationError = require_errors.ActivityOutputValidationError;
+exports.ActivityDefinitionNotFoundError = require_internal.ActivityDefinitionNotFoundError;
+exports.ActivityInputValidationError = require_internal.ActivityInputValidationError;
+exports.ActivityOutputValidationError = require_internal.ActivityOutputValidationError;
+Object.defineProperty(exports, "ApplicationFailure", {
+	enumerable: true,
+	get: function() {
+		return _temporalio_common.ApplicationFailure;
+	}
+});
 exports.declareActivitiesHandler = declareActivitiesHandler;
-exports.getWorkflowActivities = getWorkflowActivities;
-exports.getWorkflowActivityNames = getWorkflowActivityNames;
-exports.getWorkflowNames = getWorkflowNames;
-exports.isWorkflowActivity = isWorkflowActivity;

package/dist/activity.d.cts

@@ -1,35 +1,30 @@
-import { g as WorkerInferOutput, h as WorkerInferInput, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-4jH78z8m.cjs";
-import { i as isWorkflowActivity, n as getWorkflowActivityNames, r as getWorkflowNames, t as getWorkflowActivities } from "./activity-utils-RsXOceIH.cjs";
+import { _ as WorkerInferOutput, g as WorkerInferInput, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-BeIXtRJe.cjs";
 import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
-import { Future, Result } from "@swan-io/boxed";
+import { ResultAsync } from "neverthrow";
+import { ApplicationFailure, ApplicationFailure as ApplicationFailure$1 } from "@temporalio/common";
 
 //#region src/activity.d.ts
 /**
- * Activity error class that should be used to wrap all technical exceptions
- * Forces proper error handling and enables retry policies
- */
-declare class ActivityError extends Error {
-  readonly code: string;
-  constructor(code: string, message: string, cause?: unknown);
-}
-/**
- * Activity implementation using Future/Result pattern
+ * Activity implementation using neverthrow's `ResultAsync`.
  *
- * Returns Future<Result<Output, ActivityError>> for explicit error handling instead of throwing exceptions.
- * All errors must be wrapped in ActivityError to enable proper retry policies.
+ * Returns `ResultAsync<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).
  */
-type BoxedActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Future<Result<WorkerInferOutput<TActivity>, ActivityError>>;
+type ResultActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => ResultAsync<WorkerInferOutput<TActivity>, ApplicationFailure$1>;
 /**
  * Map of all activity implementations for a contract (global + all workflow-specific)
  */
-type ContractBoxedActivitiesImplementations<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? BoxedActivitiesImplementations<TContract["activities"]> : {}) & { [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? BoxedActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} };
-type BoxedActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: BoxedActivityImplementation<TActivities[K]> };
+type ContractResultActivitiesImplementations<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? ResultActivitiesImplementations<TContract["activities"]> : {}) & { [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? ResultActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} };
+type ResultActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: ResultActivityImplementation<TActivities[K]> };
 /**
  * Options for creating activities handler
  */
 type DeclareActivitiesHandlerOptions<TContract extends ContractDefinition> = {
   contract: TContract;
-  activities: ContractBoxedActivitiesImplementations<TContract>;
+  activities: ContractResultActivitiesImplementations<TContract>;
 };
 type ActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Promise<WorkerInferOutput<TActivity>>;
 type ActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: ActivityImplementation<TActivities[K]> };
@@ -41,11 +36,11 @@ type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) exten
  */
 type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? ActivitiesImplementations<TContract["activities"]> : {}) & UnionToIntersection<{ [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? ActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} }[keyof TContract["workflows"]]>;
 /**
- * Create a typed activities handler with automatic validation and Result pattern
+ * Create a typed activities handler with automatic validation and Result pattern.
  *
  * This wraps all activity implementations with:
  * - Validation at network boundaries
- * - Result<T, ActivityError> pattern for explicit error handling
+ * - `ResultAsync<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.
@@ -54,32 +49,28 @@ type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activ
  *
  * @example
  * ```ts
- * import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
- * import { Result, Future } from '@swan-io/boxed';
+ * import { declareActivitiesHandler, ApplicationFailure } from '@temporal-contract/worker/activity';
+ * import { ResultAsync, errAsync, okAsync } from 'neverthrow';
  * import myContract from './contract';
  *
  * export const activities = declareActivitiesHandler({
  *   contract: myContract,
  *   activities: {
- *     // Activity returns Result instead of throwing
- *     // All technical exceptions must be wrapped in ActivityError for retry policies
- *     sendEmail: (args) => {
- *       return Future.make(async resolve => {
- *         try {
- *           await emailService.send(args);
- *           resolve(Result.Ok({ sent: true }));
- *         } catch (error) {
- *           // Wrap technical errors in ActivityError to enable retries
- *           resolve(Result.Error(
- *             new ActivityError(
- *               'EMAIL_SEND_FAILED',
- *               'Failed to send email',
- *               error // Original error as cause for debugging
- *             )
- *           ));
- *         }
- *       });
- *     },
+ *     // Activity returns ResultAsync instead of throwing.
+ *     sendEmail: (args) =>
+ *       ResultAsync.fromPromise(
+ *         emailService.send(args),
+ *         (error) =>
+ *           // Wrap technical errors in ApplicationFailure. `nonRetryable`
+ *           // is per-instance: set it to true on permanent failures so
+ *           // Temporal stops retrying immediately.
+ *           ApplicationFailure.create({
+ *             type: 'EMAIL_SEND_FAILED',
+ *             message: 'Failed to send email',
+ *             nonRetryable: false,
+ *             cause: error instanceof Error ? error : undefined,
+ *           }),
+ *       ).map(() => ({ sent: true })),
  *   },
  * });
  *
@@ -92,8 +83,21 @@ type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activ
  *   taskQueue: contract.taskQueue,
  * });
  * ```
+ *
+ * @remarks
+ * The wrapper accepts implementations in the
+ * `ResultAsync<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
+ * `@temporalio/activity` runtime: inside the body you can still call
+ * `Context.current()` from `@temporalio/activity` to access heartbeats
+ * (`heartbeat(details)`, `heartbeatDetails`), activity info (attempt
+ * number, workflow IDs), and the async-completion task token. See the
+ * "Working with the Activity Context" section of the worker
+ * implementation guide for end-to-end examples.
  */
 declare function declareActivitiesHandler<TContract extends ContractDefinition>(options: DeclareActivitiesHandlerOptions<TContract>): ActivitiesHandler<TContract>;
 //#endregion
-export { ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler, getWorkflowActivities, getWorkflowActivityNames, getWorkflowNames, isWorkflowActivity };
+export { ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityInputValidationError, ActivityOutputValidationError, ApplicationFailure, declareActivitiesHandler };
 //# sourceMappingURL=activity.d.cts.map

package/dist/activity.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"activity.d.cts","names":[],"sources":["../src/activity.ts"],"mappings":";;;;;;;AA2BA;;;cAAa,aAAA,SAAsB,KAAA;EAAA,SAEf,IAAA;cAAA,IAAA,UAChB,OAAA,UACA,KAAA;AAAA;;;;;;AASH;KAQI,2BAAA,mBAA8C,kBAAA,KACjD,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,MAAA,CAAO,MAAA,CAAO,iBAAA,CAAkB,SAAA,GAAY,aAAA;;;;KAK5C,sCAAA,mBAAyD,kBAAA,KAE3D,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,8BAAA,CAA+B,SAAA,8CAIX,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,8BAAA,CAA+B,SAAA,cAAuB,SAAA;AAAA,KAI3D,8BAAA,qBAAmD,MAAA,SAAe,kBAAA,mBACzD,WAAA,GAAc,2BAAA,CAA4B,WAAA,CAAY,CAAA;;;;KAM/D,+BAAA,mBAAkD,kBAAA;EACrD,QAAA,EAAU,SAAA;EACV,UAAA,EAAY,sCAAA,CAAuC,SAAA;AAAA;AAAA,KAGhD,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,CAAA,6BACrD,CAAA,sBAEE,CAAA;;;AA3C0D;;;KAmDlD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAjD2D;;;;;;;;;;;;;;;;;;;;;AAKJ;iBAoGrD,wBAAA,mBAA2C,kBAAA,CAAA,CACzD,OAAA,EAAS,+BAAA,CAAgC,SAAA,IACxC,iBAAA,CAAkB,SAAA"}
+{"version":3,"file":"activity.d.cts","names":[],"sources":["../src/activity.ts"],"mappings":";;;;;;AA+BwD;;;;;;;;;AAAA,KAWnD,4BAAA,mBAA+C,kBAAA,KAClD,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,WAAA,CAAY,iBAAA,CAAkB,SAAA,GAAY,oBAAA;;;;KAK1C,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,CAAA,6BACrD,CAAA,sBAEE,CAAA;;;;;;KAQQ,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;;;;;;;;;;;;;;;;;;;;;;AAjD4D;;;;;;;;;;;;;;;;;;;;;AAKJ;;;;;;;;;;;;;;;;;;AAQP;;iBAqG/C,wBAAA,mBAA2C,kBAAA,CAAA,CACzD,OAAA,EAAS,+BAAA,CAAgC,SAAA,IACxC,iBAAA,CAAkB,SAAA"}

package/dist/activity.d.mts

@@ -1,35 +1,30 @@
-import { g as WorkerInferOutput, h as WorkerInferInput, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-CmTXZ3JW.mjs";
-import { i as isWorkflowActivity, n as getWorkflowActivityNames, r as getWorkflowNames, t as getWorkflowActivities } from "./activity-utils-B3vP03_P.mjs";
+import { _ as WorkerInferOutput, g as WorkerInferInput, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-BjNG_jUi.mjs";
+import { ApplicationFailure, ApplicationFailure as ApplicationFailure$1 } from "@temporalio/common";
+import { ResultAsync } from "neverthrow";
 import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
-import { Future, Result } from "@swan-io/boxed";
 
 //#region src/activity.d.ts
 /**
- * Activity error class that should be used to wrap all technical exceptions
- * Forces proper error handling and enables retry policies
- */
-declare class ActivityError extends Error {
-  readonly code: string;
-  constructor(code: string, message: string, cause?: unknown);
-}
-/**
- * Activity implementation using Future/Result pattern
+ * Activity implementation using neverthrow's `ResultAsync`.
  *
- * Returns Future<Result<Output, ActivityError>> for explicit error handling instead of throwing exceptions.
- * All errors must be wrapped in ActivityError to enable proper retry policies.
+ * Returns `ResultAsync<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).
  */
-type BoxedActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Future<Result<WorkerInferOutput<TActivity>, ActivityError>>;
+type ResultActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => ResultAsync<WorkerInferOutput<TActivity>, ApplicationFailure$1>;
 /**
  * Map of all activity implementations for a contract (global + all workflow-specific)
  */
-type ContractBoxedActivitiesImplementations<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? BoxedActivitiesImplementations<TContract["activities"]> : {}) & { [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? BoxedActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} };
-type BoxedActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: BoxedActivityImplementation<TActivities[K]> };
+type ContractResultActivitiesImplementations<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? ResultActivitiesImplementations<TContract["activities"]> : {}) & { [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? ResultActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} };
+type ResultActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: ResultActivityImplementation<TActivities[K]> };
 /**
  * Options for creating activities handler
  */
 type DeclareActivitiesHandlerOptions<TContract extends ContractDefinition> = {
   contract: TContract;
-  activities: ContractBoxedActivitiesImplementations<TContract>;
+  activities: ContractResultActivitiesImplementations<TContract>;
 };
 type ActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Promise<WorkerInferOutput<TActivity>>;
 type ActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: ActivityImplementation<TActivities[K]> };
@@ -41,11 +36,11 @@ type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) exten
  */
 type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? ActivitiesImplementations<TContract["activities"]> : {}) & UnionToIntersection<{ [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? ActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} }[keyof TContract["workflows"]]>;
 /**
- * Create a typed activities handler with automatic validation and Result pattern
+ * Create a typed activities handler with automatic validation and Result pattern.
  *
  * This wraps all activity implementations with:
  * - Validation at network boundaries
- * - Result<T, ActivityError> pattern for explicit error handling
+ * - `ResultAsync<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.
@@ -54,32 +49,28 @@ type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activ
  *
  * @example
  * ```ts
- * import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
- * import { Result, Future } from '@swan-io/boxed';
+ * import { declareActivitiesHandler, ApplicationFailure } from '@temporal-contract/worker/activity';
+ * import { ResultAsync, errAsync, okAsync } from 'neverthrow';
  * import myContract from './contract';
  *
  * export const activities = declareActivitiesHandler({
  *   contract: myContract,
  *   activities: {
- *     // Activity returns Result instead of throwing
- *     // All technical exceptions must be wrapped in ActivityError for retry policies
- *     sendEmail: (args) => {
- *       return Future.make(async resolve => {
- *         try {
- *           await emailService.send(args);
- *           resolve(Result.Ok({ sent: true }));
- *         } catch (error) {
- *           // Wrap technical errors in ActivityError to enable retries
- *           resolve(Result.Error(
- *             new ActivityError(
- *               'EMAIL_SEND_FAILED',
- *               'Failed to send email',
- *               error // Original error as cause for debugging
- *             )
- *           ));
- *         }
- *       });
- *     },
+ *     // Activity returns ResultAsync instead of throwing.
+ *     sendEmail: (args) =>
+ *       ResultAsync.fromPromise(
+ *         emailService.send(args),
+ *         (error) =>
+ *           // Wrap technical errors in ApplicationFailure. `nonRetryable`
+ *           // is per-instance: set it to true on permanent failures so
+ *           // Temporal stops retrying immediately.
+ *           ApplicationFailure.create({
+ *             type: 'EMAIL_SEND_FAILED',
+ *             message: 'Failed to send email',
+ *             nonRetryable: false,
+ *             cause: error instanceof Error ? error : undefined,
+ *           }),
+ *       ).map(() => ({ sent: true })),
  *   },
  * });
  *
@@ -92,8 +83,21 @@ type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activ
  *   taskQueue: contract.taskQueue,
  * });
  * ```
+ *
+ * @remarks
+ * The wrapper accepts implementations in the
+ * `ResultAsync<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
+ * `@temporalio/activity` runtime: inside the body you can still call
+ * `Context.current()` from `@temporalio/activity` to access heartbeats
+ * (`heartbeat(details)`, `heartbeatDetails`), activity info (attempt
+ * number, workflow IDs), and the async-completion task token. See the
+ * "Working with the Activity Context" section of the worker
+ * implementation guide for end-to-end examples.
  */
 declare function declareActivitiesHandler<TContract extends ContractDefinition>(options: DeclareActivitiesHandlerOptions<TContract>): ActivitiesHandler<TContract>;
 //#endregion
-export { ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler, getWorkflowActivities, getWorkflowActivityNames, getWorkflowNames, isWorkflowActivity };
+export { ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityInputValidationError, ActivityOutputValidationError, ApplicationFailure, declareActivitiesHandler };
 //# sourceMappingURL=activity.d.mts.map

package/dist/activity.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"activity.d.mts","names":[],"sources":["../src/activity.ts"],"mappings":";;;;;;;AA2BA;;;cAAa,aAAA,SAAsB,KAAA;EAAA,SAEf,IAAA;cAAA,IAAA,UAChB,OAAA,UACA,KAAA;AAAA;;;;;;AASH;KAQI,2BAAA,mBAA8C,kBAAA,KACjD,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,MAAA,CAAO,MAAA,CAAO,iBAAA,CAAkB,SAAA,GAAY,aAAA;;;;KAK5C,sCAAA,mBAAyD,kBAAA,KAE3D,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,8BAAA,CAA+B,SAAA,8CAIX,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,8BAAA,CAA+B,SAAA,cAAuB,SAAA;AAAA,KAI3D,8BAAA,qBAAmD,MAAA,SAAe,kBAAA,mBACzD,WAAA,GAAc,2BAAA,CAA4B,WAAA,CAAY,CAAA;;;;KAM/D,+BAAA,mBAAkD,kBAAA;EACrD,QAAA,EAAU,SAAA;EACV,UAAA,EAAY,sCAAA,CAAuC,SAAA;AAAA;AAAA,KAGhD,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,CAAA,6BACrD,CAAA,sBAEE,CAAA;;;AA3C0D;;;KAmDlD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAjD2D;;;;;;;;;;;;;;;;;;;;;AAKJ;iBAoGrD,wBAAA,mBAA2C,kBAAA,CAAA,CACzD,OAAA,EAAS,+BAAA,CAAgC,SAAA,IACxC,iBAAA,CAAkB,SAAA"}
+{"version":3,"file":"activity.d.mts","names":[],"sources":["../src/activity.ts"],"mappings":";;;;;;AA+BwD;;;;;;;;;AAAA,KAWnD,4BAAA,mBAA+C,kBAAA,KAClD,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,WAAA,CAAY,iBAAA,CAAkB,SAAA,GAAY,oBAAA;;;;KAK1C,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,CAAA,6BACrD,CAAA,sBAEE,CAAA;;;;;;KAQQ,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;;;;;;;;;;;;;;;;;;;;;;AAjD4D;;;;;;;;;;;;;;;;;;;;;AAKJ;;;;;;;;;;;;;;;;;;AAQP;;iBAqG/C,wBAAA,mBAA2C,kBAAA,CAAA,CACzD,OAAA,EAAS,+BAAA,CAAgC,SAAA,IACxC,iBAAA,CAAkB,SAAA"}