@temporal-contract/worker 0.0.3 → 0.0.5

package/README.md

@@ -36,6 +36,55 @@ export const processOrder = declareWorkflow({
 });
 ```
 
+### 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
 
 📖 **[Read the full documentation →](https://btravers.github.io/temporal-contract)**

package/dist/activity.cjs

@@ -1,7 +1,7 @@
-const require_handler = require('./handler-Cc951VQp.cjs');
+const require_handler = require('./handler-BAzNuAZz.cjs');
 
 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;
 exports.WorkerError = require_handler.WorkerError;

package/dist/activity.d.cts

@@ -1,2 +1,2 @@
-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 { A as WorkerInferActivities, E as WorkerError, M as WorkerInferInput, N as WorkerInferOutput, R as WorkerInferWorkflowActivities, W as WorkflowActivityHandler, _ as ActivityInputValidationError, g as ActivityError, h as ActivityDefinitionNotFoundError, i as DeclareActivitiesHandlerOptions, j as WorkerInferActivity, k as ActivityHandler, n as ActivityImplementations, p as declareActivitiesHandler, r as BoxedActivityImplementation, t as ActivitiesHandler, v as ActivityOutputValidationError, z as WorkerInferWorkflowContextActivities } from "./handler-Cp9h_XCy.cjs";
+export { type ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, type ActivityHandler, type ActivityImplementations, ActivityInputValidationError, ActivityOutputValidationError, type BoxedActivityImplementation, type DeclareActivitiesHandlerOptions, WorkerError, type WorkerInferActivities, type WorkerInferActivity, type WorkerInferInput, type WorkerInferOutput, type WorkerInferWorkflowActivities, type WorkerInferWorkflowContextActivities, type WorkflowActivityHandler, declareActivitiesHandler };

package/dist/activity.d.mts

@@ -1,2 +1,2 @@
-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 { A as WorkerInferActivities, E as WorkerError, M as WorkerInferInput, N as WorkerInferOutput, R as WorkerInferWorkflowActivities, W as WorkflowActivityHandler, _ as ActivityInputValidationError, g as ActivityError, h as ActivityDefinitionNotFoundError, i as DeclareActivitiesHandlerOptions, j as WorkerInferActivity, k as ActivityHandler, n as ActivityImplementations, p as declareActivitiesHandler, r as BoxedActivityImplementation, t as ActivitiesHandler, v as ActivityOutputValidationError, z as WorkerInferWorkflowContextActivities } from "./handler-uAeIi9f0.mjs";
+export { type ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, type ActivityHandler, type ActivityImplementations, ActivityInputValidationError, ActivityOutputValidationError, type BoxedActivityImplementation, type DeclareActivitiesHandlerOptions, WorkerError, type WorkerInferActivities, type WorkerInferActivity, type WorkerInferInput, type WorkerInferOutput, type WorkerInferWorkflowActivities, type WorkerInferWorkflowContextActivities, type WorkflowActivityHandler, declareActivitiesHandler };

package/dist/activity.mjs

@@ -1,3 +1,3 @@
-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, i as ActivityError, m as WorkerError, o as ActivityOutputValidationError, r as ActivityDefinitionNotFoundError, t as declareActivitiesHandler } from "./handler-DFFpSaGN.mjs";
 
-export { ActivityDefinitionNotFoundError, ActivityImplementationNotFoundError, ActivityInputValidationError, ActivityOutputValidationError, WorkerError, declareActivitiesHandler };
+export { ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, WorkerError, declareActivitiesHandler };

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

@@ -1,3 +1,4 @@
+let __temporal_contract_boxed = require("@temporal-contract/boxed");
 let __temporalio_workflow = require("@temporalio/workflow");
 
 //#region src/errors.ts
@@ -5,29 +6,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";
@@ -141,6 +147,27 @@ var UpdateOutputValidationError = class extends WorkerError {
 		this.name = "UpdateOutputValidationError";
 	}
 };
+/**
+* Error thrown when a child workflow is not found in the contract
+*/
+var ChildWorkflowNotFoundError = class extends WorkerError {
+	constructor(workflowName, availableWorkflows = []) {
+		const available = availableWorkflows.length > 0 ? availableWorkflows.join(", ") : "none";
+		super(`Child workflow not found: "${workflowName}". Available workflows: ${available}`);
+		this.workflowName = workflowName;
+		this.availableWorkflows = availableWorkflows;
+		this.name = "ChildWorkflowNotFoundError";
+	}
+};
+/**
+* Generic error for child workflow operations
+*/
+var ChildWorkflowError = class extends WorkerError {
+	constructor(message, cause) {
+		super(message, cause);
+		this.name = "ChildWorkflowError";
+	}
+};
 
 //#endregion
 //#region src/handler.ts
@@ -158,7 +185,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 +199,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 '@temporal-contract/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 +265,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;
+			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 {
@@ -303,68 +347,150 @@ function declareActivitiesHandler(options) {
 * ```
 */
 function declareWorkflow(options) {
-	const { workflowName, contract, implementation, activityOptions, signals, queries, updates } = options;
+	const { workflowName, contract, implementation, activityOptions } = options;
 	const definition = contract.workflows[workflowName];
 	return async (args) => {
 		const singleArg = Array.isArray(args) ? args[0] : args;
 		const inputResult = await definition.input["~standard"].validate(singleArg);
 		if (inputResult.issues) throw new WorkflowInputValidationError(String(workflowName), inputResult.issues);
 		const validatedInput = inputResult.value;
-		if (definition.signals && signals) {
-			const signalDefs = definition.signals;
-			const signalHandlers = signals;
-			for (const [signalName, signalDef] of Object.entries(signalDefs)) {
-				const handler = signalHandlers[signalName];
-				if (handler) (0, __temporalio_workflow.setHandler)((0, __temporalio_workflow.defineSignal)(signalName), async (...args$1) => {
-					const input = args$1.length === 1 ? args$1[0] : args$1;
-					const inputResult$1 = await signalDef.input["~standard"].validate(input);
-					if (inputResult$1.issues) throw new SignalInputValidationError(signalName, inputResult$1.issues);
-					await handler(inputResult$1.value);
-				});
-			}
-		}
-		if (definition.queries && queries) {
-			const queryDefs = definition.queries;
-			const queryHandlers = queries;
-			for (const [queryName, queryDef] of Object.entries(queryDefs)) {
-				const handler = queryHandlers[queryName];
-				if (handler) (0, __temporalio_workflow.setHandler)((0, __temporalio_workflow.defineQuery)(queryName), (...args$1) => {
-					const input = args$1.length === 1 ? args$1[0] : args$1;
-					const inputResult$1 = queryDef.input["~standard"].validate(input);
-					if (inputResult$1 instanceof Promise) throw new Error(`Query "${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 "${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;
-				});
-			}
-		}
-		if (definition.updates && updates) {
-			const updateDefs = definition.updates;
-			const updateHandlers = updates;
-			for (const [updateName, updateDef] of Object.entries(updateDefs)) {
-				const handler = updateHandlers[updateName];
-				if (handler) (0, __temporalio_workflow.setHandler)((0, __temporalio_workflow.defineUpdate)(updateName), async (...args$1) => {
-					const input = args$1.length === 1 ? args$1[0] : args$1;
-					const inputResult$1 = await updateDef.input["~standard"].validate(input);
-					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;
-				});
-			}
-		}
 		let contextActivities = {};
 		if (definition.activities || contract.activities) contextActivities = createValidatedActivities((0, __temporalio_workflow.proxyActivities)({
 			startToCloseTimeout: activityOptions?.startToCloseTimeout ?? 6e4,
 			...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 __temporal_contract_boxed.Result.Error(new ChildWorkflowError(`Child workflow "${childWorkflowName}" output validation failed: ${outputResult$1.issues.map((i) => i.message).join("; ")}`));
+			return __temporal_contract_boxed.Result.Ok(outputResult$1.value);
+		}
+		async function getAndValidateChildWorkflow(childContract, childWorkflowName, args$1) {
+			const childDefinition = childContract.workflows[childWorkflowName];
+			if (!childDefinition) return __temporal_contract_boxed.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 __temporal_contract_boxed.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;
+			return __temporal_contract_boxed.Result.Ok({
+				definition: childDefinition,
+				validatedInput: validatedInput$1,
+				taskQueue: childContract.taskQueue
+			});
+		}
+		function createTypedChildHandle(handle, childDefinition, childWorkflowName) {
+			return {
+				workflowId: handle.workflowId,
+				result: () => {
+					return __temporal_contract_boxed.Future.make((resolve) => {
+						(async () => {
+							try {
+								resolve(await validateChildWorkflowOutput(childDefinition, await handle.result(), childWorkflowName));
+							} catch (error) {
+								resolve(__temporal_contract_boxed.Result.Error(new ChildWorkflowError(`Child workflow execution failed: ${error instanceof Error ? error.message : String(error)}`, error)));
+							}
+						})();
+					});
+				}
+			};
+		}
+		function createStartChildWorkflow(childContract, childWorkflowName, options$1) {
+			return __temporal_contract_boxed.Future.make((resolve) => {
+				(async () => {
+					const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options$1.args);
+					if (validationResult.isError()) {
+						resolve(__temporal_contract_boxed.Result.Error(validationResult.error));
+						return;
+					}
+					const { definition: childDefinition, validatedInput: validatedInput$1, taskQueue } = validationResult.value;
+					try {
+						const { args: _args, ...temporalOptions } = options$1;
+						const typedHandle = createTypedChildHandle(await (0, __temporalio_workflow.startChild)(childWorkflowName, {
+							...temporalOptions,
+							taskQueue,
+							args: [validatedInput$1]
+						}), childDefinition, String(childWorkflowName));
+						resolve(__temporal_contract_boxed.Result.Ok(typedHandle));
+					} catch (error) {
+						resolve(__temporal_contract_boxed.Result.Error(new ChildWorkflowError(`Failed to start child workflow: ${error instanceof Error ? error.message : String(error)}`, error)));
+					}
+				})();
+			});
+		}
+		function createExecuteChildWorkflow(childContract, childWorkflowName, options$1) {
+			return __temporal_contract_boxed.Future.make((resolve) => {
+				(async () => {
+					const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options$1.args);
+					if (validationResult.isError()) {
+						resolve(__temporal_contract_boxed.Result.Error(validationResult.error));
+						return;
+					}
+					const { definition: childDefinition, validatedInput: validatedInput$1, taskQueue } = validationResult.value;
+					try {
+						const { args: _args, ...temporalOptions } = options$1;
+						const outputValidationResult = await validateChildWorkflowOutput(childDefinition, await (0, __temporalio_workflow.executeChild)(childWorkflowName, {
+							...temporalOptions,
+							taskQueue,
+							args: [validatedInput$1]
+						}), String(childWorkflowName));
+						if (outputValidationResult.isError()) {
+							resolve(__temporal_contract_boxed.Result.Error(outputValidationResult.error));
+							return;
+						}
+						resolve(__temporal_contract_boxed.Result.Ok(outputValidationResult.value));
+					} catch (error) {
+						resolve(__temporal_contract_boxed.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`);
+			(0, __temporalio_workflow.setHandler)((0, __temporalio_workflow.defineSignal)(signalName), async (...args$1) => {
+				const input = args$1.length === 1 ? args$1[0] : args$1;
+				const inputResult$1 = await signalDef.input["~standard"].validate(input);
+				if (inputResult$1.issues) throw new SignalInputValidationError(signalName, inputResult$1.issues);
+				await handler(inputResult$1.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`);
+			(0, __temporalio_workflow.setHandler)((0, __temporalio_workflow.defineQuery)(queryName), (...args$1) => {
+				const input = args$1.length === 1 ? args$1[0] : args$1;
+				const inputResult$1 = queryDef.input["~standard"].validate(input);
+				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;
+			});
+		}
+		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`);
+			(0, __temporalio_workflow.setHandler)((0, __temporalio_workflow.defineUpdate)(updateName), async (...args$1) => {
+				const input = args$1.length === 1 ? args$1[0] : args$1;
+				const inputResult$1 = await updateDef.input["~standard"].validate(input);
+				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;
+			});
+		}
 		const result = await implementation({
 			activities: contextActivities,
-			info: (0, __temporalio_workflow.workflowInfo)()
+			info: (0, __temporalio_workflow.workflowInfo)(),
+			startChildWorkflow: createStartChildWorkflow,
+			executeChildWorkflow: createExecuteChildWorkflow,
+			defineSignal: createDefineSignal,
+			defineQuery: createDefineQuery,
+			defineUpdate: createDefineUpdate
 		}, validatedInput);
 		const outputResult = await definition.output["~standard"].validate(result);
 		if (outputResult.issues) throw new WorkflowOutputValidationError(String(workflowName), outputResult.issues);
@@ -379,10 +505,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', {
@@ -397,6 +523,18 @@ Object.defineProperty(exports, 'ActivityOutputValidationError', {
     return ActivityOutputValidationError;
   }
 });
+Object.defineProperty(exports, 'ChildWorkflowError', {
+  enumerable: true,
+  get: function () {
+    return ChildWorkflowError;
+  }
+});
+Object.defineProperty(exports, 'ChildWorkflowNotFoundError', {
+  enumerable: true,
+  get: function () {
+    return ChildWorkflowNotFoundError;
+  }
+});
 Object.defineProperty(exports, 'QueryInputValidationError', {
   enumerable: true,
   get: function () {