@temporal-contract/worker 0.0.5 → 0.0.7

package/dist/workflow.cjs

@@ -1,13 +1,256 @@
-const require_handler = require('./handler-BAzNuAZz.cjs');
+const require_errors = require('./errors-DjSZg-93.cjs');
+let _temporal_contract_boxed = require("@temporal-contract/boxed");
+let _temporalio_workflow = require("@temporalio/workflow");
 
-exports.ChildWorkflowError = require_handler.ChildWorkflowError;
-exports.ChildWorkflowNotFoundError = require_handler.ChildWorkflowNotFoundError;
-exports.QueryInputValidationError = require_handler.QueryInputValidationError;
-exports.QueryOutputValidationError = require_handler.QueryOutputValidationError;
-exports.SignalInputValidationError = require_handler.SignalInputValidationError;
-exports.UpdateInputValidationError = require_handler.UpdateInputValidationError;
-exports.UpdateOutputValidationError = require_handler.UpdateOutputValidationError;
-exports.WorkerError = require_handler.WorkerError;
-exports.WorkflowInputValidationError = require_handler.WorkflowInputValidationError;
-exports.WorkflowOutputValidationError = require_handler.WorkflowOutputValidationError;
-exports.declareWorkflow = require_handler.declareWorkflow;
+//#region src/workflow.ts
+/**
+* Create a typed workflow implementation with automatic validation
+*
+* This wraps a workflow implementation with:
+* - Input/output validation
+* - Typed workflow context with activities
+* - Workflow info access
+*
+* Workflows must be defined in separate files and imported by the Temporal Worker
+* via workflowsPath.
+*
+* @example
+* ```ts
+* // workflows/processOrder.ts
+* import { declareWorkflow } from '@temporal-contract/worker';
+* import myContract from '../contract';
+*
+* export const processOrder = declareWorkflow({
+*   workflowName: 'processOrder',
+*   contract: myContract,
+*   implementation: async (context, orderId, customerId) => {
+*     // context.activities: typed activities (workflow + global)
+*     // context.info: WorkflowInfo
+*
+*     const inventory = await context.activities.validateInventory(orderId);
+*
+*     if (!inventory.available) {
+*       throw new Error('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'
+*     );
+*
+*     return {
+*       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';
+*
+* const worker = await Worker.create({
+*   workflowsPath: require.resolve('./workflows'), // Imports processOrder
+*   activities: activitiesHandler.activities,
+*   taskQueue: activitiesHandler.contract.taskQueue,
+* });
+* ```
+*/
+function declareWorkflow({ workflowName, contract, implementation, activityOptions }) {
+	const definition = contract.workflows[workflowName];
+	return async (...args) => {
+		const input = args.length === 1 ? args[0] : args;
+		const inputResult = await definition.input["~standard"].validate(input);
+		if (inputResult.issues) throw new require_errors.WorkflowInputValidationError(String(workflowName), inputResult.issues);
+		const validatedInput = inputResult.value;
+		let contextActivities = {};
+		if (definition.activities || contract.activities) contextActivities = createValidatedActivities((0, _temporalio_workflow.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 _temporal_contract_boxed.Result.Error(new require_errors.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 require_errors.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 require_errors.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 require_errors.ChildWorkflowError(`Child workflow execution failed: ${error instanceof Error ? error.message : String(error)}`, error)));
+							}
+						})();
+					});
+				}
+			};
+		}
+		function createStartChildWorkflow(childContract, childWorkflowName, options) {
+			return _temporal_contract_boxed.Future.make((resolve) => {
+				(async () => {
+					const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options.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;
+						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 require_errors.ChildWorkflowError(`Failed to start child workflow: ${error instanceof Error ? error.message : String(error)}`, error)));
+					}
+				})();
+			});
+		}
+		function createExecuteChildWorkflow(childContract, childWorkflowName, options) {
+			return _temporal_contract_boxed.Future.make((resolve) => {
+				(async () => {
+					const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options.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;
+						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 require_errors.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$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 require_errors.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$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 require_errors.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 require_errors.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$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 require_errors.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 require_errors.UpdateOutputValidationError(updateName, outputResult$1.issues);
+				return outputResult$1.value;
+			});
+		}
+		const result = await implementation({
+			activities: contextActivities,
+			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 require_errors.WorkflowOutputValidationError(String(workflowName), outputResult.issues);
+		return outputResult.value;
+	};
+}
+/**
+* Create a validated activities proxy that parses inputs and outputs
+*
+* This wrapper ensures data integrity across the network boundary between
+* workflow and activity execution.
+*/
+function createValidatedActivities(rawActivities, workflowActivitiesDefinition, contractActivitiesDefinition) {
+	const validatedActivities = {};
+	const allActivitiesDefinition = {
+		...contractActivitiesDefinition,
+		...workflowActivitiesDefinition
+	};
+	for (const [activityName, activityDef] of Object.entries(allActivitiesDefinition)) {
+		const rawActivity = rawActivities[activityName];
+		if (!rawActivity) throw new Error(`Activity implementation not found for: "${activityName}". Available activities: ${Object.keys(rawActivities).length > 0 ? Object.keys(rawActivities).join(", ") : "none"}`);
+		validatedActivities[activityName] = async (input) => {
+			const inputResult = await activityDef.input["~standard"].validate(input);
+			if (inputResult.issues) throw new require_errors.ActivityInputValidationError(activityName, inputResult.issues);
+			const result = await rawActivity(inputResult.value);
+			const outputResult = await activityDef.output["~standard"].validate(result);
+			if (outputResult.issues) throw new require_errors.ActivityOutputValidationError(activityName, outputResult.issues);
+			return outputResult.value;
+		};
+	}
+	return validatedActivities;
+}
+
+//#endregion
+exports.ActivityInputValidationError = require_errors.ActivityInputValidationError;
+exports.ActivityOutputValidationError = require_errors.ActivityOutputValidationError;
+exports.ChildWorkflowError = require_errors.ChildWorkflowError;
+exports.ChildWorkflowNotFoundError = require_errors.ChildWorkflowNotFoundError;
+exports.QueryInputValidationError = require_errors.QueryInputValidationError;
+exports.QueryOutputValidationError = require_errors.QueryOutputValidationError;
+exports.SignalInputValidationError = require_errors.SignalInputValidationError;
+exports.UpdateInputValidationError = require_errors.UpdateInputValidationError;
+exports.UpdateOutputValidationError = require_errors.UpdateOutputValidationError;
+exports.WorkflowInputValidationError = require_errors.WorkflowInputValidationError;
+exports.WorkflowOutputValidationError = require_errors.WorkflowOutputValidationError;
+exports.declareWorkflow = declareWorkflow;

package/dist/workflow.d.cts

@@ -1,2 +1,299 @@
-import { B as WorkerInferWorkflowQueries, C as SignalInputValidationError, D as WorkflowInputValidationError, E as WorkerError, F as WorkerInferSignal, H as WorkerInferWorkflowUpdates, I as WorkerInferUpdate, L as WorkerInferWorkflow, M as WorkerInferInput, N as WorkerInferOutput, O as WorkflowOutputValidationError, P as WorkerInferQuery, S as QueryOutputValidationError, T as UpdateOutputValidationError, U as WorkerInferWorkflows, V as WorkerInferWorkflowSignals, a as DeclareWorkflowOptions, b as ChildWorkflowNotFoundError, c as TypedChildWorkflowHandle, d as WorkflowContext, f as WorkflowImplementation, l as TypedChildWorkflowOptions, m as declareWorkflow, o as QueryHandlerImplementation, s as SignalHandlerImplementation, u as UpdateHandlerImplementation, w as UpdateInputValidationError, x as QueryInputValidationError, y as ChildWorkflowError } from "./handler-Cp9h_XCy.cjs";
-export { ChildWorkflowError, ChildWorkflowNotFoundError, type DeclareWorkflowOptions, type QueryHandlerImplementation, QueryInputValidationError, QueryOutputValidationError, type SignalHandlerImplementation, SignalInputValidationError, type TypedChildWorkflowHandle, type TypedChildWorkflowOptions, type UpdateHandlerImplementation, UpdateInputValidationError, UpdateOutputValidationError, WorkerError, type WorkerInferInput, type WorkerInferOutput, type WorkerInferQuery, type WorkerInferSignal, type WorkerInferUpdate, type WorkerInferWorkflow, type WorkerInferWorkflowQueries, type WorkerInferWorkflowSignals, type WorkerInferWorkflowUpdates, type WorkerInferWorkflows, type WorkflowContext, type WorkflowImplementation, WorkflowInputValidationError, WorkflowOutputValidationError, declareWorkflow };
+import { a as ChildWorkflowNotFoundError, c as SignalInputValidationError, d as WorkflowInputValidationError, f as WorkflowOutputValidationError, g as WorkerInferOutput, h as WorkerInferInput, i as ChildWorkflowError, l as UpdateInputValidationError, m as ClientInferOutput, n as ActivityInputValidationError, o as QueryInputValidationError, p as ClientInferInput, r as ActivityOutputValidationError, s as QueryOutputValidationError, u as UpdateOutputValidationError } from "./errors-BqYWpdvd.cjs";
+import { ActivityDefinition, ContractDefinition, QueryDefinition, SignalDefinition, UpdateDefinition, WorkflowDefinition } from "@temporal-contract/contract";
+import { Future, Result } from "@temporal-contract/boxed";
+import { ActivityOptions, ChildWorkflowOptions, WorkflowInfo } from "@temporalio/workflow";
+
+//#region src/workflow.d.ts
+
+/**
+ * Create a typed workflow implementation with automatic validation
+ *
+ * This wraps a workflow implementation with:
+ * - Input/output validation
+ * - Typed workflow context with activities
+ * - Workflow info access
+ *
+ * Workflows must be defined in separate files and imported by the Temporal Worker
+ * via workflowsPath.
+ *
+ * @example
+ * ```ts
+ * // workflows/processOrder.ts
+ * import { declareWorkflow } from '@temporal-contract/worker';
+ * import myContract from '../contract';
+ *
+ * export const processOrder = declareWorkflow({
+ *   workflowName: 'processOrder',
+ *   contract: myContract,
+ *   implementation: async (context, orderId, customerId) => {
+ *     // context.activities: typed activities (workflow + global)
+ *     // context.info: WorkflowInfo
+ *
+ *     const inventory = await context.activities.validateInventory(orderId);
+ *
+ *     if (!inventory.available) {
+ *       throw new Error('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'
+ *     );
+ *
+ *     return {
+ *       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';
+ *
+ * const worker = await Worker.create({
+ *   workflowsPath: require.resolve('./workflows'), // Imports processOrder
+ *   activities: activitiesHandler.activities,
+ *   taskQueue: activitiesHandler.contract.taskQueue,
+ * });
+ * ```
+ */
+declare function declareWorkflow<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]>({
+  workflowName,
+  contract,
+  implementation,
+  activityOptions
+}: DeclareWorkflowOptions<TContract, TWorkflowName>): (...args: unknown[]) => Promise<WorkerInferOutput<TContract["workflows"][TWorkflowName]>>;
+/**
+ * Signal handler implementation
+ *
+ * Processes signal input and can optionally perform asynchronous operations.
+ * Should not return a value (signals are fire-and-forget).
+ */
+type SignalHandlerImplementation<TSignal extends SignalDefinition> = (args: WorkerInferInput<TSignal>) => void | Promise<void>;
+/**
+ * Query handler implementation
+ *
+ * Processes query input and returns a synchronous response.
+ * Must be synchronous to satisfy Temporal's query constraints.
+ */
+type QueryHandlerImplementation<TQuery extends QueryDefinition> = (args: WorkerInferInput<TQuery>) => WorkerInferOutput<TQuery>;
+/**
+ * Update handler implementation
+ *
+ * Processes update input and returns a validated response after modifying workflow state.
+ * Can perform asynchronous operations.
+ */
+type UpdateHandlerImplementation<TUpdate extends UpdateDefinition> = (args: WorkerInferInput<TUpdate>) => Promise<WorkerInferOutput<TUpdate>>;
+/**
+ * Options for declaring a workflow implementation
+ */
+interface DeclareWorkflowOptions<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> {
+  workflowName: TWorkflowName;
+  contract: TContract;
+  implementation: WorkflowImplementation<TContract, TWorkflowName>;
+  /**
+   * Default activity options applied to all activities in this workflow.
+   * For more control, you can override specific Temporal ActivityOptions like:
+   * - startToCloseTimeout: Maximum time for activity execution
+   * - scheduleToCloseTimeout: End-to-end timeout including queuing
+   * - scheduleToStartTimeout: Maximum time activity can wait in queue
+   * - heartbeatTimeout: Time between heartbeats before considering activity dead
+   * - retry: Retry policy for failed activities
+   *
+   * @example
+   * ```ts
+   * activityOptions: {
+   *   startToCloseTimeout: '5m',
+   *   retry: { maximumAttempts: 3 }
+   * }
+   * ```
+   */
+  activityOptions: ActivityOptions;
+}
+/**
+ * Workflow implementation function
+ *
+ * Receives a workflow context (with typed activities and utilities) and validated input arguments.
+ * Returns the workflow output which will be validated against the contract schema.
+ */
+type WorkflowImplementation<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = (context: WorkflowContext<TContract, TWorkflowName>, args: WorkerInferInput<TContract["workflows"][TWorkflowName]>) => Promise<WorkerInferOutput<TContract["workflows"][TWorkflowName]>>;
+/**
+ * Workflow execution context providing typed activities, workflow info, and interaction handlers
+ *
+ * Provides access to:
+ * - Typed activities (both workflow-specific and global)
+ * - Workflow metadata and execution info
+ * - Signal, query, and update handler registration
+ * - Child workflow execution capabilities
+ */
+interface WorkflowContext<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> {
+  activities: WorkflowInferWorkflowContextActivities<TContract, TWorkflowName>;
+  info: WorkflowInfo;
+  /**
+   * Define a signal handler within the workflow implementation
+   * Allows the signal handler to access workflow state
+   *
+   * @example
+   * ```ts
+   * implementation: async (context, args) => {
+   *   let currentValue = args.initialValue;
+   *
+   *   context.defineSignal('increment', async (signalArgs) => {
+   *     currentValue += signalArgs.amount;
+   *   });
+   *
+   *   // ... rest of workflow
+   * }
+   * ```
+   */
+  defineSignal: <K$1 extends keyof TContract["workflows"][TWorkflowName]["signals"]>(signalName: K$1, handler: SignalHandlerImplementation<TContract["workflows"][TWorkflowName]["signals"][K$1] extends SignalDefinition ? TContract["workflows"][TWorkflowName]["signals"][K$1] : never>) => void;
+  /**
+   * Define a query handler within the workflow implementation
+   * Allows the query handler to access workflow state
+   *
+   * @example
+   * ```ts
+   * implementation: async (context, args) => {
+   *   let currentValue = args.initialValue;
+   *
+   *   context.defineQuery('getCurrentValue', () => {
+   *     return { value: currentValue };
+   *   });
+   *
+   *   // ... rest of workflow
+   * }
+   * ```
+   */
+  defineQuery: <K$1 extends keyof TContract["workflows"][TWorkflowName]["queries"]>(queryName: K$1, handler: QueryHandlerImplementation<TContract["workflows"][TWorkflowName]["queries"][K$1] extends QueryDefinition ? TContract["workflows"][TWorkflowName]["queries"][K$1] : never>) => void;
+  /**
+   * Define an update handler within the workflow implementation
+   * Allows the update handler to access and modify workflow state
+   *
+   * @example
+   * ```ts
+   * implementation: async (context, args) => {
+   *   let currentValue = args.initialValue;
+   *
+   *   context.defineUpdate('multiply', async (updateArgs) => {
+   *     currentValue *= updateArgs.factor;
+   *     return { newValue: currentValue };
+   *   });
+   *
+   *   // ... rest of workflow
+   * }
+   * ```
+   */
+  defineUpdate: <K$1 extends keyof TContract["workflows"][TWorkflowName]["updates"]>(updateName: K$1, handler: UpdateHandlerImplementation<TContract["workflows"][TWorkflowName]["updates"][K$1] extends UpdateDefinition ? TContract["workflows"][TWorkflowName]["updates"][K$1] : never>) => void;
+  /**
+   * Start a child workflow and return a typed handle with Future/Result pattern
+   *
+   * Supports both same-contract and cross-contract child workflows:
+   * - Same contract: Pass workflowName from current contract
+   * - Cross-contract: Pass contract and workflowName to invoke workflows from other workers
+   *
+   * @example
+   * ```ts
+   * // Same contract child workflow
+   * const childResult = await context.startChildWorkflow(myContract, 'processPayment', {
+   *   workflowId: 'payment-123',
+   *   args: { amount: 100 }
+   * });
+   *
+   * // Cross-contract child workflow (from another worker)
+   * const otherResult = await context.startChildWorkflow(otherContract, 'sendNotification', {
+   *   workflowId: 'notification-123',
+   *   args: { message: 'Hello' }
+   * });
+   *
+   * childResult.match({
+   *   Ok: async (handle) => {
+   *     const result = await handle.result();
+   *     // ... handle result
+   *   },
+   *   Error: (error) => console.error('Failed to start:', error),
+   * });
+   * ```
+   */
+  startChildWorkflow: <TChildContract extends ContractDefinition, TChildWorkflowName extends keyof TChildContract["workflows"]>(contract: TChildContract, workflowName: TChildWorkflowName, options: TypedChildWorkflowOptions<TChildContract, TChildWorkflowName>) => Future<Result<TypedChildWorkflowHandle<TChildContract["workflows"][TChildWorkflowName]>, ChildWorkflowError>>;
+  /**
+   * Execute a child workflow (start and wait for result) with Future/Result pattern
+   *
+   * Supports both same-contract and cross-contract child workflows:
+   * - Same contract: Pass workflowName from current contract
+   * - Cross-contract: Pass contract and workflowName to invoke workflows from other workers
+   *
+   * @example
+   * ```ts
+   * // Same contract child workflow
+   * const result = await context.executeChildWorkflow(myContract, 'processPayment', {
+   *   workflowId: 'payment-123',
+   *   args: { amount: 100 }
+   * });
+   *
+   * // Cross-contract child workflow (from another worker)
+   * const otherResult = await context.executeChildWorkflow(otherContract, 'sendNotification', {
+   *   workflowId: 'notification-123',
+   *   args: { message: 'Hello' }
+   * });
+   *
+   * result.match({
+   *   Ok: (output) => console.log('Payment processed:', output),
+   *   Error: (error) => console.error('Processing failed:', error),
+   * });
+   * ```
+   */
+  executeChildWorkflow: <TChildContract extends ContractDefinition, TChildWorkflowName extends keyof TChildContract["workflows"]>(contract: TChildContract, workflowName: TChildWorkflowName, options: TypedChildWorkflowOptions<TChildContract, TChildWorkflowName>) => Future<Result<ClientInferOutput<TChildContract["workflows"][TChildWorkflowName]>, ChildWorkflowError>>;
+}
+/**
+ * Options for starting a child workflow
+ */
+type TypedChildWorkflowOptions<TChildContract extends ContractDefinition, TChildWorkflowName extends keyof TChildContract["workflows"]> = Omit<ChildWorkflowOptions, "taskQueue" | "args"> & {
+  args: ClientInferInput<TChildContract["workflows"][TChildWorkflowName]>;
+};
+/**
+ * Typed handle for a child workflow with Future/Result pattern
+ */
+interface TypedChildWorkflowHandle<TWorkflow extends WorkflowDefinition> {
+  /**
+   * Get child workflow result with Result pattern
+   */
+  result: () => Future<Result<ClientInferOutput<TWorkflow>, ChildWorkflowError>>;
+  /**
+   * Child workflow ID
+   */
+  workflowId: string;
+}
+/**
+ * Activity function signature from workflow execution perspective
+ *
+ * Workflows call activities with validated input (z.input parsed) and receive validated output (z.output)
+ */
+type WorkflowInferActivity<TActivity extends ActivityDefinition> = (args: ClientInferInput<TActivity>) => Promise<ClientInferOutput<TActivity>>;
+/**
+ * All global activities from a contract (workflow execution perspective)
+ */
+type WorkflowInferActivities<TContract extends ContractDefinition> = TContract["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof TContract["activities"]]: WorkflowInferActivity<TContract["activities"][K]> } : {};
+/**
+ * Workflow-specific activities (workflow execution perspective)
+ */
+type WorkflowInferWorkflowActivities<T extends WorkflowDefinition> = T["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof T["activities"]]: WorkflowInferActivity<T["activities"][K]> } : {};
+/**
+ * All activities available in a workflow context (workflow execution perspective)
+ *
+ * Combines workflow-specific activities with global contract activities
+ */
+type WorkflowInferWorkflowContextActivities<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = WorkflowInferWorkflowActivities<TContract["workflows"][TWorkflowName]> & WorkflowInferActivities<TContract>;
+//#endregion
+export { ActivityInputValidationError, ActivityOutputValidationError, ChildWorkflowError, ChildWorkflowNotFoundError, QueryInputValidationError, QueryOutputValidationError, SignalInputValidationError, UpdateInputValidationError, UpdateOutputValidationError, WorkflowInputValidationError, WorkflowOutputValidationError, declareWorkflow };