@temporal-contract/worker 0.2.0 → 1.0.0

package/dist/workflow.cjs

@@ -1,8 +1,148 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_errors = require('./errors-DjSZg-93.cjs');
-let _temporal_contract_boxed = require("@temporal-contract/boxed");
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_internal = require("./internal-Tj4m4f_K.cjs");
 let _temporalio_workflow = require("@temporalio/workflow");
-
+let _temporal_contract_boxed = require("@temporal-contract/boxed");
+//#region src/cancellation.ts
+/**
+* Typed wrappers around Temporal's `CancellationScope` so workflows can
+* opt into cancellation control without reaching for
+* `@temporalio/workflow` directly. The wrappers fold cancellation into
+* the same `Future<Result<...>>` shape used elsewhere in the worker
+* context — callers branch on `Result.Error(WorkflowCancelledError)`
+* instead of catching `CancelledFailure`.
+*
+* Non-cancellation errors thrown inside the scope are *not* swallowed:
+* the Future rejects with the original error so user-domain failures
+* keep their identity.
+*/
+/**
+* Run `fn` inside a cancellable Temporal scope. If the workflow (or an
+* ancestor scope) is cancelled while the function is in flight, the
+* resulting Future resolves to `Result.Error(WorkflowCancelledError)`,
+* letting callers handle cancellation explicitly — typically to perform
+* a graceful exit from the current step.
+*
+* @example
+* ```ts
+* const result = await context.cancellableScope(async () => {
+*   return await context.activities.processStep(...);
+* });
+*
+* result.match({
+*   Ok: (output) => { ... },
+*   Error: (err) => {
+*     // err instanceof WorkflowCancelledError — graceful exit
+*   },
+* });
+* ```
+*/
+function cancellableScope(fn) {
+	return _temporal_contract_boxed.Future.fromAsync(async () => {
+		try {
+			const value = await _temporalio_workflow.CancellationScope.cancellable(async () => fn());
+			return _temporal_contract_boxed.Result.Ok(value);
+		} catch (error) {
+			if ((0, _temporalio_workflow.isCancellation)(error)) return _temporal_contract_boxed.Result.Error(new require_internal.WorkflowCancelledError(error));
+			throw error;
+		}
+	});
+}
+/**
+* Run `fn` inside a non-cancellable Temporal scope. Cancellation requests
+* from outside the scope are ignored for its duration — the idiomatic way
+* to perform cleanup that must not be interrupted (e.g. releasing a
+* resource after a graceful shutdown).
+*
+* Mirrors `cancellableScope`'s `Future<Result<...>>` shape for symmetry;
+* the `Result.Error` branch only triggers when cancellation is raised
+* from inside the scope (rare).
+*
+* @example
+* ```ts
+* await context.nonCancellableScope(async () => {
+*   await context.activities.releaseResources(...);
+* });
+* ```
+*/
+function nonCancellableScope(fn) {
+	return _temporal_contract_boxed.Future.fromAsync(async () => {
+		try {
+			const value = await _temporalio_workflow.CancellationScope.nonCancellable(async () => fn());
+			return _temporal_contract_boxed.Result.Ok(value);
+		} catch (error) {
+			if ((0, _temporalio_workflow.isCancellation)(error)) return _temporal_contract_boxed.Result.Error(new require_internal.WorkflowCancelledError(error));
+			throw error;
+		}
+	});
+}
+//#endregion
+//#region src/handlers.ts
+/**
+* Bind a typed signal handler to the running workflow. Validates the
+* signal payload against the contract's input schema before invoking the
+* user-supplied handler.
+*
+* The runtime guard against a missing `signals` block — and an unknown
+* signal name within it — covers the union-typed-`workflowName` case
+* where the type system's keyset constraint collapses; without the
+* check, a caller would see `Cannot read properties of undefined`
+* instead of a controlled error.
+*/
+function bindSignalHandler(workflowDefinition, workflowName, signalName, handler) {
+	if (!workflowDefinition.signals) throw new Error(`Signal "${signalName}" cannot be defined: workflow "${workflowName}" has no signals in its contract`);
+	const signalDef = workflowDefinition.signals[signalName];
+	if (!signalDef) throw new Error(`Signal "${signalName}" not found in workflow "${workflowName}" contract`);
+	(0, _temporalio_workflow.setHandler)((0, _temporalio_workflow.defineSignal)(signalName), async (...args) => {
+		const input = require_internal.extractHandlerInput(args);
+		const inputResult = await signalDef.input["~standard"].validate(input);
+		if (inputResult.issues) throw new require_internal.SignalInputValidationError(signalName, inputResult.issues);
+		await handler(inputResult.value);
+	});
+}
+/**
+* Bind a typed query handler to the running workflow. Validates input
+* and output against the contract synchronously.
+*
+* Temporal's query API requires a synchronous handler — async
+* validation breaks replay determinism. The handler trips a clear error
+* if the schema library returns a Promise from `validate(...)`, instead
+* of letting the async path silently corrupt query semantics.
+*/
+function bindQueryHandler(workflowDefinition, workflowName, queryName, handler) {
+	if (!workflowDefinition.queries) throw new Error(`Query "${queryName}" cannot be defined: workflow "${workflowName}" has no queries in its contract`);
+	const queryDef = workflowDefinition.queries[queryName];
+	if (!queryDef) throw new Error(`Query "${queryName}" not found in workflow "${workflowName}" contract`);
+	(0, _temporalio_workflow.setHandler)((0, _temporalio_workflow.defineQuery)(queryName), (...args) => {
+		const input = require_internal.extractHandlerInput(args);
+		const inputResult = queryDef.input["~standard"].validate(input);
+		if (inputResult instanceof Promise) throw new Error(`Query "${queryName}" validation must be synchronous. Use a schema library that supports synchronous validation for queries.`);
+		if (inputResult.issues) throw new require_internal.QueryInputValidationError(queryName, inputResult.issues);
+		const result = handler(inputResult.value);
+		const outputResult = queryDef.output["~standard"].validate(result);
+		if (outputResult instanceof Promise) throw new Error(`Query "${queryName}" output validation must be synchronous. Use a schema library that supports synchronous validation for queries.`);
+		if (outputResult.issues) throw new require_internal.QueryOutputValidationError(queryName, outputResult.issues);
+		return outputResult.value;
+	});
+}
+/**
+* Bind a typed update handler to the running workflow. Validates both
+* input and output (asynchronously, like signals).
+*/
+function bindUpdateHandler(workflowDefinition, workflowName, updateName, handler) {
+	if (!workflowDefinition.updates) throw new Error(`Update "${updateName}" cannot be defined: workflow "${workflowName}" has no updates in its contract`);
+	const updateDef = workflowDefinition.updates[updateName];
+	if (!updateDef) throw new Error(`Update "${updateName}" not found in workflow "${workflowName}" contract`);
+	(0, _temporalio_workflow.setHandler)((0, _temporalio_workflow.defineUpdate)(updateName), async (...args) => {
+		const input = require_internal.extractHandlerInput(args);
+		const inputResult = await updateDef.input["~standard"].validate(input);
+		if (inputResult.issues) throw new require_internal.UpdateInputValidationError(updateName, inputResult.issues);
+		const result = await handler(inputResult.value);
+		const outputResult = await updateDef.output["~standard"].validate(result);
+		if (outputResult.issues) throw new require_internal.UpdateOutputValidationError(updateName, outputResult.issues);
+		return outputResult.value;
+	});
+}
+//#endregion
 //#region src/workflow.ts
 /**
 * Create a typed workflow implementation with automatic validation
@@ -27,6 +167,15 @@ let _temporalio_workflow = require("@temporalio/workflow");
 *   activityOptions: {
 *     startToCloseTimeout: '1 minute',
 *   },
+*   // Optional: override `activityOptions` for specific activities. Each
+*   // entry shallow-merges over the workflow default — the override wins on
+*   // every property it specifies, including the whole `retry` block.
+*   activityOptionsByName: {
+*     chargePayment: {
+*       startToCloseTimeout: '5 minutes',
+*       retry: { maximumAttempts: 5 },
+*     },
+*   },
 *   implementation: async (context, args) => {
 *     // context.activities: typed activities (workflow + global)
 *     // context.info: WorkflowInfo
@@ -68,135 +217,29 @@ let _temporalio_workflow = require("@temporalio/workflow");
 * });
 * ```
 */
-function declareWorkflow({ workflowName, contract, implementation, activityOptions }) {
+function declareWorkflow({ workflowName, contract, implementation, activityOptions, activityOptionsByName }) {
 	const definition = contract.workflows[workflowName];
 	return async (...args) => {
-		const input = args.length === 1 ? args[0] : args;
+		const input = require_internal.extractHandlerInput(args);
 		const inputResult = await definition.input["~standard"].validate(input);
-		if (inputResult.issues) throw new require_errors.WorkflowInputValidationError(String(workflowName), inputResult.issues);
+		if (inputResult.issues) throw new require_internal.WorkflowInputValidationError(String(workflowName), inputResult.issues);
 		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, 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) {
-			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 = 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,
-				taskQueue: childContract.taskQueue
-			});
-		}
-		function createTypedChildHandle(handle, childDefinition, childWorkflowName) {
-			return {
-				workflowId: handle.workflowId,
-				result: () => {
-					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.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.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) => {
-				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) => {
-				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) => {
-				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;
-			});
-		}
+		if (definition.activities || contract.activities) contextActivities = createValidatedActivities(require_internal.buildRawActivitiesProxy(definition.activities, contract.activities, activityOptions, activityOptionsByName), definition.activities, contract.activities);
 		const result = await implementation({
 			activities: contextActivities,
 			info: (0, _temporalio_workflow.workflowInfo)(),
 			startChildWorkflow: createStartChildWorkflow,
 			executeChildWorkflow: createExecuteChildWorkflow,
-			defineSignal: createDefineSignal,
-			defineQuery: createDefineQuery,
-			defineUpdate: createDefineUpdate
+			cancellableScope,
+			nonCancellableScope,
+			defineSignal: ((signalName, handler) => bindSignalHandler(definition, String(workflowName), signalName, handler)),
+			defineQuery: ((queryName, handler) => bindQueryHandler(definition, String(workflowName), queryName, handler)),
+			defineUpdate: ((updateName, handler) => bindUpdateHandler(definition, String(workflowName), updateName, handler)),
+			continueAsNew: require_internal.createContinueAsNew(contract, workflowName)
 		}, validatedInput);
 		const outputResult = await definition.output["~standard"].validate(result);
-		if (outputResult.issues) throw new require_errors.WorkflowOutputValidationError(String(workflowName), outputResult.issues);
+		if (outputResult.issues) throw new require_internal.WorkflowOutputValidationError(String(workflowName), outputResult.issues);
 		return outputResult.value;
 	};
 }
@@ -217,26 +260,94 @@ function createValidatedActivities(rawActivities, workflowActivitiesDefinition,
 		if (!rawActivity) throw new Error(`Activity implementation not found for: "${activityName}". Available activities: ${Object.keys(rawActivities).length > 0 ? Object.keys(rawActivities).join(", ") : "none"}`);
 		validatedActivities[activityName] = async (input) => {
 			const inputResult = await activityDef.input["~standard"].validate(input);
-			if (inputResult.issues) throw new require_errors.ActivityInputValidationError(activityName, inputResult.issues);
+			if (inputResult.issues) throw new require_internal.ActivityInputValidationError(activityName, inputResult.issues);
 			const result = await rawActivity(inputResult.value);
 			const outputResult = await activityDef.output["~standard"].validate(result);
-			if (outputResult.issues) throw new require_errors.ActivityOutputValidationError(activityName, outputResult.issues);
+			if (outputResult.issues) throw new require_internal.ActivityOutputValidationError(activityName, outputResult.issues);
 			return outputResult.value;
 		};
 	}
 	return validatedActivities;
 }
-
+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_internal.ChildWorkflowError(require_internal.formatChildWorkflowValidationMessage(childWorkflowName, "output", outputResult.issues)));
+	return _temporal_contract_boxed.Result.Ok(outputResult.value);
+}
+async function getAndValidateChildWorkflow(childContract, childWorkflowName, args) {
+	const childDefinition = childContract.workflows[childWorkflowName];
+	if (!childDefinition) return _temporal_contract_boxed.Result.Error(new require_internal.ChildWorkflowNotFoundError(String(childWorkflowName), Object.keys(childContract.workflows)));
+	const inputResult = await childDefinition.input["~standard"].validate(args);
+	if (inputResult.issues) return _temporal_contract_boxed.Result.Error(new require_internal.ChildWorkflowError(require_internal.formatChildWorkflowValidationMessage(String(childWorkflowName), "input", inputResult.issues)));
+	const validatedInput = inputResult.value;
+	return _temporal_contract_boxed.Result.Ok({
+		definition: childDefinition,
+		validatedInput,
+		taskQueue: childContract.taskQueue
+	});
+}
+function createTypedChildHandle(handle, childDefinition, childWorkflowName) {
+	return {
+		workflowId: handle.workflowId,
+		result: () => {
+			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_internal.ChildWorkflowError(`Child workflow execution failed: ${error instanceof Error ? error.message : String(error)}`, error));
+				}
+			});
+		}
+	};
+}
+function createStartChildWorkflow(childContract, childWorkflowName, options) {
+	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_internal.ChildWorkflowError(`Failed to start child workflow: ${error instanceof Error ? error.message : String(error)}`, error));
+		}
+	});
+}
+function createExecuteChildWorkflow(childContract, childWorkflowName, options) {
+	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_internal.ChildWorkflowError(`Failed to execute child workflow: ${error instanceof Error ? error.message : String(error)}`, error));
+		}
+	});
+}
 //#endregion
-exports.ActivityInputValidationError = require_errors.ActivityInputValidationError;
-exports.ActivityOutputValidationError = require_errors.ActivityOutputValidationError;
-exports.ChildWorkflowError = require_errors.ChildWorkflowError;
-exports.ChildWorkflowNotFoundError = require_errors.ChildWorkflowNotFoundError;
-exports.QueryInputValidationError = require_errors.QueryInputValidationError;
-exports.QueryOutputValidationError = require_errors.QueryOutputValidationError;
-exports.SignalInputValidationError = require_errors.SignalInputValidationError;
-exports.UpdateInputValidationError = require_errors.UpdateInputValidationError;
-exports.UpdateOutputValidationError = require_errors.UpdateOutputValidationError;
-exports.WorkflowInputValidationError = require_errors.WorkflowInputValidationError;
-exports.WorkflowOutputValidationError = require_errors.WorkflowOutputValidationError;
-exports.declareWorkflow = declareWorkflow;
+exports.ActivityInputValidationError = require_internal.ActivityInputValidationError;
+exports.ActivityOutputValidationError = require_internal.ActivityOutputValidationError;
+exports.ChildWorkflowError = require_internal.ChildWorkflowError;
+exports.ChildWorkflowNotFoundError = require_internal.ChildWorkflowNotFoundError;
+exports.QueryInputValidationError = require_internal.QueryInputValidationError;
+exports.QueryOutputValidationError = require_internal.QueryOutputValidationError;
+exports.SignalInputValidationError = require_internal.SignalInputValidationError;
+exports.UpdateInputValidationError = require_internal.UpdateInputValidationError;
+exports.UpdateOutputValidationError = require_internal.UpdateOutputValidationError;
+exports.WorkflowCancelledError = require_internal.WorkflowCancelledError;
+exports.WorkflowInputValidationError = require_internal.WorkflowInputValidationError;
+exports.WorkflowOutputValidationError = require_internal.WorkflowOutputValidationError;
+exports.declareWorkflow = declareWorkflow;