@temporal-contract/worker 0.1.0 → 0.2.0

package/dist/worker.d.mts

@@ -1,4 +1,4 @@
-import { t as ActivitiesHandler } from "./activity-BUEBZ7SL.mjs";
+import { ActivitiesHandler } from "./activity.mjs";
 import { Worker, WorkerOptions } from "@temporalio/worker";
 import { ContractDefinition } from "@temporal-contract/contract";
 
@@ -6,7 +6,7 @@ import { ContractDefinition } from "@temporal-contract/contract";
 /**
  * Options for creating a Temporal worker
  */
-interface CreateWorkerOptions<TContract extends ContractDefinition> extends Omit<WorkerOptions, "activities" | "taskQueue"> {
+type CreateWorkerOptions<TContract extends ContractDefinition> = Omit<WorkerOptions, "activities" | "taskQueue"> & {
   /**
    * The contract definition for this worker
    */
@@ -15,7 +15,7 @@ interface CreateWorkerOptions<TContract extends ContractDefinition> extends Omit
    * Activities handler for this worker
    */
   activities: ActivitiesHandler<TContract>;
-}
+};
 /**
  * Create a typed Temporal worker with contract-based configuration
  *
@@ -46,9 +46,14 @@ interface CreateWorkerOptions<TContract extends ContractDefinition> extends Omit
  */
 declare function createWorker<TContract extends ContractDefinition>(options: CreateWorkerOptions<TContract>): Promise<Worker>;
 /**
- * Helper to create a workflowsPath from a file URL
+ * Helper to resolve a workflow file path relative to the current module's URL.
  *
- * Useful for creating the workflowsPath option when using ES modules
+ * Useful when using ES modules (`import.meta.url`) to locate workflow files.
+ * The `relativePath` should include the file extension explicitly (e.g. `./workflows.js`)
+ * to ensure the resolved path is unambiguous in both source and built contexts.
+ *
+ * @param baseURL - The base URL to resolve from, typically `import.meta.url`
+ * @param relativePath - Relative path to the workflows file, **including extension**
  *
  * @example
  * ```ts
@@ -57,11 +62,13 @@ declare function createWorker<TContract extends ContractDefinition>(options: Cre
  * const worker = await createWorker({
  *   contract: myContract,
  *   connection,
- *   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows'),
+ *   // Include the extension explicitly to work in both source (.ts) and build (.js) contexts
+ *   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows.js'),
  *   activities,
  * });
  * ```
  */
 declare function workflowsPathFromURL(baseURL: string, relativePath: string): string;
 //#endregion
-export { CreateWorkerOptions, createWorker, workflowsPathFromURL };
+export { CreateWorkerOptions, createWorker, workflowsPathFromURL };
+//# sourceMappingURL=worker.d.mts.map

package/dist/worker.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.mts","names":[],"sources":["../src/worker.ts"],"mappings":";;;;;;;AASA;KAAY,mBAAA,mBAAsC,kBAAA,IAAsB,IAAA,CACtE,aAAA;EAD6B;;;EAO7B,QAAA,EAAU,SAAA;EAAA;;;EAKV,UAAA,EAAY,iBAAA,CAAkB,SAAA;AAAA;;;;;;;;;;;;AA+BhC;;;;;;;;;;;;;;;;;iBAAsB,YAAA,mBAA+B,kBAAA,CAAA,CACnD,OAAA,EAAS,mBAAA,CAAoB,SAAA,IAC5B,OAAA,CAAQ,MAAA;;AAkCX;;;;;;;;;;;;;;;;;;;;;;iBAAgB,oBAAA,CAAqB,OAAA,UAAiB,YAAA"}

package/dist/worker.mjs

@@ -1,6 +1,5 @@
 import { Worker } from "@temporalio/worker";
 import { fileURLToPath } from "node:url";
-import { extname } from "node:path";
 
 //#region src/worker.ts
 /**
@@ -40,9 +39,14 @@ async function createWorker(options) {
 	});
 }
 /**
-* Helper to create a workflowsPath from a file URL
+* Helper to resolve a workflow file path relative to the current module's URL.
 *
-* Useful for creating the workflowsPath option when using ES modules
+* Useful when using ES modules (`import.meta.url`) to locate workflow files.
+* The `relativePath` should include the file extension explicitly (e.g. `./workflows.js`)
+* to ensure the resolved path is unambiguous in both source and built contexts.
+*
+* @param baseURL - The base URL to resolve from, typically `import.meta.url`
+* @param relativePath - Relative path to the workflows file, **including extension**
 *
 * @example
 * ```ts
@@ -51,14 +55,16 @@ async function createWorker(options) {
 * const worker = await createWorker({
 *   contract: myContract,
 *   connection,
-*   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows'),
+*   // Include the extension explicitly to work in both source (.ts) and build (.js) contexts
+*   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows.js'),
 *   activities,
 * });
 * ```
 */
 function workflowsPathFromURL(baseURL, relativePath) {
-	return fileURLToPath(new URL(`${relativePath}${extname(baseURL)}`, baseURL));
+	return fileURLToPath(new URL(relativePath, baseURL));
 }
 
 //#endregion
-export { createWorker, workflowsPathFromURL };
+export { createWorker, workflowsPathFromURL };
+//# sourceMappingURL=worker.mjs.map

package/dist/worker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.mjs","names":[],"sources":["../src/worker.ts"],"sourcesContent":["// Entry point for worker creation utilities\nimport { ContractDefinition } from \"@temporal-contract/contract\";\nimport { Worker, WorkerOptions } from \"@temporalio/worker\";\nimport { fileURLToPath } from \"node:url\";\nimport type { ActivitiesHandler } from \"./activity.js\";\n\n/**\n * Options for creating a Temporal worker\n */\nexport type CreateWorkerOptions<TContract extends ContractDefinition> = Omit<\n  WorkerOptions,\n  \"activities\" | \"taskQueue\"\n> & {\n  /**\n   * The contract definition for this worker\n   */\n  contract: TContract;\n\n  /**\n   * Activities handler for this worker\n   */\n  activities: ActivitiesHandler<TContract>;\n};\n\n/**\n * Create a typed Temporal worker with contract-based configuration\n *\n * This helper simplifies worker creation by:\n * - Using the contract's task queue automatically\n * - Providing type-safe configuration\n *\n * @example\n * ```ts\n * import { NativeConnection } from '@temporalio/worker';\n * import { createWorker } from '@temporal-contract/worker/worker';\n * import { activities } from './activities';\n * import myContract from './contract';\n *\n * const connection = await NativeConnection.connect({\n *   address: 'localhost:7233',\n * });\n *\n * const worker = await createWorker({\n *   contract: myContract,\n *   connection,\n *   workflowsPath: require.resolve('./workflows'),\n *   activities,\n * });\n *\n * await worker.run();\n * ```\n */\nexport async function createWorker<TContract extends ContractDefinition>(\n  options: CreateWorkerOptions<TContract>,\n): Promise<Worker> {\n  const { contract, activities, ...workerOptions } = options;\n\n  // Create the worker with contract's task queue\n  return await Worker.create({\n    ...workerOptions,\n    activities,\n    taskQueue: contract.taskQueue,\n  });\n}\n\n/**\n * Helper to resolve a workflow file path relative to the current module's URL.\n *\n * Useful when using ES modules (`import.meta.url`) to locate workflow files.\n * The `relativePath` should include the file extension explicitly (e.g. `./workflows.js`)\n * to ensure the resolved path is unambiguous in both source and built contexts.\n *\n * @param baseURL - The base URL to resolve from, typically `import.meta.url`\n * @param relativePath - Relative path to the workflows file, **including extension**\n *\n * @example\n * ```ts\n * import { workflowsPathFromURL } from '@temporal-contract/worker/worker';\n *\n * const worker = await createWorker({\n *   contract: myContract,\n *   connection,\n *   // Include the extension explicitly to work in both source (.ts) and build (.js) contexts\n *   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows.js'),\n *   activities,\n * });\n * ```\n */\nexport function workflowsPathFromURL(baseURL: string, relativePath: string): string {\n  return fileURLToPath(new URL(relativePath, baseURL));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,eAAsB,aACpB,SACiB;CACjB,MAAM,EAAE,UAAU,YAAY,GAAG,kBAAkB;AAGnD,QAAO,MAAM,OAAO,OAAO;EACzB,GAAG;EACH;EACA,WAAW,SAAS;EACrB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;AA0BJ,SAAgB,qBAAqB,SAAiB,cAA8B;AAClF,QAAO,cAAc,IAAI,IAAI,cAAc,QAAQ,CAAC"}

package/dist/workflow.cjs

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_errors = require('./errors-DjSZg-93.cjs');
 let _temporal_contract_boxed = require("@temporal-contract/boxed");
 let _temporalio_workflow = require("@temporalio/workflow");
@@ -17,53 +18,53 @@ let _temporalio_workflow = require("@temporalio/workflow");
 * @example
 * ```ts
 * // workflows/processOrder.ts
-* import { declareWorkflow } from '@temporal-contract/worker';
+* import { declareWorkflow } from '@temporal-contract/worker/workflow';
 * import myContract from '../contract';
 *
 * export const processOrder = declareWorkflow({
 *   workflowName: 'processOrder',
 *   contract: myContract,
-*   implementation: async (context, orderId, customerId) => {
+*   activityOptions: {
+*     startToCloseTimeout: '1 minute',
+*   },
+*   implementation: async (context, args) => {
 *     // context.activities: typed activities (workflow + global)
 *     // context.info: WorkflowInfo
 *
-*     const inventory = await context.activities.validateInventory(orderId);
+*     const inventory = await context.activities.validateInventory({
+*       orderId: args.orderId,
+*     });
 *
 *     if (!inventory.available) {
-*       throw new Error('Out of stock');
+*       return { orderId: args.orderId, status: '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'
-*     );
+*     const payment = await context.activities.chargePayment({
+*       customerId: args.customerId,
+*       amount: 100,
+*     });
 *
 *     return {
-*       orderId,
+*       orderId: args.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';
+* import { createWorker } from '@temporal-contract/worker/worker';
+* import { activities } from './activities';
+* import myContract from './contract';
 *
-* const worker = await Worker.create({
-*   workflowsPath: require.resolve('./workflows'), // Imports processOrder
-*   activities: activitiesHandler.activities,
-*   taskQueue: activitiesHandler.contract.taskQueue,
+* const worker = await createWorker({
+*   contract: myContract,
+*   connection,
+*   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows.js'),
+*   activities,
 * });
 * ```
 */
@@ -76,20 +77,20 @@ function declareWorkflow({ workflowName, contract, implementation, activityOptio
 		const validatedInput = inputResult.value;
 		let contextActivities = {};
 		if (definition.activities || contract.activities) contextActivities = createValidatedActivities((0, _temporalio_workflow.proxyActivities)(activityOptions), definition.activities, contract.activities);
-		async function validateChildWorkflowOutput(childDefinition, result$1, childWorkflowName) {
-			const outputResult$1 = await childDefinition.output["~standard"].validate(result$1);
-			if (outputResult$1.issues) return _temporal_contract_boxed.Result.Error(new require_errors.ChildWorkflowError(`Child workflow "${childWorkflowName}" output validation failed: ${outputResult$1.issues.map((i) => i.message).join("; ")}`));
-			return _temporal_contract_boxed.Result.Ok(outputResult$1.value);
+		async function validateChildWorkflowOutput(childDefinition, result, childWorkflowName) {
+			const outputResult = await childDefinition.output["~standard"].validate(result);
+			if (outputResult.issues) return _temporal_contract_boxed.Result.Error(new require_errors.ChildWorkflowError(`Child workflow "${childWorkflowName}" output validation failed: ${outputResult.issues.map((i) => i.message).join("; ")}`));
+			return _temporal_contract_boxed.Result.Ok(outputResult.value);
 		}
-		async function getAndValidateChildWorkflow(childContract, childWorkflowName, args$1) {
+		async function getAndValidateChildWorkflow(childContract, childWorkflowName, args) {
 			const childDefinition = childContract.workflows[childWorkflowName];
 			if (!childDefinition) return _temporal_contract_boxed.Result.Error(new require_errors.ChildWorkflowNotFoundError(String(childWorkflowName), Object.keys(childContract.workflows)));
-			const inputResult$1 = await childDefinition.input["~standard"].validate(args$1);
-			if (inputResult$1.issues) return _temporal_contract_boxed.Result.Error(new require_errors.ChildWorkflowError(`Child workflow "${String(childWorkflowName)}" input validation failed: ${inputResult$1.issues.map((i) => i.message).join("; ")}`));
-			const validatedInput$1 = inputResult$1.value;
+			const inputResult = await childDefinition.input["~standard"].validate(args);
+			if (inputResult.issues) return _temporal_contract_boxed.Result.Error(new require_errors.ChildWorkflowError(`Child workflow "${String(childWorkflowName)}" input validation failed: ${inputResult.issues.map((i) => i.message).join("; ")}`));
+			const validatedInput = inputResult.value;
 			return _temporal_contract_boxed.Result.Ok({
 				definition: childDefinition,
-				validatedInput: validatedInput$1,
+				validatedInput,
 				taskQueue: childContract.taskQueue
 			});
 		}
@@ -97,107 +98,92 @@ function declareWorkflow({ workflowName, contract, implementation, activityOptio
 			return {
 				workflowId: handle.workflowId,
 				result: () => {
-					return _temporal_contract_boxed.Future.make((resolve) => {
-						(async () => {
-							try {
-								resolve(await validateChildWorkflowOutput(childDefinition, await handle.result(), childWorkflowName));
-							} catch (error) {
-								resolve(_temporal_contract_boxed.Result.Error(new require_errors.ChildWorkflowError(`Child workflow execution failed: ${error instanceof Error ? error.message : String(error)}`, error)));
-							}
-						})();
+					return _temporal_contract_boxed.Future.fromAsync(async () => {
+						try {
+							return validateChildWorkflowOutput(childDefinition, await handle.result(), childWorkflowName);
+						} catch (error) {
+							return _temporal_contract_boxed.Result.Error(new require_errors.ChildWorkflowError(`Child workflow execution failed: ${error instanceof Error ? error.message : String(error)}`, error));
+						}
 					});
 				}
 			};
 		}
 		function createStartChildWorkflow(childContract, childWorkflowName, options) {
-			return _temporal_contract_boxed.Future.make((resolve) => {
-				(async () => {
-					const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options.args);
-					if (validationResult.isError()) {
-						resolve(_temporal_contract_boxed.Result.Error(validationResult.error));
-						return;
-					}
-					const { definition: childDefinition, validatedInput: validatedInput$1, taskQueue } = validationResult.value;
-					try {
-						const { args: _args, ...temporalOptions } = options;
-						const typedHandle = createTypedChildHandle(await (0, _temporalio_workflow.startChild)(childWorkflowName, {
-							...temporalOptions,
-							taskQueue,
-							args: [validatedInput$1]
-						}), childDefinition, String(childWorkflowName));
-						resolve(_temporal_contract_boxed.Result.Ok(typedHandle));
-					} catch (error) {
-						resolve(_temporal_contract_boxed.Result.Error(new require_errors.ChildWorkflowError(`Failed to start child workflow: ${error instanceof Error ? error.message : String(error)}`, error)));
-					}
-				})();
+			return _temporal_contract_boxed.Future.fromAsync(async () => {
+				const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options.args);
+				if (validationResult.isError()) return _temporal_contract_boxed.Result.Error(validationResult.error);
+				const { definition: childDefinition, validatedInput, taskQueue } = validationResult.value;
+				try {
+					const { args: _args, ...temporalOptions } = options;
+					const typedHandle = createTypedChildHandle(await (0, _temporalio_workflow.startChild)(childWorkflowName, {
+						...temporalOptions,
+						taskQueue,
+						args: [validatedInput]
+					}), childDefinition, String(childWorkflowName));
+					return _temporal_contract_boxed.Result.Ok(typedHandle);
+				} catch (error) {
+					return _temporal_contract_boxed.Result.Error(new require_errors.ChildWorkflowError(`Failed to start child workflow: ${error instanceof Error ? error.message : String(error)}`, error));
+				}
 			});
 		}
 		function createExecuteChildWorkflow(childContract, childWorkflowName, options) {
-			return _temporal_contract_boxed.Future.make((resolve) => {
-				(async () => {
-					const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options.args);
-					if (validationResult.isError()) {
-						resolve(_temporal_contract_boxed.Result.Error(validationResult.error));
-						return;
-					}
-					const { definition: childDefinition, validatedInput: validatedInput$1, taskQueue } = validationResult.value;
-					try {
-						const { args: _args, ...temporalOptions } = options;
-						const outputValidationResult = await validateChildWorkflowOutput(childDefinition, await (0, _temporalio_workflow.executeChild)(childWorkflowName, {
-							...temporalOptions,
-							taskQueue,
-							args: [validatedInput$1]
-						}), String(childWorkflowName));
-						if (outputValidationResult.isError()) {
-							resolve(_temporal_contract_boxed.Result.Error(outputValidationResult.error));
-							return;
-						}
-						resolve(_temporal_contract_boxed.Result.Ok(outputValidationResult.value));
-					} catch (error) {
-						resolve(_temporal_contract_boxed.Result.Error(new require_errors.ChildWorkflowError(`Failed to execute child workflow: ${error instanceof Error ? error.message : String(error)}`, error)));
-					}
-				})();
+			return _temporal_contract_boxed.Future.fromAsync(async () => {
+				const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options.args);
+				if (validationResult.isError()) return _temporal_contract_boxed.Result.Error(validationResult.error);
+				const { definition: childDefinition, validatedInput, taskQueue } = validationResult.value;
+				try {
+					const { args: _args, ...temporalOptions } = options;
+					const outputValidationResult = await validateChildWorkflowOutput(childDefinition, await (0, _temporalio_workflow.executeChild)(childWorkflowName, {
+						...temporalOptions,
+						taskQueue,
+						args: [validatedInput]
+					}), String(childWorkflowName));
+					if (outputValidationResult.isError()) return _temporal_contract_boxed.Result.Error(outputValidationResult.error);
+					return _temporal_contract_boxed.Result.Ok(outputValidationResult.value);
+				} catch (error) {
+					return _temporal_contract_boxed.Result.Error(new require_errors.ChildWorkflowError(`Failed to execute child workflow: ${error instanceof Error ? error.message : String(error)}`, error));
+				}
 			});
 		}
 		function createDefineSignal(signalName, handler) {
 			if (!definition.signals) throw new Error(`Signal "${String(signalName)}" cannot be defined: workflow "${String(workflowName)}" has no signals in its contract`);
 			const signalDef = definition.signals[signalName];
 			if (!signalDef) throw new Error(`Signal "${String(signalName)}" not found in workflow "${String(workflowName)}" contract`);
-			(0, _temporalio_workflow.setHandler)((0, _temporalio_workflow.defineSignal)(signalName), async (...args$1) => {
-				const input$1 = args$1.length === 1 ? args$1[0] : args$1;
-				const inputResult$1 = await signalDef.input["~standard"].validate(input$1);
-				if (inputResult$1.issues) throw new require_errors.SignalInputValidationError(signalName, inputResult$1.issues);
-				await handler(inputResult$1.value);
+			(0, _temporalio_workflow.setHandler)((0, _temporalio_workflow.defineSignal)(signalName), async (...args) => {
+				const input = args.length === 1 ? args[0] : args;
+				const inputResult = await signalDef.input["~standard"].validate(input);
+				if (inputResult.issues) throw new require_errors.SignalInputValidationError(signalName, inputResult.issues);
+				await handler(inputResult.value);
 			});
 		}
 		function createDefineQuery(queryName, handler) {
 			if (!definition.queries) throw new Error(`Query "${String(queryName)}" cannot be defined: workflow "${String(workflowName)}" has no queries in its contract`);
 			const queryDef = definition.queries[queryName];
 			if (!queryDef) throw new Error(`Query "${String(queryName)}" not found in workflow "${String(workflowName)}" contract`);
-			(0, _temporalio_workflow.setHandler)((0, _temporalio_workflow.defineQuery)(queryName), (...args$1) => {
-				const input$1 = args$1.length === 1 ? args$1[0] : args$1;
-				const inputResult$1 = queryDef.input["~standard"].validate(input$1);
-				if (inputResult$1 instanceof Promise) throw new Error(`Query "${String(queryName)}" validation must be synchronous. Use a schema library that supports synchronous validation for queries.`);
-				if (inputResult$1.issues) throw new require_errors.QueryInputValidationError(queryName, inputResult$1.issues);
-				const result$1 = handler(inputResult$1.value);
-				const outputResult$1 = queryDef.output["~standard"].validate(result$1);
-				if (outputResult$1 instanceof Promise) throw new Error(`Query "${String(queryName)}" output validation must be synchronous. Use a schema library that supports synchronous validation for queries.`);
-				if (outputResult$1.issues) throw new require_errors.QueryOutputValidationError(queryName, outputResult$1.issues);
-				return outputResult$1.value;
+			(0, _temporalio_workflow.setHandler)((0, _temporalio_workflow.defineQuery)(queryName), (...args) => {
+				const input = args.length === 1 ? args[0] : args;
+				const inputResult = queryDef.input["~standard"].validate(input);
+				if (inputResult instanceof Promise) throw new Error(`Query "${String(queryName)}" validation must be synchronous. Use a schema library that supports synchronous validation for queries.`);
+				if (inputResult.issues) throw new require_errors.QueryInputValidationError(queryName, inputResult.issues);
+				const result = handler(inputResult.value);
+				const outputResult = queryDef.output["~standard"].validate(result);
+				if (outputResult instanceof Promise) throw new Error(`Query "${String(queryName)}" output validation must be synchronous. Use a schema library that supports synchronous validation for queries.`);
+				if (outputResult.issues) throw new require_errors.QueryOutputValidationError(queryName, outputResult.issues);
+				return outputResult.value;
 			});
 		}
 		function createDefineUpdate(updateName, handler) {
 			if (!definition.updates) throw new Error(`Update "${String(updateName)}" cannot be defined: workflow "${String(workflowName)}" has no updates in its contract`);
 			const updateDef = definition.updates[updateName];
 			if (!updateDef) throw new Error(`Update "${String(updateName)}" not found in workflow "${String(workflowName)}" contract`);
-			(0, _temporalio_workflow.setHandler)((0, _temporalio_workflow.defineUpdate)(updateName), async (...args$1) => {
-				const input$1 = args$1.length === 1 ? args$1[0] : args$1;
-				const inputResult$1 = await updateDef.input["~standard"].validate(input$1);
-				if (inputResult$1.issues) throw new require_errors.UpdateInputValidationError(updateName, inputResult$1.issues);
-				const result$1 = await handler(inputResult$1.value);
-				const outputResult$1 = await updateDef.output["~standard"].validate(result$1);
-				if (outputResult$1.issues) throw new require_errors.UpdateOutputValidationError(updateName, outputResult$1.issues);
-				return outputResult$1.value;
+			(0, _temporalio_workflow.setHandler)((0, _temporalio_workflow.defineUpdate)(updateName), async (...args) => {
+				const input = args.length === 1 ? args[0] : args;
+				const inputResult = await updateDef.input["~standard"].validate(input);
+				if (inputResult.issues) throw new require_errors.UpdateInputValidationError(updateName, inputResult.issues);
+				const result = await handler(inputResult.value);
+				const outputResult = await updateDef.output["~standard"].validate(result);
+				if (outputResult.issues) throw new require_errors.UpdateOutputValidationError(updateName, outputResult.issues);
+				return outputResult.value;
 			});
 		}
 		const result = await implementation({

package/dist/workflow.d.cts

@@ -1,4 +1,4 @@
-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-CXpHOFmk.cjs";
+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-4jH78z8m.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";
@@ -18,53 +18,53 @@ import { ActivityOptions, ChildWorkflowOptions, WorkflowInfo } from "@temporalio
  * @example
  * ```ts
  * // workflows/processOrder.ts
- * import { declareWorkflow } from '@temporal-contract/worker';
+ * import { declareWorkflow } from '@temporal-contract/worker/workflow';
  * import myContract from '../contract';
  *
  * export const processOrder = declareWorkflow({
  *   workflowName: 'processOrder',
  *   contract: myContract,
- *   implementation: async (context, orderId, customerId) => {
+ *   activityOptions: {
+ *     startToCloseTimeout: '1 minute',
+ *   },
+ *   implementation: async (context, args) => {
  *     // context.activities: typed activities (workflow + global)
  *     // context.info: WorkflowInfo
  *
- *     const inventory = await context.activities.validateInventory(orderId);
+ *     const inventory = await context.activities.validateInventory({
+ *       orderId: args.orderId,
+ *     });
  *
  *     if (!inventory.available) {
- *       throw new Error('Out of stock');
+ *       return { orderId: args.orderId, status: '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'
- *     );
+ *     const payment = await context.activities.chargePayment({
+ *       customerId: args.customerId,
+ *       amount: 100,
+ *     });
  *
  *     return {
- *       orderId,
+ *       orderId: args.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';
+ * import { createWorker } from '@temporal-contract/worker/worker';
+ * import { activities } from './activities';
+ * import myContract from './contract';
  *
- * const worker = await Worker.create({
- *   workflowsPath: require.resolve('./workflows'), // Imports processOrder
- *   activities: activitiesHandler.activities,
- *   taskQueue: activitiesHandler.contract.taskQueue,
+ * const worker = await createWorker({
+ *   contract: myContract,
+ *   connection,
+ *   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows.js'),
+ *   activities,
  * });
  * ```
  */
@@ -98,7 +98,7 @@ type UpdateHandlerImplementation<TUpdate extends UpdateDefinition> = (args: Work
 /**
  * Options for declaring a workflow implementation
  */
-interface DeclareWorkflowOptions<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> {
+type DeclareWorkflowOptions<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = {
   workflowName: TWorkflowName;
   contract: TContract;
   implementation: WorkflowImplementation<TContract, TWorkflowName>;
@@ -120,7 +120,7 @@ interface DeclareWorkflowOptions<TContract extends ContractDefinition, TWorkflow
    * ```
    */
   activityOptions: ActivityOptions;
-}
+};
 /**
  * Workflow implementation function
  *
@@ -137,7 +137,7 @@ type WorkflowImplementation<TContract extends ContractDefinition, TWorkflowName
  * - Signal, query, and update handler registration
  * - Child workflow execution capabilities
  */
-interface WorkflowContext<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> {
+type WorkflowContext<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = {
   activities: WorkflowInferWorkflowContextActivities<TContract, TWorkflowName>;
   info: WorkflowInfo;
   /**
@@ -254,7 +254,7 @@ interface WorkflowContext<TContract extends ContractDefinition, TWorkflowName ex
    * ```
    */
   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
  */
@@ -264,7 +264,7 @@ type TypedChildWorkflowOptions<TChildContract extends ContractDefinition, TChild
 /**
  * Typed handle for a child workflow with Future/Result pattern
  */
-interface TypedChildWorkflowHandle<TWorkflow extends WorkflowDefinition> {
+type TypedChildWorkflowHandle<TWorkflow extends WorkflowDefinition> = {
   /**
    * Get child workflow result with Result pattern
    */
@@ -273,7 +273,7 @@ interface TypedChildWorkflowHandle<TWorkflow extends WorkflowDefinition> {
    * Child workflow ID
    */
   workflowId: string;
-}
+};
 /**
  * Activity function signature from workflow execution perspective
  *
@@ -293,6 +293,7 @@ type WorkflowInferWorkflowActivities<T extends WorkflowDefinition> = T["activiti
  *
  * Combines workflow-specific activities with global contract activities
  */
-type WorkflowInferWorkflowContextActivities<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = WorkflowInferWorkflowActivities<TContract["workflows"][TWorkflowName]> & WorkflowInferActivities<TContract>;
+type WorkflowInferWorkflowContextActivities<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = WorkflowInferWorkflowActivities<TContract["workflows"][TWorkflowName]> & WorkflowInferActivities<TContract>; //# sourceMappingURL=workflow.d.ts.map
 //#endregion
-export { ActivityInputValidationError, ActivityOutputValidationError, ChildWorkflowError, ChildWorkflowNotFoundError, QueryInputValidationError, QueryOutputValidationError, SignalInputValidationError, UpdateInputValidationError, UpdateOutputValidationError, WorkflowInputValidationError, WorkflowOutputValidationError, declareWorkflow };
+export { ActivityInputValidationError, ActivityOutputValidationError, ChildWorkflowError, ChildWorkflowNotFoundError, QueryInputValidationError, QueryOutputValidationError, SignalInputValidationError, UpdateInputValidationError, UpdateOutputValidationError, WorkflowInputValidationError, WorkflowOutputValidationError, declareWorkflow };
+//# sourceMappingURL=workflow.d.cts.map

package/dist/workflow.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.cts","names":[],"sources":["../src/workflow.ts"],"mappings":"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"}