@temporal-contract/worker 0.0.2 → 0.0.4

package/dist/activity.cjs

@@ -1,8 +1,33 @@
-const require_handler = require('./handler-Cc951VQp.cjs');
+const require_handler = require('./handler-D9BllGor.cjs');
+let __swan_io_boxed = require("@swan-io/boxed");
 
 exports.ActivityDefinitionNotFoundError = require_handler.ActivityDefinitionNotFoundError;
-exports.ActivityImplementationNotFoundError = require_handler.ActivityImplementationNotFoundError;
+exports.ActivityError = require_handler.ActivityError;
 exports.ActivityInputValidationError = require_handler.ActivityInputValidationError;
 exports.ActivityOutputValidationError = require_handler.ActivityOutputValidationError;
+Object.defineProperty(exports, 'AsyncData', {
+  enumerable: true,
+  get: function () {
+    return __swan_io_boxed.AsyncData;
+  }
+});
+Object.defineProperty(exports, 'Future', {
+  enumerable: true,
+  get: function () {
+    return __swan_io_boxed.Future;
+  }
+});
+Object.defineProperty(exports, 'Option', {
+  enumerable: true,
+  get: function () {
+    return __swan_io_boxed.Option;
+  }
+});
+Object.defineProperty(exports, 'Result', {
+  enumerable: true,
+  get: function () {
+    return __swan_io_boxed.Result;
+  }
+});
 exports.WorkerError = require_handler.WorkerError;
 exports.declareActivitiesHandler = require_handler.declareActivitiesHandler;

package/dist/activity.d.cts

@@ -1,2 +1,3 @@
-import { C as declareActivitiesHandler, h as DeclareActivitiesHandlerOptions, i as ActivityOutputValidationError, m as ActivityImplementations, n as ActivityImplementationNotFoundError, p as ActivitiesHandler, r as ActivityInputValidationError, t as ActivityDefinitionNotFoundError, u as WorkerError, v as RawActivityImplementation } from "./errors-B50uht6a.cjs";
-export { type ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityImplementationNotFoundError, type ActivityImplementations, ActivityInputValidationError, ActivityOutputValidationError, type DeclareActivitiesHandlerOptions, type RawActivityImplementation, WorkerError, declareActivitiesHandler };
+import { S as WorkerError, d as declareActivitiesHandler, g as ActivityOutputValidationError, h as ActivityInputValidationError, i as DeclareActivitiesHandlerOptions, m as ActivityError, n as ActivityImplementations, p as ActivityDefinitionNotFoundError, r as BoxedActivityImplementation, t as ActivitiesHandler } from "./handler-Czi-kgwZ.cjs";
+import { AsyncData, Future, Option, Result } from "@swan-io/boxed";
+export { type ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, type ActivityImplementations, ActivityInputValidationError, ActivityOutputValidationError, AsyncData, type BoxedActivityImplementation, type DeclareActivitiesHandlerOptions, Future, Option, Result, WorkerError, declareActivitiesHandler };

package/dist/activity.d.mts

@@ -1,2 +1,3 @@
-import { C as declareActivitiesHandler, h as DeclareActivitiesHandlerOptions, i as ActivityOutputValidationError, m as ActivityImplementations, n as ActivityImplementationNotFoundError, p as ActivitiesHandler, r as ActivityInputValidationError, t as ActivityDefinitionNotFoundError, u as WorkerError, v as RawActivityImplementation } from "./errors-DgUMRes-.mjs";
-export { type ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityImplementationNotFoundError, type ActivityImplementations, ActivityInputValidationError, ActivityOutputValidationError, type DeclareActivitiesHandlerOptions, type RawActivityImplementation, WorkerError, declareActivitiesHandler };
+import { S as WorkerError, d as declareActivitiesHandler, g as ActivityOutputValidationError, h as ActivityInputValidationError, i as DeclareActivitiesHandlerOptions, m as ActivityError, n as ActivityImplementations, p as ActivityDefinitionNotFoundError, r as BoxedActivityImplementation, t as ActivitiesHandler } from "./handler-DThqdaaS.mjs";
+import { AsyncData, Future, Option, Result } from "@swan-io/boxed";
+export { type ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, type ActivityImplementations, ActivityInputValidationError, ActivityOutputValidationError, AsyncData, type BoxedActivityImplementation, type DeclareActivitiesHandlerOptions, Future, Option, Result, WorkerError, declareActivitiesHandler };

package/dist/activity.mjs

@@ -1,3 +1,4 @@
-import { a as ActivityInputValidationError, f as WorkerError, i as ActivityImplementationNotFoundError, o as ActivityOutputValidationError, r as ActivityDefinitionNotFoundError, t as declareActivitiesHandler } from "./handler-BP9xAycT.mjs";
+import { a as ActivityInputValidationError, f as WorkerError, i as ActivityError, o as ActivityOutputValidationError, r as ActivityDefinitionNotFoundError, t as declareActivitiesHandler } from "./handler-B7B5QHez.mjs";
+import { AsyncData, Future, Option, Result } from "@swan-io/boxed";
 
-export { ActivityDefinitionNotFoundError, ActivityImplementationNotFoundError, ActivityInputValidationError, ActivityOutputValidationError, WorkerError, declareActivitiesHandler };
+export { ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, AsyncData, Future, Option, Result, WorkerError, declareActivitiesHandler };

package/dist/{handler-BP9xAycT.mjs → handler-B7B5QHez.mjs}

@@ -5,29 +5,34 @@ import { defineQuery, defineSignal, defineUpdate, proxyActivities, setHandler, w
 * Base error class for worker errors
 */
 var WorkerError = class extends Error {
-	constructor(message) {
-		super(message);
+	constructor(message, cause) {
+		super(message, { cause });
 		this.name = "WorkerError";
 		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
 	}
 };
 /**
-* Error thrown when an activity implementation is not found
+* Activity error class that should be used to wrap all technical exceptions
+* Forces proper error handling and enables retry policies
 */
-var ActivityImplementationNotFoundError = class extends WorkerError {
-	constructor(activityName, availableActivities) {
-		super(`Activity implementation not found for: "${activityName}". Available activities: ${availableActivities.length > 0 ? availableActivities.join(", ") : "none"}`);
-		this.activityName = activityName;
-		this.availableActivities = availableActivities;
-		this.name = "ActivityImplementationNotFoundError";
+var ActivityError = class ActivityError extends Error {
+	code;
+	cause;
+	constructor(code, message, cause) {
+		super(message, { cause });
+		this.code = code;
+		this.cause = cause;
+		this.name = "ActivityError";
+		if (Error.captureStackTrace) Error.captureStackTrace(this, ActivityError);
 	}
 };
 /**
 * Error thrown when an activity definition is not found in the contract
 */
 var ActivityDefinitionNotFoundError = class extends WorkerError {
-	constructor(activityName, availableDefinitions) {
-		super(`Activity definition not found in contract for: "${activityName}". Available definitions: ${availableDefinitions.length > 0 ? availableDefinitions.join(", ") : "none"}`);
+	constructor(activityName, availableDefinitions = []) {
+		const available = availableDefinitions.length > 0 ? availableDefinitions.join(", ") : "none";
+		super(`Activity definition not found for: "${activityName}". Available activities: ${available}`);
 		this.activityName = activityName;
 		this.availableDefinitions = availableDefinitions;
 		this.name = "ActivityDefinitionNotFoundError";
@@ -158,7 +163,7 @@ function createValidatedActivities(rawActivities, workflowActivitiesDefinition,
 	};
 	for (const [activityName, activityDef] of Object.entries(allActivitiesDefinition)) {
 		const rawActivity = rawActivities[activityName];
-		if (!rawActivity) throw new ActivityImplementationNotFoundError(activityName, Object.keys(rawActivities));
+		if (!rawActivity) throw new Error(`Activity implementation not found for: "${activityName}". Available activities: ${Object.keys(rawActivities).length > 0 ? Object.keys(rawActivities).join(", ") : "none"}`);
 		const wrappedActivity = async (input) => {
 			const inputResult = await activityDef.input["~standard"].validate(input);
 			if (inputResult.issues) throw new ActivityInputValidationError(activityName, inputResult.issues);
@@ -172,30 +177,44 @@ function createValidatedActivities(rawActivities, workflowActivitiesDefinition,
 	return validatedActivities;
 }
 /**
-* Create a typed activities handler with automatic validation
+* 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
+* - Automatic conversion from Result to Promise (throwing on Error)
 *
-* This wraps all activity implementations with Zod validation at network boundaries.
 * TypeScript ensures ALL activities (global + workflow-specific) are implemented.
 *
 * Use this to create the activities object for the Temporal Worker.
 *
 * @example
 * ```ts
-* import { declareActivitiesHandler } from '@temporal-contract/worker';
+* import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
+* import { Result, Future } from '@swan-io/boxed';
 * import myContract from './contract';
 *
 * export const activitiesHandler = declareActivitiesHandler({
 *   contract: myContract,
 *   activities: {
-*     // Global activities
-*     sendEmail: async (to, subject, body) => {
-*       await emailService.send({ to, subject, body });
-*       return { sent: true };
-*     },
-*     // Workflow-specific activities
-*     validateInventory: async (orderId) => {
-*       const available = await inventory.check(orderId);
-*       return { available };
+*     // 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
+*             )
+*           ));
+*         }
+*       });
 *     },
 *   },
 * });
@@ -224,13 +243,16 @@ function declareActivitiesHandler(options) {
 			break;
 		}
 		if (!activityDef) throw new ActivityDefinitionNotFoundError(activityName, allDefinitions);
-		wrappedActivities[activityName] = async (input) => {
+		wrappedActivities[activityName] = async (...args) => {
+			const input = args.length === 1 ? args[0] : args;
 			const inputResult = await activityDef.input["~standard"].validate(input);
 			if (inputResult.issues) throw new ActivityInputValidationError(activityName, inputResult.issues);
-			const result = await activityImpl(inputResult.value);
-			const outputResult = await activityDef.output["~standard"].validate(result);
-			if (outputResult.issues) throw new ActivityOutputValidationError(activityName, outputResult.issues);
-			return outputResult.value;
+			const result = await activityImpl(inputResult.value).toPromise();
+			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 {
@@ -373,4 +395,4 @@ function declareWorkflow(options) {
 }
 
 //#endregion
-export { ActivityInputValidationError as a, QueryOutputValidationError as c, UpdateOutputValidationError as d, WorkerError as f, ActivityImplementationNotFoundError as i, SignalInputValidationError as l, WorkflowOutputValidationError as m, declareWorkflow as n, ActivityOutputValidationError as o, WorkflowInputValidationError as p, ActivityDefinitionNotFoundError as r, QueryInputValidationError as s, declareActivitiesHandler as t, UpdateInputValidationError as u };
+export { ActivityInputValidationError as a, QueryOutputValidationError as c, UpdateOutputValidationError as d, WorkerError as f, ActivityError as i, SignalInputValidationError as l, WorkflowOutputValidationError as m, declareWorkflow as n, ActivityOutputValidationError as o, WorkflowInputValidationError as p, ActivityDefinitionNotFoundError as r, QueryInputValidationError as s, declareActivitiesHandler as t, UpdateInputValidationError as u };

package/dist/{errors-B50uht6a.d.cts → handler-Czi-kgwZ.d.cts}

@@ -1,9 +1,106 @@
+import { Future, Result } from "@swan-io/boxed";
 import { ActivityOptions, WorkflowInfo } from "@temporalio/workflow";
 import { ActivityDefinition, ContractDefinition, QueryDefinition, SignalDefinition, UpdateDefinition, WorkerInferInput, WorkerInferOutput, WorkerInferWorkflowContextActivities } from "@temporal-contract/contract";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
+//#region src/errors.d.ts
+/**
+ * Base error class for worker errors
+ */
+declare class WorkerError extends Error {
+  constructor(message: string, cause?: unknown);
+}
+/**
+ * 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;
+  readonly cause?: unknown;
+  constructor(code: string, message: string, cause?: unknown);
+}
+/**
+ * Error thrown when an activity definition is not found in the contract
+ */
+declare class ActivityDefinitionNotFoundError extends WorkerError {
+  readonly activityName: string;
+  readonly availableDefinitions: readonly string[];
+  constructor(activityName: string, availableDefinitions?: readonly string[]);
+}
+/**
+ * Error thrown when activity input validation fails
+ */
+declare class ActivityInputValidationError extends WorkerError {
+  readonly activityName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(activityName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when activity output validation fails
+ */
+declare class ActivityOutputValidationError extends WorkerError {
+  readonly activityName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(activityName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when workflow input validation fails
+ */
+declare class WorkflowInputValidationError extends WorkerError {
+  readonly workflowName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(workflowName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when workflow output validation fails
+ */
+declare class WorkflowOutputValidationError extends WorkerError {
+  readonly workflowName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(workflowName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when signal input validation fails
+ */
+declare class SignalInputValidationError extends WorkerError {
+  readonly signalName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(signalName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when query input validation fails
+ */
+declare class QueryInputValidationError extends WorkerError {
+  readonly queryName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(queryName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when query output validation fails
+ */
+declare class QueryOutputValidationError extends WorkerError {
+  readonly queryName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(queryName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when update input validation fails
+ */
+declare class UpdateInputValidationError extends WorkerError {
+  readonly updateName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when update output validation fails
+ */
+declare class UpdateOutputValidationError extends WorkerError {
+  readonly updateName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+//#endregion
 //#region src/handler.d.ts
-
 /**
  * Workflow context with typed activities (workflow + global) and workflow info
  * Note: activities is typed as 'any' to work around TypeScript generic type inference limitations with Zod tuples
@@ -19,11 +116,10 @@ interface WorkflowContext<TContract extends ContractDefinition, TWorkflowName ex
  */
 type WorkflowImplementation<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = (context: WorkflowContext<TContract, TWorkflowName>, args: WorkerInferInput<TContract["workflows"][TWorkflowName]>) => Promise<WorkerInferOutput<TContract["workflows"][TWorkflowName]>>;
 /**
- * Raw activity implementation function (receives typed args as tuple)
- * Note: We use 'any' for args/return to work around TypeScript limitations with generic Zod tuple inference
- * The actual types will be enforced at runtime by Zod validation
+ * Activity implementation using Result pattern
+ * Returns Future<Result<Output, ActivityError>> instead of throwing exceptions
  */
-type RawActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Promise<WorkerInferOutput<TActivity>>;
+type BoxedActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Future<Result<WorkerInferOutput<TActivity>, ActivityError>>;
 /**
  * Signal handler implementation
  */
@@ -39,7 +135,7 @@ type UpdateHandlerImplementation<TUpdate extends UpdateDefinition> = (args: Work
 /**
  * Map of all activity implementations for a contract (global + all workflow-specific)
  */
-type ActivityImplementations<T extends ContractDefinition> = (T["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof T["activities"]]: RawActivityImplementation<T["activities"][K]> } : {}) & UnionToIntersection<{ [K in keyof T["workflows"]]: T["workflows"][K]["activities"] extends Record<string, ActivityDefinition> ? { [A in keyof T["workflows"][K]["activities"]]: RawActivityImplementation<T["workflows"][K]["activities"][A]> } : {} }[keyof T["workflows"]]>;
+type ActivityImplementations<T extends ContractDefinition> = (T["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof T["activities"]]: BoxedActivityImplementation<T["activities"][K]> } : {}) & UnionToIntersection<{ [K in keyof T["workflows"]]: T["workflows"][K]["activities"] extends Record<string, ActivityDefinition> ? { [A in keyof T["workflows"][K]["activities"]]: BoxedActivityImplementation<T["workflows"][K]["activities"][A]> } : {} }[keyof T["workflows"]]>;
 /**
  * Utility type to convert union to intersection
  */
@@ -98,30 +194,44 @@ interface DeclareWorkflowOptions<TContract extends ContractDefinition, TWorkflow
   updates?: TContract["workflows"][TWorkflowName]["updates"] extends Record<string, UpdateDefinition> ? { [K in keyof TContract["workflows"][TWorkflowName]["updates"]]: UpdateHandlerImplementation<TContract["workflows"][TWorkflowName]["updates"][K]> } : never;
 }
 /**
- * Create a typed activities handler with automatic validation
+ * 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
+ * - Automatic conversion from Result to Promise (throwing on Error)
  *
- * This wraps all activity implementations with Zod validation at network boundaries.
  * TypeScript ensures ALL activities (global + workflow-specific) are implemented.
  *
  * Use this to create the activities object for the Temporal Worker.
  *
  * @example
  * ```ts
- * import { declareActivitiesHandler } from '@temporal-contract/worker';
+ * import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
+ * import { Result, Future } from '@swan-io/boxed';
  * import myContract from './contract';
  *
  * export const activitiesHandler = declareActivitiesHandler({
  *   contract: myContract,
  *   activities: {
- *     // Global activities
- *     sendEmail: async (to, subject, body) => {
- *       await emailService.send({ to, subject, body });
- *       return { sent: true };
- *     },
- *     // Workflow-specific activities
- *     validateInventory: async (orderId) => {
- *       const available = await inventory.check(orderId);
- *       return { available };
+ *     // 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
+ *             )
+ *           ));
+ *         }
+ *       });
  *     },
  *   },
  * });
@@ -203,100 +313,4 @@ declare function declareActivitiesHandler<T extends ContractDefinition>(options:
  */
 declare function declareWorkflow<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]>(options: DeclareWorkflowOptions<TContract, TWorkflowName>): (args: WorkerInferInput<TContract["workflows"][TWorkflowName]>) => Promise<WorkerInferOutput<TContract["workflows"][TWorkflowName]>>;
 //#endregion
-//#region src/errors.d.ts
-/**
- * Base error class for worker errors
- */
-declare class WorkerError extends Error {
-  constructor(message: string);
-}
-/**
- * Error thrown when an activity implementation is not found
- */
-declare class ActivityImplementationNotFoundError extends WorkerError {
-  readonly activityName: string;
-  readonly availableActivities: readonly string[];
-  constructor(activityName: string, availableActivities: readonly string[]);
-}
-/**
- * Error thrown when an activity definition is not found in the contract
- */
-declare class ActivityDefinitionNotFoundError extends WorkerError {
-  readonly activityName: string;
-  readonly availableDefinitions: readonly string[];
-  constructor(activityName: string, availableDefinitions: readonly string[]);
-}
-/**
- * Error thrown when activity input validation fails
- */
-declare class ActivityInputValidationError extends WorkerError {
-  readonly activityName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(activityName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-/**
- * Error thrown when activity output validation fails
- */
-declare class ActivityOutputValidationError extends WorkerError {
-  readonly activityName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(activityName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-/**
- * Error thrown when workflow input validation fails
- */
-declare class WorkflowInputValidationError extends WorkerError {
-  readonly workflowName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(workflowName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-/**
- * Error thrown when workflow output validation fails
- */
-declare class WorkflowOutputValidationError extends WorkerError {
-  readonly workflowName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(workflowName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-/**
- * Error thrown when signal input validation fails
- */
-declare class SignalInputValidationError extends WorkerError {
-  readonly signalName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(signalName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-/**
- * Error thrown when query input validation fails
- */
-declare class QueryInputValidationError extends WorkerError {
-  readonly queryName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(queryName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-/**
- * Error thrown when query output validation fails
- */
-declare class QueryOutputValidationError extends WorkerError {
-  readonly queryName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(queryName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-/**
- * Error thrown when update input validation fails
- */
-declare class UpdateInputValidationError extends WorkerError {
-  readonly updateName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-/**
- * Error thrown when update output validation fails
- */
-declare class UpdateOutputValidationError extends WorkerError {
-  readonly updateName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-//#endregion
-export { declareActivitiesHandler as C, WorkflowImplementation as S, QueryHandlerImplementation as _, QueryInputValidationError as a, UpdateHandlerImplementation as b, UpdateInputValidationError as c, WorkflowInputValidationError as d, WorkflowOutputValidationError as f, DeclareWorkflowOptions as g, DeclareActivitiesHandlerOptions as h, ActivityOutputValidationError as i, UpdateOutputValidationError as l, ActivityImplementations as m, ActivityImplementationNotFoundError as n, QueryOutputValidationError as o, ActivitiesHandler as p, ActivityInputValidationError as r, SignalInputValidationError as s, ActivityDefinitionNotFoundError as t, WorkerError as u, RawActivityImplementation as v, declareWorkflow as w, WorkflowContext as x, SignalHandlerImplementation as y };
+export { WorkflowInputValidationError as C, WorkerError as S, QueryInputValidationError as _, DeclareWorkflowOptions as a, UpdateInputValidationError as b, UpdateHandlerImplementation as c, declareActivitiesHandler as d, declareWorkflow as f, ActivityOutputValidationError as g, ActivityInputValidationError as h, DeclareActivitiesHandlerOptions as i, WorkflowContext as l, ActivityError as m, ActivityImplementations as n, QueryHandlerImplementation as o, ActivityDefinitionNotFoundError as p, BoxedActivityImplementation as r, SignalHandlerImplementation as s, ActivitiesHandler as t, WorkflowImplementation as u, QueryOutputValidationError as v, WorkflowOutputValidationError as w, UpdateOutputValidationError as x, SignalInputValidationError as y };

package/dist/{handler-Cc951VQp.cjs → handler-D9BllGor.cjs}

@@ -5,29 +5,34 @@ let __temporalio_workflow = require("@temporalio/workflow");
 * Base error class for worker errors
 */
 var WorkerError = class extends Error {
-	constructor(message) {
-		super(message);
+	constructor(message, cause) {
+		super(message, { cause });
 		this.name = "WorkerError";
 		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
 	}
 };
 /**
-* Error thrown when an activity implementation is not found
+* Activity error class that should be used to wrap all technical exceptions
+* Forces proper error handling and enables retry policies
 */
-var ActivityImplementationNotFoundError = class extends WorkerError {
-	constructor(activityName, availableActivities) {
-		super(`Activity implementation not found for: "${activityName}". Available activities: ${availableActivities.length > 0 ? availableActivities.join(", ") : "none"}`);
-		this.activityName = activityName;
-		this.availableActivities = availableActivities;
-		this.name = "ActivityImplementationNotFoundError";
+var ActivityError = class ActivityError extends Error {
+	code;
+	cause;
+	constructor(code, message, cause) {
+		super(message, { cause });
+		this.code = code;
+		this.cause = cause;
+		this.name = "ActivityError";
+		if (Error.captureStackTrace) Error.captureStackTrace(this, ActivityError);
 	}
 };
 /**
 * Error thrown when an activity definition is not found in the contract
 */
 var ActivityDefinitionNotFoundError = class extends WorkerError {
-	constructor(activityName, availableDefinitions) {
-		super(`Activity definition not found in contract for: "${activityName}". Available definitions: ${availableDefinitions.length > 0 ? availableDefinitions.join(", ") : "none"}`);
+	constructor(activityName, availableDefinitions = []) {
+		const available = availableDefinitions.length > 0 ? availableDefinitions.join(", ") : "none";
+		super(`Activity definition not found for: "${activityName}". Available activities: ${available}`);
 		this.activityName = activityName;
 		this.availableDefinitions = availableDefinitions;
 		this.name = "ActivityDefinitionNotFoundError";
@@ -158,7 +163,7 @@ function createValidatedActivities(rawActivities, workflowActivitiesDefinition,
 	};
 	for (const [activityName, activityDef] of Object.entries(allActivitiesDefinition)) {
 		const rawActivity = rawActivities[activityName];
-		if (!rawActivity) throw new ActivityImplementationNotFoundError(activityName, Object.keys(rawActivities));
+		if (!rawActivity) throw new Error(`Activity implementation not found for: "${activityName}". Available activities: ${Object.keys(rawActivities).length > 0 ? Object.keys(rawActivities).join(", ") : "none"}`);
 		const wrappedActivity = async (input) => {
 			const inputResult = await activityDef.input["~standard"].validate(input);
 			if (inputResult.issues) throw new ActivityInputValidationError(activityName, inputResult.issues);
@@ -172,30 +177,44 @@ function createValidatedActivities(rawActivities, workflowActivitiesDefinition,
 	return validatedActivities;
 }
 /**
-* Create a typed activities handler with automatic validation
+* 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
+* - Automatic conversion from Result to Promise (throwing on Error)
 *
-* This wraps all activity implementations with Zod validation at network boundaries.
 * TypeScript ensures ALL activities (global + workflow-specific) are implemented.
 *
 * Use this to create the activities object for the Temporal Worker.
 *
 * @example
 * ```ts
-* import { declareActivitiesHandler } from '@temporal-contract/worker';
+* import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
+* import { Result, Future } from '@swan-io/boxed';
 * import myContract from './contract';
 *
 * export const activitiesHandler = declareActivitiesHandler({
 *   contract: myContract,
 *   activities: {
-*     // Global activities
-*     sendEmail: async (to, subject, body) => {
-*       await emailService.send({ to, subject, body });
-*       return { sent: true };
-*     },
-*     // Workflow-specific activities
-*     validateInventory: async (orderId) => {
-*       const available = await inventory.check(orderId);
-*       return { available };
+*     // 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
+*             )
+*           ));
+*         }
+*       });
 *     },
 *   },
 * });
@@ -224,13 +243,16 @@ function declareActivitiesHandler(options) {
 			break;
 		}
 		if (!activityDef) throw new ActivityDefinitionNotFoundError(activityName, allDefinitions);
-		wrappedActivities[activityName] = async (input) => {
+		wrappedActivities[activityName] = async (...args) => {
+			const input = args.length === 1 ? args[0] : args;
 			const inputResult = await activityDef.input["~standard"].validate(input);
 			if (inputResult.issues) throw new ActivityInputValidationError(activityName, inputResult.issues);
-			const result = await activityImpl(inputResult.value);
-			const outputResult = await activityDef.output["~standard"].validate(result);
-			if (outputResult.issues) throw new ActivityOutputValidationError(activityName, outputResult.issues);
-			return outputResult.value;
+			const result = await activityImpl(inputResult.value).toPromise();
+			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 {
@@ -379,10 +401,10 @@ Object.defineProperty(exports, 'ActivityDefinitionNotFoundError', {
     return ActivityDefinitionNotFoundError;
   }
 });
-Object.defineProperty(exports, 'ActivityImplementationNotFoundError', {
+Object.defineProperty(exports, 'ActivityError', {
   enumerable: true,
   get: function () {
-    return ActivityImplementationNotFoundError;
+    return ActivityError;
   }
 });
 Object.defineProperty(exports, 'ActivityInputValidationError', {