@temporal-contract/worker 0.0.3 → 0.0.5

package/dist/errors-DgUMRes-.d.mts

@@ -1,302 +0,0 @@
-import { ActivityOptions, WorkflowInfo } from "@temporalio/workflow";
-import { ActivityDefinition, ContractDefinition, QueryDefinition, SignalDefinition, UpdateDefinition, WorkerInferInput, WorkerInferOutput, WorkerInferWorkflowContextActivities } from "@temporal-contract/contract";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-
-//#region src/handler.d.ts
-
-/**
- * Workflow context with typed activities (workflow + global) and workflow info
- * Note: activities is typed as 'any' to work around TypeScript generic type inference limitations with Zod tuples
- */
-interface WorkflowContext<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> {
-  activities: WorkerInferWorkflowContextActivities<TContract, TWorkflowName>;
-  info: WorkflowInfo;
-}
-/**
- * Workflow implementation function (receives context + typed args as tuple)
- * Note: We use 'any' for args to work around TypeScript limitations with generic Zod tuple inference
- * The actual type will be enforced at runtime by Zod validation
- */
-type WorkflowImplementation<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = (context: WorkflowContext<TContract, TWorkflowName>, args: WorkerInferInput<TContract["workflows"][TWorkflowName]>) => Promise<WorkerInferOutput<TContract["workflows"][TWorkflowName]>>;
-/**
- * Raw activity implementation function (receives typed args as tuple)
- * Note: We use 'any' for args/return to work around TypeScript limitations with generic Zod tuple inference
- * The actual types will be enforced at runtime by Zod validation
- */
-type RawActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Promise<WorkerInferOutput<TActivity>>;
-/**
- * Signal handler implementation
- */
-type SignalHandlerImplementation<TSignal extends SignalDefinition> = (args: WorkerInferInput<TSignal>) => void | Promise<void>;
-/**
- * Query handler implementation
- */
-type QueryHandlerImplementation<TQuery extends QueryDefinition> = (args: WorkerInferInput<TQuery>) => WorkerInferOutput<TQuery>;
-/**
- * Update handler implementation
- */
-type UpdateHandlerImplementation<TUpdate extends UpdateDefinition> = (args: WorkerInferInput<TUpdate>) => Promise<WorkerInferOutput<TUpdate>>;
-/**
- * Map of all activity implementations for a contract (global + all workflow-specific)
- */
-type ActivityImplementations<T extends ContractDefinition> = (T["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof T["activities"]]: RawActivityImplementation<T["activities"][K]> } : {}) & UnionToIntersection<{ [K in keyof T["workflows"]]: T["workflows"][K]["activities"] extends Record<string, ActivityDefinition> ? { [A in keyof T["workflows"][K]["activities"]]: RawActivityImplementation<T["workflows"][K]["activities"][A]> } : {} }[keyof T["workflows"]]>;
-/**
- * Utility type to convert union to intersection
- */
-type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-/**
- * Options for creating activities handler
- */
-interface DeclareActivitiesHandlerOptions<T extends ContractDefinition> {
-  contract: T;
-  activities: ActivityImplementations<T>;
-}
-/**
- * Activities handler ready for Temporal Worker
- */
-interface ActivitiesHandler<T extends ContractDefinition> {
-  contract: T;
-  activities: Record<string, (...args: unknown[]) => Promise<unknown>>;
-}
-/**
- * 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.
-   * These will be merged with the default startToCloseTimeout of 60 seconds.
-   * 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;
-  /**
-   * Signal handlers (if defined in workflow)
-   */
-  signals?: TContract["workflows"][TWorkflowName]["signals"] extends Record<string, SignalDefinition> ? { [K in keyof TContract["workflows"][TWorkflowName]["signals"]]: SignalHandlerImplementation<TContract["workflows"][TWorkflowName]["signals"][K]> } : never;
-  /**
-   * Query handlers (if defined in workflow)
-   */
-  queries?: TContract["workflows"][TWorkflowName]["queries"] extends Record<string, QueryDefinition> ? { [K in keyof TContract["workflows"][TWorkflowName]["queries"]]: QueryHandlerImplementation<TContract["workflows"][TWorkflowName]["queries"][K]> } : never;
-  /**
-   * Update handlers (if defined in workflow)
-   */
-  updates?: TContract["workflows"][TWorkflowName]["updates"] extends Record<string, UpdateDefinition> ? { [K in keyof TContract["workflows"][TWorkflowName]["updates"]]: UpdateHandlerImplementation<TContract["workflows"][TWorkflowName]["updates"][K]> } : never;
-}
-/**
- * Create a typed activities handler with automatic validation
- *
- * 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 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 };
- *     },
- *   },
- * });
- *
- * // Use with Temporal Worker
- * import { Worker } from '@temporalio/worker';
- *
- * const worker = await Worker.create({
- *   workflowsPath: require.resolve('./workflows'),
- *   activities: activitiesHandler.activities,
- *   taskQueue: activitiesHandler.contract.taskQueue,
- * });
- * ```
- */
-declare function declareActivitiesHandler<T extends ContractDefinition>(options: DeclareActivitiesHandlerOptions<T>): ActivitiesHandler<T>;
-/**
- * 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"]>(options: DeclareWorkflowOptions<TContract, TWorkflowName>): (args: WorkerInferInput<TContract["workflows"][TWorkflowName]>) => Promise<WorkerInferOutput<TContract["workflows"][TWorkflowName]>>;
-//#endregion
-//#region src/errors.d.ts
-/**
- * Base error class for worker errors
- */
-declare class WorkerError extends Error {
-  constructor(message: string);
-}
-/**
- * Error thrown when an activity implementation is not found
- */
-declare class ActivityImplementationNotFoundError extends WorkerError {
-  readonly activityName: string;
-  readonly availableActivities: readonly string[];
-  constructor(activityName: string, availableActivities: readonly string[]);
-}
-/**
- * Error thrown when an activity definition is not found in the contract
- */
-declare class ActivityDefinitionNotFoundError extends WorkerError {
-  readonly activityName: string;
-  readonly availableDefinitions: readonly string[];
-  constructor(activityName: string, availableDefinitions: readonly string[]);
-}
-/**
- * Error thrown when activity input validation fails
- */
-declare class ActivityInputValidationError extends WorkerError {
-  readonly activityName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(activityName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-/**
- * Error thrown when activity output validation fails
- */
-declare class ActivityOutputValidationError extends WorkerError {
-  readonly activityName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(activityName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-/**
- * Error thrown when workflow input validation fails
- */
-declare class WorkflowInputValidationError extends WorkerError {
-  readonly workflowName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(workflowName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-/**
- * Error thrown when workflow output validation fails
- */
-declare class WorkflowOutputValidationError extends WorkerError {
-  readonly workflowName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(workflowName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-/**
- * Error thrown when signal input validation fails
- */
-declare class SignalInputValidationError extends WorkerError {
-  readonly signalName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(signalName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-/**
- * Error thrown when query input validation fails
- */
-declare class QueryInputValidationError extends WorkerError {
-  readonly queryName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(queryName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-/**
- * Error thrown when query output validation fails
- */
-declare class QueryOutputValidationError extends WorkerError {
-  readonly queryName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(queryName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-/**
- * Error thrown when update input validation fails
- */
-declare class UpdateInputValidationError extends WorkerError {
-  readonly updateName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-/**
- * Error thrown when update output validation fails
- */
-declare class UpdateOutputValidationError extends WorkerError {
-  readonly updateName: string;
-  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
-  constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
-}
-//#endregion
-export { declareActivitiesHandler as C, WorkflowImplementation as S, QueryHandlerImplementation as _, QueryInputValidationError as a, UpdateHandlerImplementation as b, UpdateInputValidationError as c, WorkflowInputValidationError as d, WorkflowOutputValidationError as f, DeclareWorkflowOptions as g, DeclareActivitiesHandlerOptions as h, ActivityOutputValidationError as i, UpdateOutputValidationError as l, ActivityImplementations as m, ActivityImplementationNotFoundError as n, QueryOutputValidationError as o, ActivitiesHandler as p, ActivityInputValidationError as r, SignalInputValidationError as s, ActivityDefinitionNotFoundError as t, WorkerError as u, RawActivityImplementation as v, declareWorkflow as w, WorkflowContext as x, SignalHandlerImplementation as y };

package/dist/handler-BP9xAycT.mjs

@@ -1,376 +0,0 @@
-import { defineQuery, defineSignal, defineUpdate, proxyActivities, setHandler, workflowInfo } from "@temporalio/workflow";
-
-//#region src/errors.ts
-/**
-* Base error class for worker errors
-*/
-var WorkerError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "WorkerError";
-		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-	}
-};
-/**
-* Error thrown when an activity implementation is not found
-*/
-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";
-	}
-};
-/**
-* 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"}`);
-		this.activityName = activityName;
-		this.availableDefinitions = availableDefinitions;
-		this.name = "ActivityDefinitionNotFoundError";
-	}
-};
-/**
-* Error thrown when activity input validation fails
-*/
-var ActivityInputValidationError = class extends WorkerError {
-	constructor(activityName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Activity "${activityName}" input validation failed: ${message}`);
-		this.activityName = activityName;
-		this.issues = issues;
-		this.name = "ActivityInputValidationError";
-	}
-};
-/**
-* Error thrown when activity output validation fails
-*/
-var ActivityOutputValidationError = class extends WorkerError {
-	constructor(activityName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Activity "${activityName}" output validation failed: ${message}`);
-		this.activityName = activityName;
-		this.issues = issues;
-		this.name = "ActivityOutputValidationError";
-	}
-};
-/**
-* Error thrown when workflow input validation fails
-*/
-var WorkflowInputValidationError = class extends WorkerError {
-	constructor(workflowName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Workflow "${workflowName}" input validation failed: ${message}`);
-		this.workflowName = workflowName;
-		this.issues = issues;
-		this.name = "WorkflowInputValidationError";
-	}
-};
-/**
-* Error thrown when workflow output validation fails
-*/
-var WorkflowOutputValidationError = class extends WorkerError {
-	constructor(workflowName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Workflow "${workflowName}" output validation failed: ${message}`);
-		this.workflowName = workflowName;
-		this.issues = issues;
-		this.name = "WorkflowOutputValidationError";
-	}
-};
-/**
-* Error thrown when signal input validation fails
-*/
-var SignalInputValidationError = class extends WorkerError {
-	constructor(signalName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Signal "${signalName}" input validation failed: ${message}`);
-		this.signalName = signalName;
-		this.issues = issues;
-		this.name = "SignalInputValidationError";
-	}
-};
-/**
-* Error thrown when query input validation fails
-*/
-var QueryInputValidationError = class extends WorkerError {
-	constructor(queryName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Query "${queryName}" input validation failed: ${message}`);
-		this.queryName = queryName;
-		this.issues = issues;
-		this.name = "QueryInputValidationError";
-	}
-};
-/**
-* Error thrown when query output validation fails
-*/
-var QueryOutputValidationError = class extends WorkerError {
-	constructor(queryName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Query "${queryName}" output validation failed: ${message}`);
-		this.queryName = queryName;
-		this.issues = issues;
-		this.name = "QueryOutputValidationError";
-	}
-};
-/**
-* Error thrown when update input validation fails
-*/
-var UpdateInputValidationError = class extends WorkerError {
-	constructor(updateName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Update "${updateName}" input validation failed: ${message}`);
-		this.updateName = updateName;
-		this.issues = issues;
-		this.name = "UpdateInputValidationError";
-	}
-};
-/**
-* Error thrown when update output validation fails
-*/
-var UpdateOutputValidationError = class extends WorkerError {
-	constructor(updateName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Update "${updateName}" output validation failed: ${message}`);
-		this.updateName = updateName;
-		this.issues = issues;
-		this.name = "UpdateOutputValidationError";
-	}
-};
-
-//#endregion
-//#region src/handler.ts
-/**
-* 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 ActivityImplementationNotFoundError(activityName, Object.keys(rawActivities));
-		const wrappedActivity = async (input) => {
-			const inputResult = await activityDef.input["~standard"].validate(input);
-			if (inputResult.issues) throw new ActivityInputValidationError(activityName, inputResult.issues);
-			const result = await rawActivity(inputResult.value);
-			const outputResult = await activityDef.output["~standard"].validate(result);
-			if (outputResult.issues) throw new ActivityOutputValidationError(activityName, outputResult.issues);
-			return outputResult.value;
-		};
-		validatedActivities[activityName] = wrappedActivity;
-	}
-	return validatedActivities;
-}
-/**
-* Create a typed activities handler with automatic validation
-*
-* 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 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 };
-*     },
-*   },
-* });
-*
-* // Use with Temporal Worker
-* import { Worker } from '@temporalio/worker';
-*
-* const worker = await Worker.create({
-*   workflowsPath: require.resolve('./workflows'),
-*   activities: activitiesHandler.activities,
-*   taskQueue: activitiesHandler.contract.taskQueue,
-* });
-* ```
-*/
-function declareActivitiesHandler(options) {
-	const { contract, activities } = options;
-	const wrappedActivities = {};
-	const allDefinitions = [];
-	if (contract.activities) allDefinitions.push(...Object.keys(contract.activities));
-	for (const workflow of Object.values(contract.workflows)) if (workflow.activities) allDefinitions.push(...Object.keys(workflow.activities));
-	for (const [activityName, activityImpl] of Object.entries(activities)) {
-		let activityDef;
-		if (contract.activities?.[activityName]) activityDef = contract.activities[activityName];
-		else for (const workflow of Object.values(contract.workflows)) if (workflow.activities?.[activityName]) {
-			activityDef = workflow.activities[activityName];
-			break;
-		}
-		if (!activityDef) throw new ActivityDefinitionNotFoundError(activityName, allDefinitions);
-		wrappedActivities[activityName] = async (input) => {
-			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;
-		};
-	}
-	return {
-		contract,
-		activities: wrappedActivities
-	};
-}
-/**
-* 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(options) {
-	const { workflowName, contract, implementation, activityOptions, signals, queries, updates } = 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) setHandler(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) setHandler(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) setHandler(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(proxyActivities({
-			startToCloseTimeout: activityOptions?.startToCloseTimeout ?? 6e4,
-			...activityOptions
-		}), definition.activities, contract.activities);
-		const result = await implementation({
-			activities: contextActivities,
-			info: workflowInfo()
-		}, validatedInput);
-		const outputResult = await definition.output["~standard"].validate(result);
-		if (outputResult.issues) throw new WorkflowOutputValidationError(String(workflowName), outputResult.issues);
-		return outputResult.value;
-	};
-}
-
-//#endregion
-export { ActivityInputValidationError as a, QueryOutputValidationError as c, UpdateOutputValidationError as d, WorkerError as f, ActivityImplementationNotFoundError as i, SignalInputValidationError as l, WorkflowOutputValidationError as m, declareWorkflow as n, ActivityOutputValidationError as o, WorkflowInputValidationError as p, ActivityDefinitionNotFoundError as r, QueryInputValidationError as s, declareActivitiesHandler as t, UpdateInputValidationError as u };