@temporal-contract/worker 0.0.7 → 0.2.0

package/dist/workflow.mjs

@@ -1,4 +1,4 @@
-import { a as ChildWorkflowNotFoundError, c as SignalInputValidationError, d as WorkflowInputValidationError, f as WorkflowOutputValidationError, i as ChildWorkflowError, l as UpdateInputValidationError, n as ActivityInputValidationError, o as QueryInputValidationError, r as ActivityOutputValidationError, s as QueryOutputValidationError, u as UpdateOutputValidationError } from "./errors-BqVTpfcf.mjs";
+import { a as ChildWorkflowNotFoundError, c as SignalInputValidationError, d as WorkflowInputValidationError, f as WorkflowOutputValidationError, i as ChildWorkflowError, l as UpdateInputValidationError, n as ActivityInputValidationError, o as QueryInputValidationError, r as ActivityOutputValidationError, s as QueryOutputValidationError, u as UpdateOutputValidationError } from "./errors-Di6Ja4Rt.mjs";
 import { Future, Result } from "@temporal-contract/boxed";
 import { defineQuery, defineSignal, defineUpdate, executeChild, proxyActivities, setHandler, startChild, workflowInfo } from "@temporalio/workflow";
 
@@ -17,53 +17,53 @@ import { defineQuery, defineSignal, defineUpdate, executeChild, proxyActivities,
 * @example
 * ```ts
 * // workflows/processOrder.ts
-* import { declareWorkflow } from '@temporal-contract/worker';
+* import { declareWorkflow } from '@temporal-contract/worker/workflow';
 * import myContract from '../contract';
 *
 * export const processOrder = declareWorkflow({
 *   workflowName: 'processOrder',
 *   contract: myContract,
-*   implementation: async (context, orderId, customerId) => {
+*   activityOptions: {
+*     startToCloseTimeout: '1 minute',
+*   },
+*   implementation: async (context, args) => {
 *     // context.activities: typed activities (workflow + global)
 *     // context.info: WorkflowInfo
 *
-*     const inventory = await context.activities.validateInventory(orderId);
+*     const inventory = await context.activities.validateInventory({
+*       orderId: args.orderId,
+*     });
 *
 *     if (!inventory.available) {
-*       throw new Error('Out of stock');
+*       return { orderId: args.orderId, status: 'out_of_stock' };
 *     }
 *
-*     const payment = await context.activities.chargePayment(customerId, 100);
-*
-*     // Global activity
-*     await context.activities.sendEmail(
-*       customerId,
-*       'Order processed',
-*       'Your order has been processed'
-*     );
+*     const payment = await context.activities.chargePayment({
+*       customerId: args.customerId,
+*       amount: 100,
+*     });
 *
 *     return {
-*       orderId,
+*       orderId: args.orderId,
 *       status: payment.success ? 'success' : 'failed',
 *       transactionId: payment.transactionId,
 *     };
 *   },
-*   activityOptions: {
-*     startToCloseTimeout: '1 minute',
-*   },
 * });
 * ```
 *
 * Then in your worker setup:
 * ```ts
 * // worker.ts
-* import { Worker } from '@temporalio/worker';
-* import { activitiesHandler } from './activities';
+* import { createWorker } from '@temporal-contract/worker/worker';
+* import { activities } from './activities';
+* import myContract from './contract';
 *
-* const worker = await Worker.create({
-*   workflowsPath: require.resolve('./workflows'), // Imports processOrder
-*   activities: activitiesHandler.activities,
-*   taskQueue: activitiesHandler.contract.taskQueue,
+* const worker = await createWorker({
+*   contract: myContract,
+*   connection,
+*   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows.js'),
+*   activities,
 * });
 * ```
 */
@@ -76,20 +76,20 @@ function declareWorkflow({ workflowName, contract, implementation, activityOptio
 		const validatedInput = inputResult.value;
 		let contextActivities = {};
 		if (definition.activities || contract.activities) contextActivities = createValidatedActivities(proxyActivities(activityOptions), definition.activities, contract.activities);
-		async function validateChildWorkflowOutput(childDefinition, result$1, childWorkflowName) {
-			const outputResult$1 = await childDefinition.output["~standard"].validate(result$1);
-			if (outputResult$1.issues) return Result.Error(new ChildWorkflowError(`Child workflow "${childWorkflowName}" output validation failed: ${outputResult$1.issues.map((i) => i.message).join("; ")}`));
-			return Result.Ok(outputResult$1.value);
+		async function validateChildWorkflowOutput(childDefinition, result, childWorkflowName) {
+			const outputResult = await childDefinition.output["~standard"].validate(result);
+			if (outputResult.issues) return Result.Error(new ChildWorkflowError(`Child workflow "${childWorkflowName}" output validation failed: ${outputResult.issues.map((i) => i.message).join("; ")}`));
+			return Result.Ok(outputResult.value);
 		}
-		async function getAndValidateChildWorkflow(childContract, childWorkflowName, args$1) {
+		async function getAndValidateChildWorkflow(childContract, childWorkflowName, args) {
 			const childDefinition = childContract.workflows[childWorkflowName];
 			if (!childDefinition) return Result.Error(new ChildWorkflowNotFoundError(String(childWorkflowName), Object.keys(childContract.workflows)));
-			const inputResult$1 = await childDefinition.input["~standard"].validate(args$1);
-			if (inputResult$1.issues) return Result.Error(new ChildWorkflowError(`Child workflow "${String(childWorkflowName)}" input validation failed: ${inputResult$1.issues.map((i) => i.message).join("; ")}`));
-			const validatedInput$1 = inputResult$1.value;
+			const inputResult = await childDefinition.input["~standard"].validate(args);
+			if (inputResult.issues) return Result.Error(new ChildWorkflowError(`Child workflow "${String(childWorkflowName)}" input validation failed: ${inputResult.issues.map((i) => i.message).join("; ")}`));
+			const validatedInput = inputResult.value;
 			return Result.Ok({
 				definition: childDefinition,
-				validatedInput: validatedInput$1,
+				validatedInput,
 				taskQueue: childContract.taskQueue
 			});
 		}
@@ -97,107 +97,92 @@ function declareWorkflow({ workflowName, contract, implementation, activityOptio
 			return {
 				workflowId: handle.workflowId,
 				result: () => {
-					return Future.make((resolve) => {
-						(async () => {
-							try {
-								resolve(await validateChildWorkflowOutput(childDefinition, await handle.result(), childWorkflowName));
-							} catch (error) {
-								resolve(Result.Error(new ChildWorkflowError(`Child workflow execution failed: ${error instanceof Error ? error.message : String(error)}`, error)));
-							}
-						})();
+					return Future.fromAsync(async () => {
+						try {
+							return validateChildWorkflowOutput(childDefinition, await handle.result(), childWorkflowName);
+						} catch (error) {
+							return Result.Error(new ChildWorkflowError(`Child workflow execution failed: ${error instanceof Error ? error.message : String(error)}`, error));
+						}
 					});
 				}
 			};
 		}
 		function createStartChildWorkflow(childContract, childWorkflowName, options) {
-			return Future.make((resolve) => {
-				(async () => {
-					const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options.args);
-					if (validationResult.isError()) {
-						resolve(Result.Error(validationResult.error));
-						return;
-					}
-					const { definition: childDefinition, validatedInput: validatedInput$1, taskQueue } = validationResult.value;
-					try {
-						const { args: _args, ...temporalOptions } = options;
-						const typedHandle = createTypedChildHandle(await startChild(childWorkflowName, {
-							...temporalOptions,
-							taskQueue,
-							args: [validatedInput$1]
-						}), childDefinition, String(childWorkflowName));
-						resolve(Result.Ok(typedHandle));
-					} catch (error) {
-						resolve(Result.Error(new ChildWorkflowError(`Failed to start child workflow: ${error instanceof Error ? error.message : String(error)}`, error)));
-					}
-				})();
+			return Future.fromAsync(async () => {
+				const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options.args);
+				if (validationResult.isError()) return Result.Error(validationResult.error);
+				const { definition: childDefinition, validatedInput, taskQueue } = validationResult.value;
+				try {
+					const { args: _args, ...temporalOptions } = options;
+					const typedHandle = createTypedChildHandle(await startChild(childWorkflowName, {
+						...temporalOptions,
+						taskQueue,
+						args: [validatedInput]
+					}), childDefinition, String(childWorkflowName));
+					return Result.Ok(typedHandle);
+				} catch (error) {
+					return Result.Error(new ChildWorkflowError(`Failed to start child workflow: ${error instanceof Error ? error.message : String(error)}`, error));
+				}
 			});
 		}
 		function createExecuteChildWorkflow(childContract, childWorkflowName, options) {
-			return Future.make((resolve) => {
-				(async () => {
-					const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options.args);
-					if (validationResult.isError()) {
-						resolve(Result.Error(validationResult.error));
-						return;
-					}
-					const { definition: childDefinition, validatedInput: validatedInput$1, taskQueue } = validationResult.value;
-					try {
-						const { args: _args, ...temporalOptions } = options;
-						const outputValidationResult = await validateChildWorkflowOutput(childDefinition, await executeChild(childWorkflowName, {
-							...temporalOptions,
-							taskQueue,
-							args: [validatedInput$1]
-						}), String(childWorkflowName));
-						if (outputValidationResult.isError()) {
-							resolve(Result.Error(outputValidationResult.error));
-							return;
-						}
-						resolve(Result.Ok(outputValidationResult.value));
-					} catch (error) {
-						resolve(Result.Error(new ChildWorkflowError(`Failed to execute child workflow: ${error instanceof Error ? error.message : String(error)}`, error)));
-					}
-				})();
+			return Future.fromAsync(async () => {
+				const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options.args);
+				if (validationResult.isError()) return Result.Error(validationResult.error);
+				const { definition: childDefinition, validatedInput, taskQueue } = validationResult.value;
+				try {
+					const { args: _args, ...temporalOptions } = options;
+					const outputValidationResult = await validateChildWorkflowOutput(childDefinition, await executeChild(childWorkflowName, {
+						...temporalOptions,
+						taskQueue,
+						args: [validatedInput]
+					}), String(childWorkflowName));
+					if (outputValidationResult.isError()) return Result.Error(outputValidationResult.error);
+					return Result.Ok(outputValidationResult.value);
+				} catch (error) {
+					return Result.Error(new ChildWorkflowError(`Failed to execute child workflow: ${error instanceof Error ? error.message : String(error)}`, error));
+				}
 			});
 		}
 		function createDefineSignal(signalName, handler) {
 			if (!definition.signals) throw new Error(`Signal "${String(signalName)}" cannot be defined: workflow "${String(workflowName)}" has no signals in its contract`);
 			const signalDef = definition.signals[signalName];
 			if (!signalDef) throw new Error(`Signal "${String(signalName)}" not found in workflow "${String(workflowName)}" contract`);
-			setHandler(defineSignal(signalName), async (...args$1) => {
-				const input$1 = args$1.length === 1 ? args$1[0] : args$1;
-				const inputResult$1 = await signalDef.input["~standard"].validate(input$1);
-				if (inputResult$1.issues) throw new SignalInputValidationError(signalName, inputResult$1.issues);
-				await handler(inputResult$1.value);
+			setHandler(defineSignal(signalName), async (...args) => {
+				const input = args.length === 1 ? args[0] : args;
+				const inputResult = await signalDef.input["~standard"].validate(input);
+				if (inputResult.issues) throw new SignalInputValidationError(signalName, inputResult.issues);
+				await handler(inputResult.value);
 			});
 		}
 		function createDefineQuery(queryName, handler) {
 			if (!definition.queries) throw new Error(`Query "${String(queryName)}" cannot be defined: workflow "${String(workflowName)}" has no queries in its contract`);
 			const queryDef = definition.queries[queryName];
 			if (!queryDef) throw new Error(`Query "${String(queryName)}" not found in workflow "${String(workflowName)}" contract`);
-			setHandler(defineQuery(queryName), (...args$1) => {
-				const input$1 = args$1.length === 1 ? args$1[0] : args$1;
-				const inputResult$1 = queryDef.input["~standard"].validate(input$1);
-				if (inputResult$1 instanceof Promise) throw new Error(`Query "${String(queryName)}" validation must be synchronous. Use a schema library that supports synchronous validation for queries.`);
-				if (inputResult$1.issues) throw new QueryInputValidationError(queryName, inputResult$1.issues);
-				const result$1 = handler(inputResult$1.value);
-				const outputResult$1 = queryDef.output["~standard"].validate(result$1);
-				if (outputResult$1 instanceof Promise) throw new Error(`Query "${String(queryName)}" output validation must be synchronous. Use a schema library that supports synchronous validation for queries.`);
-				if (outputResult$1.issues) throw new QueryOutputValidationError(queryName, outputResult$1.issues);
-				return outputResult$1.value;
+			setHandler(defineQuery(queryName), (...args) => {
+				const input = args.length === 1 ? args[0] : args;
+				const inputResult = queryDef.input["~standard"].validate(input);
+				if (inputResult instanceof Promise) throw new Error(`Query "${String(queryName)}" validation must be synchronous. Use a schema library that supports synchronous validation for queries.`);
+				if (inputResult.issues) throw new QueryInputValidationError(queryName, inputResult.issues);
+				const result = handler(inputResult.value);
+				const outputResult = queryDef.output["~standard"].validate(result);
+				if (outputResult instanceof Promise) throw new Error(`Query "${String(queryName)}" output validation must be synchronous. Use a schema library that supports synchronous validation for queries.`);
+				if (outputResult.issues) throw new QueryOutputValidationError(queryName, outputResult.issues);
+				return outputResult.value;
 			});
 		}
 		function createDefineUpdate(updateName, handler) {
 			if (!definition.updates) throw new Error(`Update "${String(updateName)}" cannot be defined: workflow "${String(workflowName)}" has no updates in its contract`);
 			const updateDef = definition.updates[updateName];
 			if (!updateDef) throw new Error(`Update "${String(updateName)}" not found in workflow "${String(workflowName)}" contract`);
-			setHandler(defineUpdate(updateName), async (...args$1) => {
-				const input$1 = args$1.length === 1 ? args$1[0] : args$1;
-				const inputResult$1 = await updateDef.input["~standard"].validate(input$1);
-				if (inputResult$1.issues) throw new UpdateInputValidationError(updateName, inputResult$1.issues);
-				const result$1 = await handler(inputResult$1.value);
-				const outputResult$1 = await updateDef.output["~standard"].validate(result$1);
-				if (outputResult$1.issues) throw new UpdateOutputValidationError(updateName, outputResult$1.issues);
-				return outputResult$1.value;
+			setHandler(defineUpdate(updateName), async (...args) => {
+				const input = args.length === 1 ? args[0] : args;
+				const inputResult = await updateDef.input["~standard"].validate(input);
+				if (inputResult.issues) throw new UpdateInputValidationError(updateName, inputResult.issues);
+				const result = await handler(inputResult.value);
+				const outputResult = await updateDef.output["~standard"].validate(result);
+				if (outputResult.issues) throw new UpdateOutputValidationError(updateName, outputResult.issues);
+				return outputResult.value;
 			});
 		}
 		const result = await implementation({
@@ -242,4 +227,5 @@ function createValidatedActivities(rawActivities, workflowActivitiesDefinition,
 }
 
 //#endregion
-export { ActivityInputValidationError, ActivityOutputValidationError, ChildWorkflowError, ChildWorkflowNotFoundError, QueryInputValidationError, QueryOutputValidationError, SignalInputValidationError, UpdateInputValidationError, UpdateOutputValidationError, WorkflowInputValidationError, WorkflowOutputValidationError, declareWorkflow };
+export { ActivityInputValidationError, ActivityOutputValidationError, ChildWorkflowError, ChildWorkflowNotFoundError, QueryInputValidationError, QueryOutputValidationError, SignalInputValidationError, UpdateInputValidationError, UpdateOutputValidationError, WorkflowInputValidationError, WorkflowOutputValidationError, declareWorkflow };
+//# sourceMappingURL=workflow.mjs.map

package/dist/workflow.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.mjs","names":[],"sources":["../src/workflow.ts"],"sourcesContent":["// Entry point for workflows\nimport {\n  ActivityDefinition,\n  ContractDefinition,\n  QueryDefinition,\n  SignalDefinition,\n  UpdateDefinition,\n  WorkflowDefinition,\n} from \"@temporal-contract/contract\";\nimport {\n  ActivityInputValidationError,\n  ActivityOutputValidationError,\n  ChildWorkflowError,\n  ChildWorkflowNotFoundError,\n  QueryInputValidationError,\n  QueryOutputValidationError,\n  SignalInputValidationError,\n  UpdateInputValidationError,\n  UpdateOutputValidationError,\n  WorkflowInputValidationError,\n  WorkflowOutputValidationError,\n} from \"./errors.js\";\nimport {\n  ClientInferInput,\n  ClientInferOutput,\n  WorkerInferInput,\n  WorkerInferOutput,\n} from \"./types.js\";\nimport { Future, Result } from \"@temporal-contract/boxed\";\nimport {\n  ActivityOptions,\n  ChildWorkflowHandle,\n  ChildWorkflowOptions,\n  defineQuery,\n  defineSignal,\n  defineUpdate,\n  executeChild,\n  proxyActivities,\n  setHandler,\n  startChild,\n  WorkflowInfo,\n  workflowInfo,\n} from \"@temporalio/workflow\";\nimport { StandardSchemaV1 } from \"@standard-schema/spec\";\n\nexport {\n  ActivityInputValidationError,\n  ActivityOutputValidationError,\n  ChildWorkflowError,\n  ChildWorkflowNotFoundError,\n  QueryInputValidationError,\n  QueryOutputValidationError,\n  SignalInputValidationError,\n  UpdateInputValidationError,\n  UpdateOutputValidationError,\n  WorkflowInputValidationError,\n  WorkflowOutputValidationError,\n} from \"./errors.js\";\n\n/**\n * Create a typed workflow implementation with automatic validation\n *\n * This wraps a workflow implementation with:\n * - Input/output validation\n * - Typed workflow context with activities\n * - Workflow info access\n *\n * Workflows must be defined in separate files and imported by the Temporal Worker\n * via workflowsPath.\n *\n * @example\n * ```ts\n * // workflows/processOrder.ts\n * import { declareWorkflow } from '@temporal-contract/worker/workflow';\n * import myContract from '../contract';\n *\n * export const processOrder = declareWorkflow({\n *   workflowName: 'processOrder',\n *   contract: myContract,\n *   activityOptions: {\n *     startToCloseTimeout: '1 minute',\n *   },\n *   implementation: async (context, args) => {\n *     // context.activities: typed activities (workflow + global)\n *     // context.info: WorkflowInfo\n *\n *     const inventory = await context.activities.validateInventory({\n *       orderId: args.orderId,\n *     });\n *\n *     if (!inventory.available) {\n *       return { orderId: args.orderId, status: 'out_of_stock' };\n *     }\n *\n *     const payment = await context.activities.chargePayment({\n *       customerId: args.customerId,\n *       amount: 100,\n *     });\n *\n *     return {\n *       orderId: args.orderId,\n *       status: payment.success ? 'success' : 'failed',\n *       transactionId: payment.transactionId,\n *     };\n *   },\n * });\n * ```\n *\n * Then in your worker setup:\n * ```ts\n * // worker.ts\n * import { createWorker } from '@temporal-contract/worker/worker';\n * import { activities } from './activities';\n * import myContract from './contract';\n *\n * const worker = await createWorker({\n *   contract: myContract,\n *   connection,\n *   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows.js'),\n *   activities,\n * });\n * ```\n */\nexport function declareWorkflow<\n  TContract extends ContractDefinition,\n  TWorkflowName extends keyof TContract[\"workflows\"],\n>({\n  workflowName,\n  contract,\n  implementation,\n  activityOptions,\n}: DeclareWorkflowOptions<TContract, TWorkflowName>): (\n  ...args: unknown[]\n) => Promise<WorkerInferOutput<TContract[\"workflows\"][TWorkflowName]>> {\n  // Get the workflow definition from the contract\n  const definition = contract.workflows[\n    workflowName as string\n  ] as TContract[\"workflows\"][TWorkflowName];\n\n  return async (...args: unknown[]) => {\n    // Extract single parameter (Temporal passes arguments as array)\n    const input = args.length === 1 ? args[0] : args;\n\n    // Validate workflow input\n    const inputResult = await definition.input[\"~standard\"].validate(input);\n    if (inputResult.issues) {\n      throw new WorkflowInputValidationError(String(workflowName), inputResult.issues);\n    }\n    const validatedInput = inputResult.value as WorkerInferInput<\n      TContract[\"workflows\"][TWorkflowName]\n    >;\n\n    // Create activities proxy with validation if activities are defined.\n    //\n    // Design note — intentional double-validation:\n    // Input and output are validated here (workflow side) AND again inside\n    // `declareActivitiesHandler` (activity worker side). This is deliberate:\n    //\n    // 1. Workflow-side validation catches bad data *before* it crosses the\n    //    task-queue network boundary, giving an early, descriptive error\n    //    instead of a confusing deserialization failure inside the activity.\n    // 2. Activity-side validation is the authoritative guard, since the\n    //    activity may be called by other callers that do not use this library.\n    //\n    // The overhead is minimal relative to the network round-trip.\n    let contextActivities: unknown = {};\n\n    if (definition.activities || contract.activities) {\n      const rawActivities =\n        proxyActivities<Record<string, (...args: unknown[]) => Promise<unknown>>>(activityOptions);\n\n      contextActivities = createValidatedActivities(\n        rawActivities,\n        definition.activities,\n        contract.activities,\n      );\n    }\n\n    // Helper to validate child workflow output\n    async function validateChildWorkflowOutput<TChildWorkflow extends WorkflowDefinition>(\n      childDefinition: TChildWorkflow,\n      result: unknown,\n      childWorkflowName: string,\n    ): Promise<Result<ClientInferOutput<TChildWorkflow>, ChildWorkflowError>> {\n      const outputResult = await childDefinition.output[\"~standard\"].validate(result);\n      if (outputResult.issues) {\n        return Result.Error(\n          new ChildWorkflowError(\n            `Child workflow \"${childWorkflowName}\" output validation failed: ${outputResult.issues.map((i: StandardSchemaV1.Issue) => i.message).join(\"; \")}`,\n          ),\n        );\n      }\n      return Result.Ok(outputResult.value as WorkerInferOutput<TChildWorkflow>);\n    }\n\n    // Helper to get and validate child workflow definition and input\n    async function getAndValidateChildWorkflow<\n      TChildContract extends ContractDefinition,\n      TChildWorkflowName extends keyof TChildContract[\"workflows\"],\n    >(\n      childContract: TChildContract,\n      childWorkflowName: TChildWorkflowName,\n      args: unknown,\n    ): Promise<\n      Result<\n        {\n          definition: TChildContract[\"workflows\"][TChildWorkflowName];\n          validatedInput: WorkerInferInput<TChildContract[\"workflows\"][TChildWorkflowName]>;\n          taskQueue: string;\n        },\n        ChildWorkflowError\n      >\n    > {\n      const childDefinition = childContract.workflows[childWorkflowName as string];\n\n      if (!childDefinition) {\n        return Result.Error(\n          new ChildWorkflowNotFoundError(\n            String(childWorkflowName),\n            Object.keys(childContract.workflows) as string[],\n          ),\n        );\n      }\n\n      const inputResult = await childDefinition.input[\"~standard\"].validate(args);\n      if (inputResult.issues) {\n        return Result.Error(\n          new ChildWorkflowError(\n            `Child workflow \"${String(childWorkflowName)}\" input validation failed: ${inputResult.issues.map((i: StandardSchemaV1.Issue) => i.message).join(\"; \")}`,\n          ),\n        );\n      }\n\n      const validatedInput = inputResult.value as WorkerInferInput<\n        TChildContract[\"workflows\"][TChildWorkflowName]\n      >;\n\n      return Result.Ok({\n        definition: childDefinition as TChildContract[\"workflows\"][TChildWorkflowName],\n        validatedInput,\n        taskQueue: childContract.taskQueue,\n      });\n    }\n\n    // Helper function to create a typed child workflow handle\n    function createTypedChildHandle<TChildWorkflow extends WorkflowDefinition>(\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      handle: ChildWorkflowHandle<any>,\n      childDefinition: TChildWorkflow,\n      childWorkflowName: string,\n    ): TypedChildWorkflowHandle<TChildWorkflow> {\n      return {\n        workflowId: handle.workflowId,\n        result: (): Future<Result<ClientInferOutput<TChildWorkflow>, ChildWorkflowError>> => {\n          return Future.fromAsync(async () => {\n            try {\n              const result = await handle.result();\n              return validateChildWorkflowOutput(childDefinition, result, childWorkflowName);\n            } catch (error) {\n              return Result.Error(\n                new ChildWorkflowError(\n                  `Child workflow execution failed: ${error instanceof Error ? error.message : String(error)}`,\n                  error,\n                ),\n              );\n            }\n          });\n        },\n      };\n    }\n\n    // Helper function to start a child workflow\n    function createStartChildWorkflow<\n      TChildContract extends ContractDefinition,\n      TChildWorkflowName extends keyof TChildContract[\"workflows\"],\n    >(\n      childContract: TChildContract,\n      childWorkflowName: TChildWorkflowName,\n      options: TypedChildWorkflowOptions<TChildContract, TChildWorkflowName>,\n    ): Future<\n      Result<\n        TypedChildWorkflowHandle<TChildContract[\"workflows\"][TChildWorkflowName]>,\n        ChildWorkflowError\n      >\n    > {\n      return Future.fromAsync(async () => {\n        // Validate input and get definition\n        const validationResult = await getAndValidateChildWorkflow(\n          childContract,\n          childWorkflowName,\n          options.args,\n        );\n\n        if (validationResult.isError()) {\n          return Result.Error(validationResult.error);\n        }\n\n        const { definition: childDefinition, validatedInput, taskQueue } = validationResult.value;\n\n        try {\n          // Start child workflow (Temporal expects args as array)\n          const { args: _args, ...temporalOptions } = options;\n          const handle = await startChild(childWorkflowName as string, {\n            ...temporalOptions,\n            taskQueue,\n            args: [validatedInput],\n          });\n\n          const typedHandle = createTypedChildHandle(\n            handle,\n            childDefinition,\n            String(childWorkflowName),\n          ) as TypedChildWorkflowHandle<TChildContract[\"workflows\"][TChildWorkflowName]>;\n\n          return Result.Ok(typedHandle);\n        } catch (error) {\n          return Result.Error(\n            new ChildWorkflowError(\n              `Failed to start child workflow: ${error instanceof Error ? error.message : String(error)}`,\n              error,\n            ),\n          );\n        }\n      });\n    }\n\n    // Helper function to execute a child workflow\n    function createExecuteChildWorkflow<\n      TChildContract extends ContractDefinition,\n      TChildWorkflowName extends keyof TChildContract[\"workflows\"],\n    >(\n      childContract: TChildContract,\n      childWorkflowName: TChildWorkflowName,\n      options: TypedChildWorkflowOptions<TChildContract, TChildWorkflowName>,\n    ): Future<\n      Result<ClientInferOutput<TChildContract[\"workflows\"][TChildWorkflowName]>, ChildWorkflowError>\n    > {\n      return Future.fromAsync(async () => {\n        // Validate input and get definition\n        const validationResult = await getAndValidateChildWorkflow(\n          childContract,\n          childWorkflowName,\n          options.args,\n        );\n\n        if (validationResult.isError()) {\n          return Result.Error(validationResult.error);\n        }\n\n        const { definition: childDefinition, validatedInput, taskQueue } = validationResult.value;\n\n        try {\n          // Execute child workflow (Temporal expects args as array)\n          const { args: _args, ...temporalOptions } = options;\n          const result = await executeChild(childWorkflowName as string, {\n            ...temporalOptions,\n            taskQueue,\n            args: [validatedInput],\n          });\n\n          // Validate output with Standard Schema\n          const outputValidationResult = await validateChildWorkflowOutput(\n            childDefinition,\n            result,\n            String(childWorkflowName),\n          );\n\n          if (outputValidationResult.isError()) {\n            return Result.Error(outputValidationResult.error);\n          }\n\n          return Result.Ok(\n            outputValidationResult.value as ClientInferOutput<\n              TChildContract[\"workflows\"][TChildWorkflowName]\n            >,\n          );\n        } catch (error) {\n          return Result.Error(\n            new ChildWorkflowError(\n              `Failed to execute child workflow: ${error instanceof Error ? error.message : String(error)}`,\n              error,\n            ),\n          );\n        }\n      });\n    }\n\n    // Context methods for defining signals, queries, and updates\n    function createDefineSignal<\n      TSignalName extends keyof TContract[\"workflows\"][TWorkflowName][\"signals\"],\n    >(\n      signalName: TSignalName,\n      handler: SignalHandlerImplementation<\n        TContract[\"workflows\"][TWorkflowName][\"signals\"][TSignalName] extends SignalDefinition\n          ? TContract[\"workflows\"][TWorkflowName][\"signals\"][TSignalName]\n          : never\n      >,\n    ): void {\n      if (!definition.signals) {\n        throw new Error(\n          `Signal \"${String(signalName)}\" cannot be defined: workflow \"${String(workflowName)}\" has no signals in its contract`,\n        );\n      }\n\n      const signalDef = (definition.signals as Record<string, SignalDefinition>)[\n        signalName as string\n      ];\n      if (!signalDef) {\n        throw new Error(\n          `Signal \"${String(signalName)}\" not found in workflow \"${String(workflowName)}\" contract`,\n        );\n      }\n\n      const signal = defineSignal(signalName as string);\n      setHandler(signal, async (...args: unknown[]) => {\n        // Extract single parameter (Temporal passes as args array)\n        const input = args.length === 1 ? args[0] : args;\n        const inputResult = await signalDef.input[\"~standard\"].validate(input);\n        if (inputResult.issues) {\n          throw new SignalInputValidationError(signalName as string, inputResult.issues);\n        }\n        await (handler as SignalHandlerImplementation<SignalDefinition>)(inputResult.value);\n      });\n    }\n\n    function createDefineQuery<\n      TQueryName extends keyof TContract[\"workflows\"][TWorkflowName][\"queries\"],\n    >(\n      queryName: TQueryName,\n      handler: QueryHandlerImplementation<\n        TContract[\"workflows\"][TWorkflowName][\"queries\"][TQueryName] extends QueryDefinition\n          ? TContract[\"workflows\"][TWorkflowName][\"queries\"][TQueryName]\n          : never\n      >,\n    ): void {\n      if (!definition.queries) {\n        throw new Error(\n          `Query \"${String(queryName)}\" cannot be defined: workflow \"${String(workflowName)}\" has no queries in its contract`,\n        );\n      }\n\n      const queryDef = (definition.queries as Record<string, QueryDefinition>)[queryName as string];\n      if (!queryDef) {\n        throw new Error(\n          `Query \"${String(queryName)}\" not found in workflow \"${String(workflowName)}\" contract`,\n        );\n      }\n\n      const query = defineQuery(queryName as string);\n      setHandler(query, (...args: unknown[]) => {\n        // Extract single parameter (Temporal passes as args array)\n        const input = args.length === 1 ? args[0] : args;\n        // Note: Query handlers must be synchronous, so we need to handle validation synchronously\n        const inputResult = queryDef.input[\"~standard\"].validate(input);\n\n        // Handle both sync and async validation results\n        if (inputResult instanceof Promise) {\n          throw new Error(\n            `Query \"${String(queryName)}\" validation must be synchronous. Use a schema library that supports synchronous validation for queries.`,\n          );\n        }\n\n        if (inputResult.issues) {\n          throw new QueryInputValidationError(queryName as string, inputResult.issues);\n        }\n\n        const result = handler(inputResult.value);\n\n        const outputResult = queryDef.output[\"~standard\"].validate(result);\n        if (outputResult instanceof Promise) {\n          throw new Error(\n            `Query \"${String(queryName)}\" output validation must be synchronous. Use a schema library that supports synchronous validation for queries.`,\n          );\n        }\n\n        if (outputResult.issues) {\n          throw new QueryOutputValidationError(queryName as string, outputResult.issues);\n        }\n\n        return outputResult.value;\n      });\n    }\n\n    function createDefineUpdate<\n      TUpdateName extends keyof TContract[\"workflows\"][TWorkflowName][\"updates\"],\n    >(\n      updateName: TUpdateName,\n      handler: UpdateHandlerImplementation<\n        TContract[\"workflows\"][TWorkflowName][\"updates\"][TUpdateName] extends UpdateDefinition\n          ? TContract[\"workflows\"][TWorkflowName][\"updates\"][TUpdateName]\n          : never\n      >,\n    ): void {\n      if (!definition.updates) {\n        throw new Error(\n          `Update \"${String(updateName)}\" cannot be defined: workflow \"${String(workflowName)}\" has no updates in its contract`,\n        );\n      }\n\n      const updateDef = (definition.updates as Record<string, UpdateDefinition>)[\n        updateName as string\n      ];\n      if (!updateDef) {\n        throw new Error(\n          `Update \"${String(updateName)}\" not found in workflow \"${String(workflowName)}\" contract`,\n        );\n      }\n\n      const update = defineUpdate(updateName as string);\n      setHandler(update, async (...args: unknown[]) => {\n        // Extract single parameter (Temporal passes as args array)\n        const input = args.length === 1 ? args[0] : args;\n        const inputResult = await updateDef.input[\"~standard\"].validate(input);\n        if (inputResult.issues) {\n          throw new UpdateInputValidationError(updateName as string, inputResult.issues);\n        }\n\n        const result = await handler(inputResult.value);\n\n        const outputResult = await updateDef.output[\"~standard\"].validate(result);\n        if (outputResult.issues) {\n          throw new UpdateOutputValidationError(updateName as string, outputResult.issues);\n        }\n\n        return outputResult.value;\n      });\n    }\n\n    // Create workflow context\n    const context: WorkflowContext<TContract, TWorkflowName> = {\n      activities: contextActivities as WorkflowInferWorkflowContextActivities<\n        TContract,\n        TWorkflowName\n      >,\n      info: workflowInfo(),\n      startChildWorkflow: createStartChildWorkflow,\n      executeChildWorkflow: createExecuteChildWorkflow,\n      defineSignal: createDefineSignal as WorkflowContext<TContract, TWorkflowName>[\"defineSignal\"],\n      defineQuery: createDefineQuery as WorkflowContext<TContract, TWorkflowName>[\"defineQuery\"],\n      defineUpdate: createDefineUpdate as WorkflowContext<TContract, TWorkflowName>[\"defineUpdate\"],\n    };\n\n    // Execute workflow (pass validated input as tuple)\n    const result = await implementation(context, validatedInput);\n\n    // Validate workflow output\n    const outputResult = await definition.output[\"~standard\"].validate(result);\n    if (outputResult.issues) {\n      throw new WorkflowOutputValidationError(String(workflowName), outputResult.issues);\n    }\n\n    return outputResult.value as WorkerInferOutput<TContract[\"workflows\"][TWorkflowName]>;\n  };\n}\n\n/**\n * Signal handler implementation\n *\n * Processes signal input and can optionally perform asynchronous operations.\n * Should not return a value (signals are fire-and-forget).\n */\ntype SignalHandlerImplementation<TSignal extends SignalDefinition> = (\n  args: WorkerInferInput<TSignal>,\n) => void | Promise<void>;\n\n/**\n * Query handler implementation\n *\n * Processes query input and returns a synchronous response.\n * Must be synchronous to satisfy Temporal's query constraints.\n */\ntype QueryHandlerImplementation<TQuery extends QueryDefinition> = (\n  args: WorkerInferInput<TQuery>,\n) => WorkerInferOutput<TQuery>;\n\n/**\n * Update handler implementation\n *\n * Processes update input and returns a validated response after modifying workflow state.\n * Can perform asynchronous operations.\n */\ntype UpdateHandlerImplementation<TUpdate extends UpdateDefinition> = (\n  args: WorkerInferInput<TUpdate>,\n) => Promise<WorkerInferOutput<TUpdate>>;\n\n/**\n * Options for declaring a workflow implementation\n */\ntype DeclareWorkflowOptions<\n  TContract extends ContractDefinition,\n  TWorkflowName extends keyof TContract[\"workflows\"],\n> = {\n  workflowName: TWorkflowName;\n  contract: TContract;\n  implementation: WorkflowImplementation<TContract, TWorkflowName>;\n  /**\n   * Default activity options applied to all activities in this workflow.\n   * For more control, you can override specific Temporal ActivityOptions like:\n   * - startToCloseTimeout: Maximum time for activity execution\n   * - scheduleToCloseTimeout: End-to-end timeout including queuing\n   * - scheduleToStartTimeout: Maximum time activity can wait in queue\n   * - heartbeatTimeout: Time between heartbeats before considering activity dead\n   * - retry: Retry policy for failed activities\n   *\n   * @example\n   * ```ts\n   * activityOptions: {\n   *   startToCloseTimeout: '5m',\n   *   retry: { maximumAttempts: 3 }\n   * }\n   * ```\n   */\n  activityOptions: ActivityOptions;\n};\n\n/**\n * Workflow implementation function\n *\n * Receives a workflow context (with typed activities and utilities) and validated input arguments.\n * Returns the workflow output which will be validated against the contract schema.\n */\ntype WorkflowImplementation<\n  TContract extends ContractDefinition,\n  TWorkflowName extends keyof TContract[\"workflows\"],\n> = (\n  context: WorkflowContext<TContract, TWorkflowName>,\n  args: WorkerInferInput<TContract[\"workflows\"][TWorkflowName]>,\n) => Promise<WorkerInferOutput<TContract[\"workflows\"][TWorkflowName]>>;\n\n/**\n * Workflow execution context providing typed activities, workflow info, and interaction handlers\n *\n * Provides access to:\n * - Typed activities (both workflow-specific and global)\n * - Workflow metadata and execution info\n * - Signal, query, and update handler registration\n * - Child workflow execution capabilities\n */\ntype WorkflowContext<\n  TContract extends ContractDefinition,\n  TWorkflowName extends keyof TContract[\"workflows\"],\n> = {\n  activities: WorkflowInferWorkflowContextActivities<TContract, TWorkflowName>;\n  info: WorkflowInfo;\n\n  /**\n   * Define a signal handler within the workflow implementation\n   * Allows the signal handler to access workflow state\n   *\n   * @example\n   * ```ts\n   * implementation: async (context, args) => {\n   *   let currentValue = args.initialValue;\n   *\n   *   context.defineSignal('increment', async (signalArgs) => {\n   *     currentValue += signalArgs.amount;\n   *   });\n   *\n   *   // ... rest of workflow\n   * }\n   * ```\n   */\n  defineSignal: <K extends keyof TContract[\"workflows\"][TWorkflowName][\"signals\"]>(\n    signalName: K,\n    handler: SignalHandlerImplementation<\n      TContract[\"workflows\"][TWorkflowName][\"signals\"][K] extends SignalDefinition\n        ? TContract[\"workflows\"][TWorkflowName][\"signals\"][K]\n        : never\n    >,\n  ) => void;\n\n  /**\n   * Define a query handler within the workflow implementation\n   * Allows the query handler to access workflow state\n   *\n   * @example\n   * ```ts\n   * implementation: async (context, args) => {\n   *   let currentValue = args.initialValue;\n   *\n   *   context.defineQuery('getCurrentValue', () => {\n   *     return { value: currentValue };\n   *   });\n   *\n   *   // ... rest of workflow\n   * }\n   * ```\n   */\n  defineQuery: <K extends keyof TContract[\"workflows\"][TWorkflowName][\"queries\"]>(\n    queryName: K,\n    handler: QueryHandlerImplementation<\n      TContract[\"workflows\"][TWorkflowName][\"queries\"][K] extends QueryDefinition\n        ? TContract[\"workflows\"][TWorkflowName][\"queries\"][K]\n        : never\n    >,\n  ) => void;\n\n  /**\n   * Define an update handler within the workflow implementation\n   * Allows the update handler to access and modify workflow state\n   *\n   * @example\n   * ```ts\n   * implementation: async (context, args) => {\n   *   let currentValue = args.initialValue;\n   *\n   *   context.defineUpdate('multiply', async (updateArgs) => {\n   *     currentValue *= updateArgs.factor;\n   *     return { newValue: currentValue };\n   *   });\n   *\n   *   // ... rest of workflow\n   * }\n   * ```\n   */\n  defineUpdate: <K extends keyof TContract[\"workflows\"][TWorkflowName][\"updates\"]>(\n    updateName: K,\n    handler: UpdateHandlerImplementation<\n      TContract[\"workflows\"][TWorkflowName][\"updates\"][K] extends UpdateDefinition\n        ? TContract[\"workflows\"][TWorkflowName][\"updates\"][K]\n        : never\n    >,\n  ) => void;\n\n  /**\n   * Start a child workflow and return a typed handle with Future/Result pattern\n   *\n   * Supports both same-contract and cross-contract child workflows:\n   * - Same contract: Pass workflowName from current contract\n   * - Cross-contract: Pass contract and workflowName to invoke workflows from other workers\n   *\n   * @example\n   * ```ts\n   * // Same contract child workflow\n   * const childResult = await context.startChildWorkflow(myContract, 'processPayment', {\n   *   workflowId: 'payment-123',\n   *   args: { amount: 100 }\n   * });\n   *\n   * // Cross-contract child workflow (from another worker)\n   * const otherResult = await context.startChildWorkflow(otherContract, 'sendNotification', {\n   *   workflowId: 'notification-123',\n   *   args: { message: 'Hello' }\n   * });\n   *\n   * childResult.match({\n   *   Ok: async (handle) => {\n   *     const result = await handle.result();\n   *     // ... handle result\n   *   },\n   *   Error: (error) => console.error('Failed to start:', error),\n   * });\n   * ```\n   */\n  startChildWorkflow: <\n    TChildContract extends ContractDefinition,\n    TChildWorkflowName extends keyof TChildContract[\"workflows\"],\n  >(\n    contract: TChildContract,\n    workflowName: TChildWorkflowName,\n    options: TypedChildWorkflowOptions<TChildContract, TChildWorkflowName>,\n  ) => Future<\n    Result<\n      TypedChildWorkflowHandle<TChildContract[\"workflows\"][TChildWorkflowName]>,\n      ChildWorkflowError\n    >\n  >;\n\n  /**\n   * Execute a child workflow (start and wait for result) with Future/Result pattern\n   *\n   * Supports both same-contract and cross-contract child workflows:\n   * - Same contract: Pass workflowName from current contract\n   * - Cross-contract: Pass contract and workflowName to invoke workflows from other workers\n   *\n   * @example\n   * ```ts\n   * // Same contract child workflow\n   * const result = await context.executeChildWorkflow(myContract, 'processPayment', {\n   *   workflowId: 'payment-123',\n   *   args: { amount: 100 }\n   * });\n   *\n   * // Cross-contract child workflow (from another worker)\n   * const otherResult = await context.executeChildWorkflow(otherContract, 'sendNotification', {\n   *   workflowId: 'notification-123',\n   *   args: { message: 'Hello' }\n   * });\n   *\n   * result.match({\n   *   Ok: (output) => console.log('Payment processed:', output),\n   *   Error: (error) => console.error('Processing failed:', error),\n   * });\n   * ```\n   */\n  executeChildWorkflow: <\n    TChildContract extends ContractDefinition,\n    TChildWorkflowName extends keyof TChildContract[\"workflows\"],\n  >(\n    contract: TChildContract,\n    workflowName: TChildWorkflowName,\n    options: TypedChildWorkflowOptions<TChildContract, TChildWorkflowName>,\n  ) => Future<\n    Result<ClientInferOutput<TChildContract[\"workflows\"][TChildWorkflowName]>, ChildWorkflowError>\n  >;\n};\n\n/**\n * Options for starting a child workflow\n */\ntype TypedChildWorkflowOptions<\n  TChildContract extends ContractDefinition,\n  TChildWorkflowName extends keyof TChildContract[\"workflows\"],\n> = Omit<ChildWorkflowOptions, \"taskQueue\" | \"args\"> & {\n  args: ClientInferInput<TChildContract[\"workflows\"][TChildWorkflowName]>;\n};\n\n/**\n * Typed handle for a child workflow with Future/Result pattern\n */\ntype TypedChildWorkflowHandle<TWorkflow extends WorkflowDefinition> = {\n  /**\n   * Get child workflow result with Result pattern\n   */\n  result: () => Future<Result<ClientInferOutput<TWorkflow>, ChildWorkflowError>>;\n\n  /**\n   * Child workflow ID\n   */\n  workflowId: string;\n};\n\n/**\n * Activity function signature from workflow execution perspective\n *\n * Workflows call activities with validated input (z.input parsed) and receive validated output (z.output)\n */\ntype WorkflowInferActivity<TActivity extends ActivityDefinition> = (\n  args: ClientInferInput<TActivity>,\n) => Promise<ClientInferOutput<TActivity>>;\n\n/**\n * All global activities from a contract (workflow execution perspective)\n */\ntype WorkflowInferActivities<TContract extends ContractDefinition> =\n  TContract[\"activities\"] extends Record<string, ActivityDefinition>\n    ? {\n        [K in keyof TContract[\"activities\"]]: WorkflowInferActivity<TContract[\"activities\"][K]>;\n      }\n    : {};\n\n/**\n * Workflow-specific activities (workflow execution perspective)\n */\ntype WorkflowInferWorkflowActivities<T extends WorkflowDefinition> =\n  T[\"activities\"] extends Record<string, ActivityDefinition>\n    ? {\n        [K in keyof T[\"activities\"]]: WorkflowInferActivity<T[\"activities\"][K]>;\n      }\n    : {};\n\n/**\n * All activities available in a workflow context (workflow execution perspective)\n *\n * Combines workflow-specific activities with global contract activities\n */\ntype WorkflowInferWorkflowContextActivities<\n  TContract extends ContractDefinition,\n  TWorkflowName extends keyof TContract[\"workflows\"],\n> = WorkflowInferWorkflowActivities<TContract[\"workflows\"][TWorkflowName]> &\n  WorkflowInferActivities<TContract>;\n\n/**\n * Create a validated activities proxy that parses inputs and outputs\n *\n * This wrapper ensures data integrity across the network boundary between\n * workflow and activity execution.\n */\nfunction createValidatedActivities<\n  TContract extends ContractDefinition,\n  TWorkflowName extends keyof TContract[\"workflows\"],\n>(\n  rawActivities: Record<string, (...args: unknown[]) => Promise<unknown>>,\n  workflowActivitiesDefinition: Record<string, ActivityDefinition> | undefined,\n  contractActivitiesDefinition: Record<string, ActivityDefinition> | undefined,\n): WorkflowInferWorkflowContextActivities<TContract, TWorkflowName> {\n  const validatedActivities = {} as WorkflowInferWorkflowContextActivities<\n    TContract,\n    TWorkflowName\n  >;\n\n  // Merge workflow-specific and global contract activities\n  // Workflow-specific activities take precedence over global ones\n  const allActivitiesDefinition = {\n    ...contractActivitiesDefinition,\n    ...workflowActivitiesDefinition,\n  };\n\n  for (const [activityName, activityDef] of Object.entries(allActivitiesDefinition)) {\n    const rawActivity = rawActivities[activityName];\n\n    if (!rawActivity) {\n      throw new Error(\n        `Activity implementation not found for: \"${activityName}\". ` +\n          `Available activities: ${Object.keys(rawActivities).length > 0 ? Object.keys(rawActivities).join(\", \") : \"none\"}`,\n      );\n    }\n\n    // Wrap activity with input/output validation\n    // Register the wrapped activity\n    (validatedActivities as Record<string, unknown>)[activityName] = async (input: unknown) => {\n      // Validate input before sending over the network\n      const inputResult = await activityDef.input[\"~standard\"].validate(input);\n      if (inputResult.issues) {\n        throw new ActivityInputValidationError(activityName, inputResult.issues);\n      }\n\n      // Call the actual activity with validated input\n      const result = await rawActivity(inputResult.value);\n\n      // Validate output after receiving from the network\n      const outputResult = await activityDef.output[\"~standard\"].validate(result);\n      if (outputResult.issues) {\n        throw new ActivityOutputValidationError(activityName, outputResult.issues);\n      }\n\n      return outputResult.value;\n    };\n  }\n\n  return validatedActivities;\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporal-contract/worker",
-  "version": "0.0.7",
+  "version": "0.2.0",
   "description": "Worker utilities with Result/Future pattern for implementing temporal-contract workflows and activities",
   "keywords": [
     "contract",
@@ -64,22 +64,25 @@
   "dependencies": {
     "@standard-schema/spec": "1.1.0",
     "@swan-io/boxed": "3.2.1",
-    "@temporal-contract/boxed": "0.0.7",
-    "@temporal-contract/contract": "0.0.7"
+    "@temporal-contract/boxed": "0.2.0",
+    "@temporal-contract/contract": "0.2.0"
   },
   "devDependencies": {
-    "@temporalio/client": "1.14.0",
-    "@temporalio/worker": "1.14.0",
-    "@temporalio/workflow": "1.14.0",
-    "@types/node": "25.0.3",
-    "@vitest/coverage-v8": "4.0.16",
-    "tsdown": "0.18.1",
+    "@temporalio/client": "1.14.1",
+    "@temporalio/worker": "1.14.1",
+    "@temporalio/workflow": "1.14.1",
+    "@types/node": "25.2.3",
+    "@vitest/coverage-v8": "4.0.18",
+    "tsdown": "0.20.3",
+    "typedoc": "0.28.17",
+    "typedoc-plugin-markdown": "4.10.0",
     "typescript": "5.9.3",
-    "vitest": "4.0.16",
-    "zod": "4.2.1",
-    "@temporal-contract/client": "0.0.7",
-    "@temporal-contract/testing": "0.0.7",
-    "@temporal-contract/tsconfig": "0.0.7"
+    "vitest": "4.0.18",
+    "zod": "4.3.6",
+    "@temporal-contract/client": "0.2.0",
+    "@temporal-contract/testing": "0.2.0",
+    "@temporal-contract/tsconfig": "0.2.0",
+    "@temporal-contract/typedoc": "0.1.0"
   },
   "peerDependencies": {
     "@temporalio/worker": "^1",
@@ -87,6 +90,7 @@
   },
   "scripts": {
     "build": "tsdown src/activity.ts src/worker.ts src/workflow.ts --format cjs,esm --dts --clean",
+    "build:docs": "typedoc",
     "dev": "tsdown src/activity.ts src/worker.ts src/workflow.ts --format cjs,esm --dts --watch",
     "test": "vitest run --project unit",
     "test:integration": "vitest run --project integration",

package/dist/activity-Csptpwgf.d.cts

@@ -1,162 +0,0 @@
-import { g as WorkerInferOutput, h as WorkerInferInput } from "./errors-BqYWpdvd.cjs";
-import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
-import { Future, Result } from "@swan-io/boxed";
-
-//#region src/activity-utils.d.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
- * ```
- */
-declare function getWorkflowActivities<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]>(contract: TContract, workflowName: TWorkflowName): Record<string, ActivityDefinition>;
-/**
- * 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']
- * ```
- */
-declare function getWorkflowActivityNames<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]>(contract: TContract, workflowName: TWorkflowName): string[];
-/**
- * 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
- * }
- * ```
- */
-declare function isWorkflowActivity<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]>(contract: TContract, workflowName: TWorkflowName, activityName: string): boolean;
-/**
- * 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']
- * ```
- */
-declare function getWorkflowNames<TContract extends ContractDefinition>(contract: TContract): Array<keyof TContract["workflows"]>;
-//#endregion
-//#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 '@swan-io/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 { getWorkflowActivityNames as a, getWorkflowActivities as i, ActivityError as n, getWorkflowNames as o, declareActivitiesHandler as r, isWorkflowActivity as s, ActivitiesHandler as t };