@temporal-contract/worker 0.0.4 → 0.0.6

package/README.md

@@ -34,6 +34,78 @@ export const processOrder = declareWorkflow({
     return { success: true };
   }
 });
+
+// worker.ts
+import { NativeConnection } from '@temporalio/worker';
+import { createWorker } from '@temporal-contract/worker/worker';
+import { activities } from './activities';
+import myContract from './contract';
+
+async function run() {
+  const connection = await NativeConnection.connect({
+    address: 'localhost:7233',
+  });
+
+  const worker = await createWorker({
+    contract: myContract,
+    connection,
+    workflowsPath: require.resolve('./workflows'),
+    activities,
+  });
+
+  await worker.run();
+}
+
+run().catch(console.error);
+```
+
+### Child Workflows
+
+Execute child workflows with type-safe Future/Result pattern. Supports both same-contract and cross-contract child workflows:
+
+```typescript
+// workflows.ts
+import { declareWorkflow } from '@temporal-contract/worker/workflow';
+
+export const parentWorkflow = declareWorkflow({
+  workflowName: 'parentWorkflow',
+  contract: myContract,
+  implementation: async (context, input) => {
+    // Execute child workflow from same contract and wait for result
+    const childResult = await context.executeChildWorkflow(myContract, 'processPayment', {
+      workflowId: `payment-${input.orderId}`,
+      args: { amount: input.totalAmount }
+    });
+
+    childResult.match({
+      Ok: (output) => console.log('Payment processed:', output),
+      Error: (error) => console.error('Payment failed:', error),
+    });
+
+    // Execute child workflow from another contract (another worker)
+    const notificationResult = await context.executeChildWorkflow(notificationContract, 'sendNotification', {
+      workflowId: `notification-${input.orderId}`,
+      args: { message: 'Order received' }
+    });
+
+    // Or start child workflow without waiting
+    const handleResult = await context.startChildWorkflow(myContract, 'sendEmail', {
+      workflowId: `email-${input.orderId}`,
+      args: { to: 'user@example.com', body: 'Order received' }
+    });
+
+    handleResult.match({
+      Ok: async (handle) => {
+        // Can wait for result later
+        const result = await handle.result();
+        // ...
+      },
+      Error: (error) => console.error('Failed to start:', error),
+    });
+
+    return { success: true };
+  }
+});
 ```
 
 ## Documentation

package/dist/activity.cjs

@@ -1,33 +1,109 @@
-const require_handler = require('./handler-D9BllGor.cjs');
-let __swan_io_boxed = require("@swan-io/boxed");
+const require_errors = require('./errors-DjSZg-93.cjs');
 
-exports.ActivityDefinitionNotFoundError = require_handler.ActivityDefinitionNotFoundError;
-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;
+//#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
+*
+* 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)
+*
+* TypeScript ensures ALL activities (global + workflow-specific) are implemented.
+*
+* Use this to create the activities object for the Temporal Worker.
+*
+* @example
+* ```ts
+* import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
+* import { Result, Future } from '@temporal-contract/boxed';
+* 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
+*             )
+*           ));
+*         }
+*       });
+*     },
+*   },
+* });
+*
+* // Use with Temporal Worker
+* import { Worker } from '@temporalio/worker';
+*
+* const worker = await Worker.create({
+*   workflowsPath: require.resolve('./workflows'),
+*   activities: activities,
+*   taskQueue: contract.taskQueue,
+* });
+* ```
+*/
+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 inputResult = await activityDef.input["~standard"].validate(input);
+			if (inputResult.issues) throw new require_errors.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);
+				return outputResult.value;
+			} else throw result.error;
+		};
+	}
+	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));
+		wrappedActivities[activityName] = makeWrapped(activityName, activityDef, impl);
+	}
+	if (contract.workflows) for (const [workflowName, workflowDef] of Object.entries(contract.workflows)) {
+		const wfActivitiesImpl = activities[workflowName];
+		if (!wfActivitiesImpl) continue;
+		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));
+			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.declareActivitiesHandler = declareActivitiesHandler;

package/dist/activity.d.cts

@@ -1,3 +1,98 @@
-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 };
+import { g as WorkerInferOutput, h as WorkerInferInput, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-BqYWpdvd.cjs";
+import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
+import { Future, Result } from "@temporal-contract/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
+ *
+ * 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.
+ */
+type BoxedActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Future<Result<WorkerInferOutput<TActivity>, ActivityError>>;
+/**
+ * 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]> };
+/**
+ * Options for creating activities handler
+ */
+interface DeclareActivitiesHandlerOptions<TContract extends ContractDefinition> {
+  contract: TContract;
+  activities: ContractBoxedActivitiesImplementations<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]> };
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+/**
+ * Activities handler ready for Temporal Worker
+ *
+ * Flat structure: all activities (global + all workflow-specific) are at the root level
+ */
+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
+ *
+ * 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)
+ *
+ * TypeScript ensures ALL activities (global + workflow-specific) are implemented.
+ *
+ * Use this to create the activities object for the Temporal Worker.
+ *
+ * @example
+ * ```ts
+ * import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
+ * import { Result, Future } from '@temporal-contract/boxed';
+ * 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
+ *             )
+ *           ));
+ *         }
+ *       });
+ *     },
+ *   },
+ * });
+ *
+ * // Use with Temporal Worker
+ * import { Worker } from '@temporalio/worker';
+ *
+ * const worker = await Worker.create({
+ *   workflowsPath: require.resolve('./workflows'),
+ *   activities: activities,
+ *   taskQueue: contract.taskQueue,
+ * });
+ * ```
+ */
+declare function declareActivitiesHandler<TContract extends ContractDefinition>(options: DeclareActivitiesHandlerOptions<TContract>): ActivitiesHandler<TContract>;
+//#endregion
+export { ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler };

package/dist/activity.d.mts

@@ -1,3 +1,98 @@
-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 };
+import { g as WorkerInferOutput, h as WorkerInferInput, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-C1RFkCuD.mjs";
+import { Future, Result } from "@temporal-contract/boxed";
+import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
+
+//#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
+ *
+ * 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.
+ */
+type BoxedActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Future<Result<WorkerInferOutput<TActivity>, ActivityError>>;
+/**
+ * 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]> };
+/**
+ * Options for creating activities handler
+ */
+interface DeclareActivitiesHandlerOptions<TContract extends ContractDefinition> {
+  contract: TContract;
+  activities: ContractBoxedActivitiesImplementations<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]> };
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+/**
+ * Activities handler ready for Temporal Worker
+ *
+ * Flat structure: all activities (global + all workflow-specific) are at the root level
+ */
+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
+ *
+ * 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)
+ *
+ * TypeScript ensures ALL activities (global + workflow-specific) are implemented.
+ *
+ * Use this to create the activities object for the Temporal Worker.
+ *
+ * @example
+ * ```ts
+ * import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
+ * import { Result, Future } from '@temporal-contract/boxed';
+ * 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
+ *             )
+ *           ));
+ *         }
+ *       });
+ *     },
+ *   },
+ * });
+ *
+ * // Use with Temporal Worker
+ * import { Worker } from '@temporalio/worker';
+ *
+ * const worker = await Worker.create({
+ *   workflowsPath: require.resolve('./workflows'),
+ *   activities: activities,
+ *   taskQueue: contract.taskQueue,
+ * });
+ * ```
+ */
+declare function declareActivitiesHandler<TContract extends ContractDefinition>(options: DeclareActivitiesHandlerOptions<TContract>): ActivitiesHandler<TContract>;
+//#endregion
+export { ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler };

package/dist/activity.mjs

@@ -1,4 +1,105 @@
-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";
+import { n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-BqVTpfcf.mjs";
 
-export { ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, AsyncData, Future, Option, Result, WorkerError, declareActivitiesHandler };
+//#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
+*
+* 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)
+*
+* TypeScript ensures ALL activities (global + workflow-specific) are implemented.
+*
+* Use this to create the activities object for the Temporal Worker.
+*
+* @example
+* ```ts
+* import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
+* import { Result, Future } from '@temporal-contract/boxed';
+* 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
+*             )
+*           ));
+*         }
+*       });
+*     },
+*   },
+* });
+*
+* // Use with Temporal Worker
+* import { Worker } from '@temporalio/worker';
+*
+* const worker = await Worker.create({
+*   workflowsPath: require.resolve('./workflows'),
+*   activities: activities,
+*   taskQueue: contract.taskQueue,
+* });
+* ```
+*/
+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 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;
+		};
+	}
+	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 ActivityDefinitionNotFoundError(activityName, Object.keys(contract.activities));
+		wrappedActivities[activityName] = makeWrapped(activityName, activityDef, impl);
+	}
+	if (contract.workflows) for (const [workflowName, workflowDef] of Object.entries(contract.workflows)) {
+		const wfActivitiesImpl = activities[workflowName];
+		if (!wfActivitiesImpl) continue;
+		const wfDefs = workflowDef.activities ?? {};
+		for (const [activityName, impl] of Object.entries(wfActivitiesImpl)) {
+			const activityDef = wfDefs[activityName];
+			if (!activityDef) throw new ActivityDefinitionNotFoundError(`${workflowName}.${activityName}`, Object.keys(wfDefs));
+			wrappedActivities[activityName] = makeWrapped(`${workflowName}.${activityName}`, activityDef, impl);
+		}
+	}
+	return wrappedActivities;
+}
+
+//#endregion
+export { ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler };