@temporal-contract/worker 0.0.1

package/dist/handler-aA2RFdV7.mjs

@@ -0,0 +1,409 @@
+import { defineQuery, defineSignal, defineUpdate, proxyActivities, setHandler, workflowInfo } from "@temporalio/workflow";
+import { ZodError } from "zod";
+
+//#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, zodError) {
+		super(`Activity "${activityName}" input validation failed: ${zodError.message}`);
+		this.activityName = activityName;
+		this.zodError = zodError;
+		this.name = "ActivityInputValidationError";
+	}
+};
+/**
+* Error thrown when activity output validation fails
+*/
+var ActivityOutputValidationError = class extends WorkerError {
+	constructor(activityName, zodError) {
+		super(`Activity "${activityName}" output validation failed: ${zodError.message}`);
+		this.activityName = activityName;
+		this.zodError = zodError;
+		this.name = "ActivityOutputValidationError";
+	}
+};
+/**
+* Error thrown when workflow input validation fails
+*/
+var WorkflowInputValidationError = class extends WorkerError {
+	constructor(workflowName, zodError) {
+		super(`Workflow "${workflowName}" input validation failed: ${zodError.message}`);
+		this.workflowName = workflowName;
+		this.zodError = zodError;
+		this.name = "WorkflowInputValidationError";
+	}
+};
+/**
+* Error thrown when workflow output validation fails
+*/
+var WorkflowOutputValidationError = class extends WorkerError {
+	constructor(workflowName, zodError) {
+		super(`Workflow "${workflowName}" output validation failed: ${zodError.message}`);
+		this.workflowName = workflowName;
+		this.zodError = zodError;
+		this.name = "WorkflowOutputValidationError";
+	}
+};
+/**
+* Error thrown when signal input validation fails
+*/
+var SignalInputValidationError = class extends WorkerError {
+	constructor(signalName, zodError) {
+		super(`Signal "${signalName}" input validation failed: ${zodError.message}`);
+		this.signalName = signalName;
+		this.zodError = zodError;
+		this.name = "SignalInputValidationError";
+	}
+};
+/**
+* Error thrown when query input validation fails
+*/
+var QueryInputValidationError = class extends WorkerError {
+	constructor(queryName, zodError) {
+		super(`Query "${queryName}" input validation failed: ${zodError.message}`);
+		this.queryName = queryName;
+		this.zodError = zodError;
+		this.name = "QueryInputValidationError";
+	}
+};
+/**
+* Error thrown when query output validation fails
+*/
+var QueryOutputValidationError = class extends WorkerError {
+	constructor(queryName, zodError) {
+		super(`Query "${queryName}" output validation failed: ${zodError.message}`);
+		this.queryName = queryName;
+		this.zodError = zodError;
+		this.name = "QueryOutputValidationError";
+	}
+};
+/**
+* Error thrown when update input validation fails
+*/
+var UpdateInputValidationError = class extends WorkerError {
+	constructor(updateName, zodError) {
+		super(`Update "${updateName}" input validation failed: ${zodError.message}`);
+		this.updateName = updateName;
+		this.zodError = zodError;
+		this.name = "UpdateInputValidationError";
+	}
+};
+/**
+* Error thrown when update output validation fails
+*/
+var UpdateOutputValidationError = class extends WorkerError {
+	constructor(updateName, zodError) {
+		super(`Update "${updateName}" output validation failed: ${zodError.message}`);
+		this.updateName = updateName;
+		this.zodError = zodError;
+		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));
+		validatedActivities[activityName] = async (input) => {
+			let validatedInput;
+			try {
+				validatedInput = activityDef.input.parse(input);
+			} catch (error) {
+				if (error instanceof ZodError) throw new ActivityInputValidationError(activityName, error);
+				throw error;
+			}
+			const result = await rawActivity(validatedInput);
+			try {
+				return activityDef.output.parse(result);
+			} catch (error) {
+				if (error instanceof ZodError) throw new ActivityOutputValidationError(activityName, error);
+				throw error;
+			}
+		};
+	}
+	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) => {
+			let validatedInput;
+			try {
+				validatedInput = activityDef.input.parse(input);
+			} catch (error) {
+				if (error instanceof ZodError) throw new ActivityInputValidationError(activityName, error);
+				throw error;
+			}
+			const result = await activityImpl(validatedInput);
+			try {
+				return activityDef.output.parse(result);
+			} catch (error) {
+				if (error instanceof ZodError) throw new ActivityOutputValidationError(activityName, error);
+				throw error;
+			}
+		};
+	}
+	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;
+		let validatedInput;
+		try {
+			validatedInput = definition.input.parse(singleArg);
+		} catch (error) {
+			if (error instanceof ZodError) throw new WorkflowInputValidationError(String(workflowName), error);
+			throw error;
+		}
+		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;
+					let validatedInput$1;
+					try {
+						validatedInput$1 = signalDef.input.parse(input);
+					} catch (error) {
+						if (error instanceof ZodError) throw new SignalInputValidationError(signalName, error);
+						throw error;
+					}
+					await handler(validatedInput$1);
+				});
+			}
+		}
+		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;
+					let validatedInput$1;
+					try {
+						validatedInput$1 = queryDef.input.parse(input);
+					} catch (error) {
+						if (error instanceof ZodError) throw new QueryInputValidationError(queryName, error);
+						throw error;
+					}
+					const result$1 = handler(validatedInput$1);
+					try {
+						return queryDef.output.parse(result$1);
+					} catch (error) {
+						if (error instanceof ZodError) throw new QueryOutputValidationError(queryName, error);
+						throw error;
+					}
+				});
+			}
+		}
+		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;
+					let validatedInput$1;
+					try {
+						validatedInput$1 = updateDef.input.parse(input);
+					} catch (error) {
+						if (error instanceof ZodError) throw new UpdateInputValidationError(updateName, error);
+						throw error;
+					}
+					const result$1 = await handler(validatedInput$1);
+					try {
+						return updateDef.output.parse(result$1);
+					} catch (error) {
+						if (error instanceof ZodError) throw new UpdateOutputValidationError(updateName, error);
+						throw error;
+					}
+				});
+			}
+		}
+		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);
+		try {
+			return definition.output.parse(result);
+		} catch (error) {
+			if (error instanceof ZodError) throw new WorkflowOutputValidationError(String(workflowName), error);
+			throw error;
+		}
+	};
+}
+
+//#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 };

package/dist/workflow.cjs

@@ -0,0 +1,11 @@
+const require_handler = require('./handler-B3KY0uDx.cjs');
+
+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;

package/dist/workflow.d.cts

@@ -0,0 +1,2 @@
+import { S as WorkflowImplementation, _ as QueryHandlerImplementation, a as QueryInputValidationError, b as UpdateHandlerImplementation, c as UpdateInputValidationError, d as WorkflowInputValidationError, f as WorkflowOutputValidationError, g as DeclareWorkflowOptions, l as UpdateOutputValidationError, o as QueryOutputValidationError, s as SignalInputValidationError, u as WorkerError, w as declareWorkflow, x as WorkflowContext, y as SignalHandlerImplementation } from "./errors-CqX81ysy.cjs";
+export { type DeclareWorkflowOptions, type QueryHandlerImplementation, QueryInputValidationError, QueryOutputValidationError, type SignalHandlerImplementation, SignalInputValidationError, type UpdateHandlerImplementation, UpdateInputValidationError, UpdateOutputValidationError, WorkerError, type WorkflowContext, type WorkflowImplementation, WorkflowInputValidationError, WorkflowOutputValidationError, declareWorkflow };

package/dist/workflow.d.mts

@@ -0,0 +1,2 @@
+import { S as WorkflowImplementation, _ as QueryHandlerImplementation, a as QueryInputValidationError, b as UpdateHandlerImplementation, c as UpdateInputValidationError, d as WorkflowInputValidationError, f as WorkflowOutputValidationError, g as DeclareWorkflowOptions, l as UpdateOutputValidationError, o as QueryOutputValidationError, s as SignalInputValidationError, u as WorkerError, w as declareWorkflow, x as WorkflowContext, y as SignalHandlerImplementation } from "./errors-oc-Iiwmu.mjs";
+export { type DeclareWorkflowOptions, type QueryHandlerImplementation, QueryInputValidationError, QueryOutputValidationError, type SignalHandlerImplementation, SignalInputValidationError, type UpdateHandlerImplementation, UpdateInputValidationError, UpdateOutputValidationError, WorkerError, type WorkflowContext, type WorkflowImplementation, WorkflowInputValidationError, WorkflowOutputValidationError, declareWorkflow };

package/dist/workflow.mjs

@@ -0,0 +1,3 @@
+import { c as QueryOutputValidationError, d as UpdateOutputValidationError, f as WorkerError, l as SignalInputValidationError, m as WorkflowOutputValidationError, n as declareWorkflow, p as WorkflowInputValidationError, s as QueryInputValidationError, u as UpdateInputValidationError } from "./handler-aA2RFdV7.mjs";
+
+export { QueryInputValidationError, QueryOutputValidationError, SignalInputValidationError, UpdateInputValidationError, UpdateOutputValidationError, WorkerError, WorkflowInputValidationError, WorkflowOutputValidationError, declareWorkflow };

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@temporal-contract/worker",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "Worker utilities for implementing temporal-contract workflows and activities",
+  "homepage": "https://github.com/btravers/temporal-contract#readme",
+  "bugs": {
+    "url": "https://github.com/btravers/temporal-contract/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/btravers/temporal-contract.git",
+    "directory": "packages/worker"
+  },
+  "author": "Benoit TRAVERS <benoit.travers.frgmail.com>",
+  "license": "MIT",
+  "keywords": [
+    "temporal",
+    "typescript",
+    "contract",
+    "worker"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    "./activity": {
+      "import": {
+        "types": "./dist/activity.d.mts",
+        "default": "./dist/activity.mjs"
+      },
+      "require": {
+        "types": "./dist/activity.d.cts",
+        "default": "./dist/activity.cjs"
+      }
+    },
+    "./workflow": {
+      "import": {
+        "types": "./dist/workflow.d.mts",
+        "default": "./dist/workflow.mjs"
+      },
+      "require": {
+        "types": "./dist/workflow.d.cts",
+        "default": "./dist/workflow.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@temporal-contract/contract": "0.0.1"
+  },
+  "devDependencies": {
+    "@temporalio/workflow": "1.13.2",
+    "@types/node": "24.10.2",
+    "tsdown": "0.17.2",
+    "typescript": "5.9.3",
+    "vitest": "4.0.15",
+    "zod": "4.1.13",
+    "@temporal-contract/tsconfig": "0.0.1"
+  },
+  "peerDependencies": {
+    "@temporalio/workflow": ">=1.13.0 <2.0.0",
+    "zod": "^4.0.0"
+  },
+  "scripts": {
+    "dev": "tsdown src/activity.ts src/workflow.ts --format cjs,esm --dts --watch",
+    "build": "tsdown src/activity.ts src/workflow.ts --format cjs,esm --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}

package/src/activity.ts

@@ -0,0 +1,15 @@
+// Entry point for activities
+export { declareActivitiesHandler } from "./handler.js";
+export type {
+  RawActivityImplementation,
+  ActivityImplementations,
+  DeclareActivitiesHandlerOptions,
+  ActivitiesHandler,
+} from "./handler.js";
+export {
+  WorkerError,
+  ActivityImplementationNotFoundError,
+  ActivityDefinitionNotFoundError,
+  ActivityInputValidationError,
+  ActivityOutputValidationError,
+} from "./errors.js";

package/src/errors.ts

@@ -0,0 +1,164 @@
+import type { z } from "zod";
+
+/**
+ * Base error class for worker errors
+ */
+export class WorkerError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "WorkerError";
+    // Maintains proper stack trace for where our error was thrown (only available on V8)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+/**
+ * Error thrown when an activity implementation is not found
+ */
+export class ActivityImplementationNotFoundError extends WorkerError {
+  constructor(
+    public readonly activityName: string,
+    public readonly availableActivities: readonly string[],
+  ) {
+    super(
+      `Activity implementation not found for: "${activityName}". ` +
+        `Available activities: ${availableActivities.length > 0 ? availableActivities.join(", ") : "none"}`,
+    );
+    this.name = "ActivityImplementationNotFoundError";
+  }
+}
+
+/**
+ * Error thrown when an activity definition is not found in the contract
+ */
+export class ActivityDefinitionNotFoundError extends WorkerError {
+  constructor(
+    public readonly activityName: string,
+    public readonly availableDefinitions: readonly string[],
+  ) {
+    super(
+      `Activity definition not found in contract for: "${activityName}". ` +
+        `Available definitions: ${availableDefinitions.length > 0 ? availableDefinitions.join(", ") : "none"}`,
+    );
+    this.name = "ActivityDefinitionNotFoundError";
+  }
+}
+
+/**
+ * Error thrown when activity input validation fails
+ */
+export class ActivityInputValidationError extends WorkerError {
+  constructor(
+    public readonly activityName: string,
+    public readonly zodError: z.ZodError,
+  ) {
+    super(`Activity "${activityName}" input validation failed: ${zodError.message}`);
+    this.name = "ActivityInputValidationError";
+  }
+}
+
+/**
+ * Error thrown when activity output validation fails
+ */
+export class ActivityOutputValidationError extends WorkerError {
+  constructor(
+    public readonly activityName: string,
+    public readonly zodError: z.ZodError,
+  ) {
+    super(`Activity "${activityName}" output validation failed: ${zodError.message}`);
+    this.name = "ActivityOutputValidationError";
+  }
+}
+
+/**
+ * Error thrown when workflow input validation fails
+ */
+export class WorkflowInputValidationError extends WorkerError {
+  constructor(
+    public readonly workflowName: string,
+    public readonly zodError: z.ZodError,
+  ) {
+    super(`Workflow "${workflowName}" input validation failed: ${zodError.message}`);
+    this.name = "WorkflowInputValidationError";
+  }
+}
+
+/**
+ * Error thrown when workflow output validation fails
+ */
+export class WorkflowOutputValidationError extends WorkerError {
+  constructor(
+    public readonly workflowName: string,
+    public readonly zodError: z.ZodError,
+  ) {
+    super(`Workflow "${workflowName}" output validation failed: ${zodError.message}`);
+    this.name = "WorkflowOutputValidationError";
+  }
+}
+
+/**
+ * Error thrown when signal input validation fails
+ */
+export class SignalInputValidationError extends WorkerError {
+  constructor(
+    public readonly signalName: string,
+    public readonly zodError: z.ZodError,
+  ) {
+    super(`Signal "${signalName}" input validation failed: ${zodError.message}`);
+    this.name = "SignalInputValidationError";
+  }
+}
+
+/**
+ * Error thrown when query input validation fails
+ */
+export class QueryInputValidationError extends WorkerError {
+  constructor(
+    public readonly queryName: string,
+    public readonly zodError: z.ZodError,
+  ) {
+    super(`Query "${queryName}" input validation failed: ${zodError.message}`);
+    this.name = "QueryInputValidationError";
+  }
+}
+
+/**
+ * Error thrown when query output validation fails
+ */
+export class QueryOutputValidationError extends WorkerError {
+  constructor(
+    public readonly queryName: string,
+    public readonly zodError: z.ZodError,
+  ) {
+    super(`Query "${queryName}" output validation failed: ${zodError.message}`);
+    this.name = "QueryOutputValidationError";
+  }
+}
+
+/**
+ * Error thrown when update input validation fails
+ */
+export class UpdateInputValidationError extends WorkerError {
+  constructor(
+    public readonly updateName: string,
+    public readonly zodError: z.ZodError,
+  ) {
+    super(`Update "${updateName}" input validation failed: ${zodError.message}`);
+    this.name = "UpdateInputValidationError";
+  }
+}
+
+/**
+ * Error thrown when update output validation fails
+ */
+export class UpdateOutputValidationError extends WorkerError {
+  constructor(
+    public readonly updateName: string,
+    public readonly zodError: z.ZodError,
+  ) {
+    super(`Update "${updateName}" output validation failed: ${zodError.message}`);
+    this.name = "UpdateOutputValidationError";
+  }
+}