@temporal-contract/worker 0.0.4 → 0.0.6

package/dist/workflow.d.cts

@@ -1,2 +1,299 @@
-import { C as WorkflowInputValidationError, S as WorkerError, _ as QueryInputValidationError, a as DeclareWorkflowOptions, b as UpdateInputValidationError, c as UpdateHandlerImplementation, f as declareWorkflow, l as WorkflowContext, o as QueryHandlerImplementation, s as SignalHandlerImplementation, u as WorkflowImplementation, v as QueryOutputValidationError, w as WorkflowOutputValidationError, x as UpdateOutputValidationError, y as SignalInputValidationError } from "./handler-Czi-kgwZ.cjs";
-export { type DeclareWorkflowOptions, type QueryHandlerImplementation, QueryInputValidationError, QueryOutputValidationError, type SignalHandlerImplementation, SignalInputValidationError, type UpdateHandlerImplementation, UpdateInputValidationError, UpdateOutputValidationError, WorkerError, 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 };

package/dist/workflow.d.mts

@@ -1,2 +1,299 @@
-import { C as WorkflowInputValidationError, S as WorkerError, _ as QueryInputValidationError, a as DeclareWorkflowOptions, b as UpdateInputValidationError, c as UpdateHandlerImplementation, f as declareWorkflow, l as WorkflowContext, o as QueryHandlerImplementation, s as SignalHandlerImplementation, u as WorkflowImplementation, v as QueryOutputValidationError, w as WorkflowOutputValidationError, x as UpdateOutputValidationError, y as SignalInputValidationError } from "./handler-DThqdaaS.mjs";
-export { type DeclareWorkflowOptions, type QueryHandlerImplementation, QueryInputValidationError, QueryOutputValidationError, type SignalHandlerImplementation, SignalInputValidationError, type UpdateHandlerImplementation, UpdateInputValidationError, UpdateOutputValidationError, WorkerError, 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-C1RFkCuD.mjs";
+import { Future, Result } from "@temporal-contract/boxed";
+import { ActivityOptions, ChildWorkflowOptions, WorkflowInfo } from "@temporalio/workflow";
+import { ActivityDefinition, ContractDefinition, QueryDefinition, SignalDefinition, UpdateDefinition, WorkflowDefinition } from "@temporal-contract/contract";
+
+//#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 };