@temporal-contract/worker 0.0.5 → 0.0.6

package/README.md

@@ -34,6 +34,29 @@ export const processOrder = declareWorkflow({
     return { success: true };
   }
 });
+
+// worker.ts
+import { NativeConnection } from '@temporalio/worker';
+import { createWorker } from '@temporal-contract/worker/worker';
+import { activities } from './activities';
+import myContract from './contract';
+
+async function run() {
+  const connection = await NativeConnection.connect({
+    address: 'localhost:7233',
+  });
+
+  const worker = await createWorker({
+    contract: myContract,
+    connection,
+    workflowsPath: require.resolve('./workflows'),
+    activities,
+  });
+
+  await worker.run();
+}
+
+run().catch(console.error);
 ```
 
 ### Child Workflows

package/dist/activity.cjs

@@ -1,8 +1,109 @@
-const require_handler = require('./handler-BAzNuAZz.cjs');
+const require_errors = require('./errors-DjSZg-93.cjs');
 
-exports.ActivityDefinitionNotFoundError = require_handler.ActivityDefinitionNotFoundError;
-exports.ActivityError = require_handler.ActivityError;
-exports.ActivityInputValidationError = require_handler.ActivityInputValidationError;
-exports.ActivityOutputValidationError = require_handler.ActivityOutputValidationError;
-exports.WorkerError = require_handler.WorkerError;
-exports.declareActivitiesHandler = require_handler.declareActivitiesHandler;
+//#region src/activity.ts
+/**
+* Activity error class that should be used to wrap all technical exceptions
+* Forces proper error handling and enables retry policies
+*/
+var ActivityError = class ActivityError extends Error {
+	constructor(code, message, cause) {
+		super(message, { cause });
+		this.code = code;
+		this.name = "ActivityError";
+		if (Error.captureStackTrace) Error.captureStackTrace(this, ActivityError);
+	}
+};
+/**
+* Create a typed activities handler with automatic validation and Result pattern
+*
+* This wraps all activity implementations with:
+* - Validation at network boundaries
+* - Result<T, ActivityError> pattern for explicit error handling
+* - Automatic conversion from Result to Promise (throwing on Error)
+*
+* TypeScript ensures ALL activities (global + workflow-specific) are implemented.
+*
+* Use this to create the activities object for the Temporal Worker.
+*
+* @example
+* ```ts
+* import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
+* import { Result, Future } from '@temporal-contract/boxed';
+* import myContract from './contract';
+*
+* export const activities = declareActivitiesHandler({
+*   contract: myContract,
+*   activities: {
+*     // Activity returns Result instead of throwing
+*     // All technical exceptions must be wrapped in ActivityError for retry policies
+*     sendEmail: (args) => {
+*       return Future.make(async resolve => {
+*         try {
+*           await emailService.send(args);
+*           resolve(Result.Ok({ sent: true }));
+*         } catch (error) {
+*           // Wrap technical errors in ActivityError to enable retries
+*           resolve(Result.Error(
+*             new ActivityError(
+*               'EMAIL_SEND_FAILED',
+*               'Failed to send email',
+*               error // Original error as cause for debugging
+*             )
+*           ));
+*         }
+*       });
+*     },
+*   },
+* });
+*
+* // Use with Temporal Worker
+* import { Worker } from '@temporalio/worker';
+*
+* const worker = await Worker.create({
+*   workflowsPath: require.resolve('./workflows'),
+*   activities: activities,
+*   taskQueue: contract.taskQueue,
+* });
+* ```
+*/
+function declareActivitiesHandler(options) {
+	const { contract, activities } = options;
+	const wrappedActivities = {};
+	function makeWrapped(activityName, activityDef, activityImpl) {
+		return async (...args) => {
+			const input = args.length === 1 ? args[0] : args;
+			const inputResult = await activityDef.input["~standard"].validate(input);
+			if (inputResult.issues) throw new require_errors.ActivityInputValidationError(activityName, inputResult.issues);
+			const result = await activityImpl(inputResult.value);
+			if (result.isOk()) {
+				const outputResult = await activityDef.output["~standard"].validate(result.value);
+				if (outputResult.issues) throw new require_errors.ActivityOutputValidationError(activityName, outputResult.issues);
+				return outputResult.value;
+			} else throw result.error;
+		};
+	}
+	if (contract.activities) for (const [activityName, impl] of Object.entries(activities)) {
+		if (contract.workflows && activityName in contract.workflows) continue;
+		const activityDef = contract.activities[activityName];
+		if (!activityDef) throw new require_errors.ActivityDefinitionNotFoundError(activityName, Object.keys(contract.activities));
+		wrappedActivities[activityName] = makeWrapped(activityName, activityDef, impl);
+	}
+	if (contract.workflows) for (const [workflowName, workflowDef] of Object.entries(contract.workflows)) {
+		const wfActivitiesImpl = activities[workflowName];
+		if (!wfActivitiesImpl) continue;
+		const wfDefs = workflowDef.activities ?? {};
+		for (const [activityName, impl] of Object.entries(wfActivitiesImpl)) {
+			const activityDef = wfDefs[activityName];
+			if (!activityDef) throw new require_errors.ActivityDefinitionNotFoundError(`${workflowName}.${activityName}`, Object.keys(wfDefs));
+			wrappedActivities[activityName] = makeWrapped(`${workflowName}.${activityName}`, activityDef, impl);
+		}
+	}
+	return wrappedActivities;
+}
+
+//#endregion
+exports.ActivityDefinitionNotFoundError = require_errors.ActivityDefinitionNotFoundError;
+exports.ActivityError = ActivityError;
+exports.ActivityInputValidationError = require_errors.ActivityInputValidationError;
+exports.ActivityOutputValidationError = require_errors.ActivityOutputValidationError;
+exports.declareActivitiesHandler = declareActivitiesHandler;

package/dist/activity.d.cts

@@ -1,2 +1,98 @@
-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 };
+import { g as WorkerInferOutput, h as WorkerInferInput, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-BqYWpdvd.cjs";
+import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
+import { Future, Result } from "@temporal-contract/boxed";
+
+//#region src/activity.d.ts
+
+/**
+ * Activity error class that should be used to wrap all technical exceptions
+ * Forces proper error handling and enables retry policies
+ */
+declare class ActivityError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string, cause?: unknown);
+}
+/**
+ * Activity implementation using Future/Result pattern
+ *
+ * Returns Future<Result<Output, ActivityError>> for explicit error handling instead of throwing exceptions.
+ * All errors must be wrapped in ActivityError to enable proper retry policies.
+ */
+type BoxedActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Future<Result<WorkerInferOutput<TActivity>, ActivityError>>;
+/**
+ * Map of all activity implementations for a contract (global + all workflow-specific)
+ */
+type ContractBoxedActivitiesImplementations<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? BoxedActivitiesImplementations<TContract["activities"]> : {}) & { [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? BoxedActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} };
+type BoxedActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: BoxedActivityImplementation<TActivities[K]> };
+/**
+ * Options for creating activities handler
+ */
+interface DeclareActivitiesHandlerOptions<TContract extends ContractDefinition> {
+  contract: TContract;
+  activities: ContractBoxedActivitiesImplementations<TContract>;
+}
+type ActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Promise<WorkerInferOutput<TActivity>>;
+type ActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: ActivityImplementation<TActivities[K]> };
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+/**
+ * Activities handler ready for Temporal Worker
+ *
+ * Flat structure: all activities (global + all workflow-specific) are at the root level
+ */
+type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? ActivitiesImplementations<TContract["activities"]> : {}) & UnionToIntersection<{ [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? ActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} }[keyof TContract["workflows"]]>;
+/**
+ * Create a typed activities handler with automatic validation and Result pattern
+ *
+ * This wraps all activity implementations with:
+ * - Validation at network boundaries
+ * - Result<T, ActivityError> pattern for explicit error handling
+ * - Automatic conversion from Result to Promise (throwing on Error)
+ *
+ * TypeScript ensures ALL activities (global + workflow-specific) are implemented.
+ *
+ * Use this to create the activities object for the Temporal Worker.
+ *
+ * @example
+ * ```ts
+ * import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
+ * import { Result, Future } from '@temporal-contract/boxed';
+ * import myContract from './contract';
+ *
+ * export const activities = declareActivitiesHandler({
+ *   contract: myContract,
+ *   activities: {
+ *     // Activity returns Result instead of throwing
+ *     // All technical exceptions must be wrapped in ActivityError for retry policies
+ *     sendEmail: (args) => {
+ *       return Future.make(async resolve => {
+ *         try {
+ *           await emailService.send(args);
+ *           resolve(Result.Ok({ sent: true }));
+ *         } catch (error) {
+ *           // Wrap technical errors in ActivityError to enable retries
+ *           resolve(Result.Error(
+ *             new ActivityError(
+ *               'EMAIL_SEND_FAILED',
+ *               'Failed to send email',
+ *               error // Original error as cause for debugging
+ *             )
+ *           ));
+ *         }
+ *       });
+ *     },
+ *   },
+ * });
+ *
+ * // Use with Temporal Worker
+ * import { Worker } from '@temporalio/worker';
+ *
+ * const worker = await Worker.create({
+ *   workflowsPath: require.resolve('./workflows'),
+ *   activities: activities,
+ *   taskQueue: contract.taskQueue,
+ * });
+ * ```
+ */
+declare function declareActivitiesHandler<TContract extends ContractDefinition>(options: DeclareActivitiesHandlerOptions<TContract>): ActivitiesHandler<TContract>;
+//#endregion
+export { ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler };

package/dist/activity.d.mts

@@ -1,2 +1,98 @@
-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 };
+import { g as WorkerInferOutput, h as WorkerInferInput, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-C1RFkCuD.mjs";
+import { Future, Result } from "@temporal-contract/boxed";
+import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
+
+//#region src/activity.d.ts
+
+/**
+ * Activity error class that should be used to wrap all technical exceptions
+ * Forces proper error handling and enables retry policies
+ */
+declare class ActivityError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string, cause?: unknown);
+}
+/**
+ * Activity implementation using Future/Result pattern
+ *
+ * Returns Future<Result<Output, ActivityError>> for explicit error handling instead of throwing exceptions.
+ * All errors must be wrapped in ActivityError to enable proper retry policies.
+ */
+type BoxedActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Future<Result<WorkerInferOutput<TActivity>, ActivityError>>;
+/**
+ * Map of all activity implementations for a contract (global + all workflow-specific)
+ */
+type ContractBoxedActivitiesImplementations<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? BoxedActivitiesImplementations<TContract["activities"]> : {}) & { [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? BoxedActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} };
+type BoxedActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: BoxedActivityImplementation<TActivities[K]> };
+/**
+ * Options for creating activities handler
+ */
+interface DeclareActivitiesHandlerOptions<TContract extends ContractDefinition> {
+  contract: TContract;
+  activities: ContractBoxedActivitiesImplementations<TContract>;
+}
+type ActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Promise<WorkerInferOutput<TActivity>>;
+type ActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: ActivityImplementation<TActivities[K]> };
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+/**
+ * Activities handler ready for Temporal Worker
+ *
+ * Flat structure: all activities (global + all workflow-specific) are at the root level
+ */
+type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? ActivitiesImplementations<TContract["activities"]> : {}) & UnionToIntersection<{ [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? ActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} }[keyof TContract["workflows"]]>;
+/**
+ * Create a typed activities handler with automatic validation and Result pattern
+ *
+ * This wraps all activity implementations with:
+ * - Validation at network boundaries
+ * - Result<T, ActivityError> pattern for explicit error handling
+ * - Automatic conversion from Result to Promise (throwing on Error)
+ *
+ * TypeScript ensures ALL activities (global + workflow-specific) are implemented.
+ *
+ * Use this to create the activities object for the Temporal Worker.
+ *
+ * @example
+ * ```ts
+ * import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
+ * import { Result, Future } from '@temporal-contract/boxed';
+ * import myContract from './contract';
+ *
+ * export const activities = declareActivitiesHandler({
+ *   contract: myContract,
+ *   activities: {
+ *     // Activity returns Result instead of throwing
+ *     // All technical exceptions must be wrapped in ActivityError for retry policies
+ *     sendEmail: (args) => {
+ *       return Future.make(async resolve => {
+ *         try {
+ *           await emailService.send(args);
+ *           resolve(Result.Ok({ sent: true }));
+ *         } catch (error) {
+ *           // Wrap technical errors in ActivityError to enable retries
+ *           resolve(Result.Error(
+ *             new ActivityError(
+ *               'EMAIL_SEND_FAILED',
+ *               'Failed to send email',
+ *               error // Original error as cause for debugging
+ *             )
+ *           ));
+ *         }
+ *       });
+ *     },
+ *   },
+ * });
+ *
+ * // Use with Temporal Worker
+ * import { Worker } from '@temporalio/worker';
+ *
+ * const worker = await Worker.create({
+ *   workflowsPath: require.resolve('./workflows'),
+ *   activities: activities,
+ *   taskQueue: contract.taskQueue,
+ * });
+ * ```
+ */
+declare function declareActivitiesHandler<TContract extends ContractDefinition>(options: DeclareActivitiesHandlerOptions<TContract>): ActivitiesHandler<TContract>;
+//#endregion
+export { ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler };

package/dist/activity.mjs

@@ -1,3 +1,105 @@
-import { a as ActivityInputValidationError, i as ActivityError, m as WorkerError, o as ActivityOutputValidationError, r as ActivityDefinitionNotFoundError, t as declareActivitiesHandler } from "./handler-DFFpSaGN.mjs";
+import { n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-BqVTpfcf.mjs";
 
-export { ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, WorkerError, declareActivitiesHandler };
+//#region src/activity.ts
+/**
+* Activity error class that should be used to wrap all technical exceptions
+* Forces proper error handling and enables retry policies
+*/
+var ActivityError = class ActivityError extends Error {
+	constructor(code, message, cause) {
+		super(message, { cause });
+		this.code = code;
+		this.name = "ActivityError";
+		if (Error.captureStackTrace) Error.captureStackTrace(this, ActivityError);
+	}
+};
+/**
+* Create a typed activities handler with automatic validation and Result pattern
+*
+* This wraps all activity implementations with:
+* - Validation at network boundaries
+* - Result<T, ActivityError> pattern for explicit error handling
+* - Automatic conversion from Result to Promise (throwing on Error)
+*
+* TypeScript ensures ALL activities (global + workflow-specific) are implemented.
+*
+* Use this to create the activities object for the Temporal Worker.
+*
+* @example
+* ```ts
+* import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
+* import { Result, Future } from '@temporal-contract/boxed';
+* import myContract from './contract';
+*
+* export const activities = declareActivitiesHandler({
+*   contract: myContract,
+*   activities: {
+*     // Activity returns Result instead of throwing
+*     // All technical exceptions must be wrapped in ActivityError for retry policies
+*     sendEmail: (args) => {
+*       return Future.make(async resolve => {
+*         try {
+*           await emailService.send(args);
+*           resolve(Result.Ok({ sent: true }));
+*         } catch (error) {
+*           // Wrap technical errors in ActivityError to enable retries
+*           resolve(Result.Error(
+*             new ActivityError(
+*               'EMAIL_SEND_FAILED',
+*               'Failed to send email',
+*               error // Original error as cause for debugging
+*             )
+*           ));
+*         }
+*       });
+*     },
+*   },
+* });
+*
+* // Use with Temporal Worker
+* import { Worker } from '@temporalio/worker';
+*
+* const worker = await Worker.create({
+*   workflowsPath: require.resolve('./workflows'),
+*   activities: activities,
+*   taskQueue: contract.taskQueue,
+* });
+* ```
+*/
+function declareActivitiesHandler(options) {
+	const { contract, activities } = options;
+	const wrappedActivities = {};
+	function makeWrapped(activityName, activityDef, activityImpl) {
+		return 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);
+			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;
+		};
+	}
+	if (contract.activities) for (const [activityName, impl] of Object.entries(activities)) {
+		if (contract.workflows && activityName in contract.workflows) continue;
+		const activityDef = contract.activities[activityName];
+		if (!activityDef) throw new ActivityDefinitionNotFoundError(activityName, Object.keys(contract.activities));
+		wrappedActivities[activityName] = makeWrapped(activityName, activityDef, impl);
+	}
+	if (contract.workflows) for (const [workflowName, workflowDef] of Object.entries(contract.workflows)) {
+		const wfActivitiesImpl = activities[workflowName];
+		if (!wfActivitiesImpl) continue;
+		const wfDefs = workflowDef.activities ?? {};
+		for (const [activityName, impl] of Object.entries(wfActivitiesImpl)) {
+			const activityDef = wfDefs[activityName];
+			if (!activityDef) throw new ActivityDefinitionNotFoundError(`${workflowName}.${activityName}`, Object.keys(wfDefs));
+			wrappedActivities[activityName] = makeWrapped(`${workflowName}.${activityName}`, activityDef, impl);
+		}
+	}
+	return wrappedActivities;
+}
+
+//#endregion
+export { ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler };

package/dist/errors-BqVTpfcf.mjs

@@ -0,0 +1,155 @@
+//#region src/errors.ts
+/**
+* Base error class for worker errors
+*/
+var WorkerError = class extends Error {
+	constructor(message, cause) {
+		super(message, { cause });
+		this.name = "WorkerError";
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+	}
+};
+/**
+* Error thrown when an activity definition is not found in the contract
+*/
+var ActivityDefinitionNotFoundError = class extends WorkerError {
+	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";
+	}
+};
+/**
+* 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";
+	}
+};
+/**
+* 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
+export { ChildWorkflowNotFoundError as a, SignalInputValidationError as c, WorkflowInputValidationError as d, WorkflowOutputValidationError as f, ChildWorkflowError as i, UpdateInputValidationError as l, ActivityInputValidationError as n, QueryInputValidationError as o, ActivityOutputValidationError as r, QueryOutputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateOutputValidationError as u };