@temporal-contract/worker 0.1.0 → 1.0.0

package/dist/activity.mjs

@@ -1,102 +1,12 @@
-import { n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-BqVTpfcf.mjs";
-
-//#region src/activity-utils.ts
-/**
-* Extract activity definitions for a specific workflow from a contract
-*
-* This includes both:
-* - Workflow-specific activities defined under workflow.activities
-* - Global activities defined under contract.activities
-*
-* @param contract - The contract definition
-* @param workflowName - The name of the workflow
-* @returns Activity definitions for the workflow (workflow-specific + global activities merged)
-*
-* @example
-* ```ts
-* const orderWorkflowActivities = getWorkflowActivities(myContract, 'processOrder');
-* // Returns: { processPayment: ActivityDef, reserveInventory: ActivityDef, sendEmail: ActivityDef }
-* // where sendEmail is a global activity
-* ```
-*/
-function getWorkflowActivities(contract, workflowName) {
-	const workflowActivities = contract.workflows[workflowName]?.activities || {};
-	return {
-		...contract.activities || {},
-		...workflowActivities
-	};
-}
-/**
-* Extract all activity names for a specific workflow from a contract
-*
-* @param contract - The contract definition
-* @param workflowName - The name of the workflow
-* @returns Array of activity names (strings) available for the workflow
-*
-* @example
-* ```ts
-* const activityNames = getWorkflowActivityNames(myContract, 'processOrder');
-* // Returns: ['processPayment', 'reserveInventory', 'sendEmail']
-* ```
-*/
-function getWorkflowActivityNames(contract, workflowName) {
-	const activities = getWorkflowActivities(contract, workflowName);
-	return Object.keys(activities);
-}
-/**
-* Check if an activity belongs to a specific workflow
-*
-* @param contract - The contract definition
-* @param workflowName - The name of the workflow
-* @param activityName - The name of the activity to check
-* @returns True if the activity is available for the workflow, false otherwise
-*
-* @example
-* ```ts
-* if (isWorkflowActivity(myContract, 'processOrder', 'processPayment')) {
-*   // Activity is available for this workflow
-* }
-* ```
-*/
-function isWorkflowActivity(contract, workflowName, activityName) {
-	return activityName in getWorkflowActivities(contract, workflowName);
-}
-/**
-* Get all workflow names from a contract
-*
-* @param contract - The contract definition
-* @returns Array of workflow names defined in the contract
-*
-* @example
-* ```ts
-* const workflows = getWorkflowNames(myContract);
-* // Returns: ['processOrder', 'processRefund']
-* ```
-*/
-function getWorkflowNames(contract) {
-	return Object.keys(contract.workflows);
-}
-
-//#endregion
+import { a as ActivityInputValidationError, i as ActivityDefinitionNotFoundError, o as ActivityOutputValidationError, r as extractHandlerInput } from "./internal-BoNcEtYh.mjs";
+import { ApplicationFailure } from "@temporalio/common";
 //#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
+* 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
+* - `Result<T, ApplicationFailure>` pattern for explicit error handling
 * - Automatic conversion from Result to Promise (throwing on Error)
 *
 * TypeScript ensures ALL activities (global + workflow-specific) are implemented.
@@ -105,28 +15,30 @@ var ActivityError = class ActivityError extends Error {
 *
 * @example
 * ```ts
-* import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
+* import { declareActivitiesHandler, ApplicationFailure } from '@temporal-contract/worker/activity';
 * import { Result, Future } from '@swan-io/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
+*     // Activity returns Result instead of throwing.
 *     sendEmail: (args) => {
-*       return Future.make(async resolve => {
+*       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
+*           // Wrap technical errors in ApplicationFailure. `nonRetryable`
+*           // is per-instance: set it to true on permanent failures so
+*           // Temporal stops retrying immediately.
 *           resolve(Result.Error(
-*             new ActivityError(
-*               'EMAIL_SEND_FAILED',
-*               'Failed to send email',
-*               error // Original error as cause for debugging
-*             )
+*             ApplicationFailure.create({
+*               type: 'EMAIL_SEND_FAILED',
+*               message: 'Failed to send email',
+*               nonRetryable: false,
+*               cause: error instanceof Error ? error : undefined,
+*             }),
 *           ));
 *         }
 *       });
@@ -143,13 +55,26 @@ var ActivityError = class ActivityError extends Error {
 *   taskQueue: contract.taskQueue,
 * });
 * ```
+*
+* @remarks
+* The wrapper accepts implementations in the
+* `Future<Result<T, ApplicationFailure>>` shape and produces ordinary
+* Promise-returning Temporal handlers (Result.Error → thrown
+* `ApplicationFailure`; Result.Ok → output validated against the
+* contract and resolved). It does **not** hide Temporal's
+* `@temporalio/activity` runtime: inside the body you can still call
+* `Context.current()` from `@temporalio/activity` to access heartbeats
+* (`heartbeat(details)`, `heartbeatDetails`), activity info (attempt
+* number, workflow IDs), and the async-completion task token. See the
+* "Working with the Activity Context" section of the worker
+* implementation guide for end-to-end examples.
 */
 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 input = extractHandlerInput(args);
 			const inputResult = await activityDef.input["~standard"].validate(input);
 			if (inputResult.issues) throw new ActivityInputValidationError(activityName, inputResult.issues);
 			const result = await activityImpl(inputResult.value);
@@ -178,6 +103,7 @@ function declareActivitiesHandler(options) {
 	}
 	return wrappedActivities;
 }
-
 //#endregion
-export { ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler, getWorkflowActivities, getWorkflowActivityNames, getWorkflowNames, isWorkflowActivity };
+export { ActivityDefinitionNotFoundError, ActivityInputValidationError, ActivityOutputValidationError, ApplicationFailure, declareActivitiesHandler };
+
+//# sourceMappingURL=activity.mjs.map

package/dist/activity.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.mjs","names":[],"sources":["../src/activity.ts"],"sourcesContent":["// Entry point for activity implementations.\n//\n// Activities run *outside* the workflow sandbox, so they can use any\n// implementation of the Result/Future pattern — we standardize on\n// `@swan-io/boxed` here for its richer API. Workflow code (see workflow.ts)\n// must use `@temporal-contract/boxed` instead, since it's compatible with\n// Temporal's deterministic replay machinery.\n//\n// Errors flow through Temporal's `ApplicationFailure` (re-exported from\n// `@temporalio/common`) — it's the SDK's first-class failure shape, so we\n// don't wrap it in a custom class. `ApplicationFailure` exposes\n// `nonRetryable`, `type`, `details`, and `category` natively, and survives\n// the activity → workflow serialization boundary unchanged.\nimport { ActivityDefinition, ContractDefinition } from \"@temporal-contract/contract\";\nimport { Future, Result } from \"@swan-io/boxed\";\nimport { ApplicationFailure } from \"@temporalio/common\";\nimport { WorkerInferInput, WorkerInferOutput } from \"./types.js\";\nimport {\n  ActivityDefinitionNotFoundError,\n  ActivityInputValidationError,\n  ActivityOutputValidationError,\n} from \"./errors.js\";\nimport { extractHandlerInput } from \"./internal.js\";\n\nexport {\n  ActivityDefinitionNotFoundError,\n  ActivityInputValidationError,\n  ActivityOutputValidationError,\n} from \"./errors.js\";\n\n// Re-export the canonical activity-failure class so consumers don't need\n// a separate `@temporalio/common` import to construct one.\nexport { ApplicationFailure } from \"@temporalio/common\";\n\n/**\n * Activity implementation using Future/Result pattern.\n *\n * Returns `Future<Result<Output, ApplicationFailure>>` for explicit error\n * handling instead of throwing. The wrapper rethrows `Result.Error`\n * payloads at the activity boundary; Temporal recognizes\n * `ApplicationFailure` natively and applies the configured retry policy\n * (with `nonRetryable: true` opting an instance out per-call).\n */\ntype BoxedActivityImplementation<TActivity extends ActivityDefinition> = (\n  args: WorkerInferInput<TActivity>,\n) => Future<Result<WorkerInferOutput<TActivity>, ApplicationFailure>>;\n\n/**\n * Map of all activity implementations for a contract (global + all workflow-specific)\n */\ntype ContractBoxedActivitiesImplementations<TContract extends ContractDefinition> =\n  // Global activities\n  (TContract[\"activities\"] extends Record<string, ActivityDefinition>\n    ? BoxedActivitiesImplementations<TContract[\"activities\"]>\n    : {}) &\n    // All workflow-specific activities merged\n    {\n      [TWorkflow in keyof TContract[\"workflows\"]]: TContract[\"workflows\"][TWorkflow][\"activities\"] extends Record<\n        string,\n        ActivityDefinition\n      >\n        ? BoxedActivitiesImplementations<TContract[\"workflows\"][TWorkflow][\"activities\"]>\n        : {};\n    };\n\ntype BoxedActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = {\n  [K in keyof TActivities]: BoxedActivityImplementation<TActivities[K]>;\n};\n\n/**\n * Options for creating activities handler\n */\ntype DeclareActivitiesHandlerOptions<TContract extends ContractDefinition> = {\n  contract: TContract;\n  activities: ContractBoxedActivitiesImplementations<TContract>;\n};\n\ntype ActivityImplementation<TActivity extends ActivityDefinition> = (\n  args: WorkerInferInput<TActivity>,\n) => Promise<WorkerInferOutput<TActivity>>;\n\ntype ActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = {\n  [K in keyof TActivities]: ActivityImplementation<TActivities[K]>;\n};\n\ntype UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (\n  k: infer I,\n) => void\n  ? I\n  : never;\n\n/**\n * Activities handler ready for Temporal Worker\n *\n * Flat structure: all activities (global + all workflow-specific) are at the root level\n */\nexport type ActivitiesHandler<TContract extends ContractDefinition> =\n  // Global activities\n  (TContract[\"activities\"] extends Record<string, ActivityDefinition>\n    ? ActivitiesImplementations<TContract[\"activities\"]>\n    : {}) &\n    // All workflow-specific activities merged at root level (flat)\n    UnionToIntersection<\n      {\n        [TWorkflow in keyof TContract[\"workflows\"]]: TContract[\"workflows\"][TWorkflow][\"activities\"] extends Record<\n          string,\n          ActivityDefinition\n        >\n          ? ActivitiesImplementations<TContract[\"workflows\"][TWorkflow][\"activities\"]>\n          : {};\n      }[keyof TContract[\"workflows\"]]\n    >;\n\n/**\n * Create a typed activities handler with automatic validation and Result pattern.\n *\n * This wraps all activity implementations with:\n * - Validation at network boundaries\n * - `Result<T, ApplicationFailure>` pattern for explicit error handling\n * - Automatic conversion from Result to Promise (throwing on Error)\n *\n * TypeScript ensures ALL activities (global + workflow-specific) are implemented.\n *\n * Use this to create the activities object for the Temporal Worker.\n *\n * @example\n * ```ts\n * import { declareActivitiesHandler, ApplicationFailure } from '@temporal-contract/worker/activity';\n * import { Result, Future } from '@swan-io/boxed';\n * import myContract from './contract';\n *\n * export const activities = declareActivitiesHandler({\n *   contract: myContract,\n *   activities: {\n *     // Activity returns Result instead of throwing.\n *     sendEmail: (args) => {\n *       return Future.make(async (resolve) => {\n *         try {\n *           await emailService.send(args);\n *           resolve(Result.Ok({ sent: true }));\n *         } catch (error) {\n *           // Wrap technical errors in ApplicationFailure. `nonRetryable`\n *           // is per-instance: set it to true on permanent failures so\n *           // Temporal stops retrying immediately.\n *           resolve(Result.Error(\n *             ApplicationFailure.create({\n *               type: 'EMAIL_SEND_FAILED',\n *               message: 'Failed to send email',\n *               nonRetryable: false,\n *               cause: error instanceof Error ? error : undefined,\n *             }),\n *           ));\n *         }\n *       });\n *     },\n *   },\n * });\n *\n * // Use with Temporal Worker\n * import { Worker } from '@temporalio/worker';\n *\n * const worker = await Worker.create({\n *   workflowsPath: require.resolve('./workflows'),\n *   activities: activities,\n *   taskQueue: contract.taskQueue,\n * });\n * ```\n *\n * @remarks\n * The wrapper accepts implementations in the\n * `Future<Result<T, ApplicationFailure>>` shape and produces ordinary\n * Promise-returning Temporal handlers (Result.Error → thrown\n * `ApplicationFailure`; Result.Ok → output validated against the\n * contract and resolved). It does **not** hide Temporal's\n * `@temporalio/activity` runtime: inside the body you can still call\n * `Context.current()` from `@temporalio/activity` to access heartbeats\n * (`heartbeat(details)`, `heartbeatDetails`), activity info (attempt\n * number, workflow IDs), and the async-completion task token. See the\n * \"Working with the Activity Context\" section of the worker\n * implementation guide for end-to-end examples.\n */\nexport function declareActivitiesHandler<TContract extends ContractDefinition>(\n  options: DeclareActivitiesHandlerOptions<TContract>,\n): ActivitiesHandler<TContract> {\n  const { contract, activities } = options;\n\n  // Prepare Temporal-compatible activities with validation and Result unwrapping\n  const wrappedActivities = {} as ActivitiesHandler<TContract>;\n\n  // Helper to create a wrapped implementation from a definition and impl\n  function makeWrapped(\n    activityName: string,\n    activityDef: ActivityDefinition,\n    activityImpl: (args: unknown) => Future<Result<unknown, ApplicationFailure>>,\n  ) {\n    return async (...args: unknown[]) => {\n      const input = extractHandlerInput(args);\n\n      // Validate input\n      const inputResult = await activityDef.input[\"~standard\"].validate(input);\n      if (inputResult.issues) {\n        throw new ActivityInputValidationError(activityName, inputResult.issues);\n      }\n\n      // Execute boxed activity (returns Future<Result<T, ApplicationFailure>>)\n      const futureResult = activityImpl(inputResult.value);\n\n      // Await Future and unwrap Result\n      const result = await futureResult;\n\n      // Process result: validate output or throw error\n      if (result.isOk()) {\n        // Validate output on success\n        const outputResult = await activityDef.output[\"~standard\"].validate(result.value);\n        if (outputResult.issues) {\n          throw new ActivityOutputValidationError(activityName, outputResult.issues);\n        }\n        return outputResult.value;\n      } else {\n        // Convert Result.Error to thrown ApplicationFailure for Temporal.\n        // Temporal recognizes this class natively and applies the\n        // configured retry policy (honoring `nonRetryable: true`).\n        throw result.error;\n      }\n    };\n  }\n\n  // 1) Wrap global activities defined directly under contract.activities\n  if (contract.activities) {\n    for (const [activityName, impl] of Object.entries(activities)) {\n      // Skip workflow namespaces if present at root\n      if (contract.workflows && activityName in contract.workflows) {\n        continue;\n      }\n\n      const activityDef = contract.activities[activityName];\n      if (!activityDef) {\n        throw new ActivityDefinitionNotFoundError(activityName, Object.keys(contract.activities));\n      }\n\n      // Assign wrapped global activity\n      (wrappedActivities as Record<string, unknown>)[activityName] = makeWrapped(\n        activityName,\n        activityDef,\n        impl as (args: unknown) => Future<Result<unknown, ApplicationFailure>>,\n      );\n    }\n  }\n\n  // 2) Wrap workflow-scoped activities at root level (flat)\n  if (contract.workflows) {\n    for (const [workflowName, workflowDef] of Object.entries(contract.workflows)) {\n      const wfActivitiesImpl = (activities as Record<string, unknown>)[workflowName] as\n        | Record<string, unknown>\n        | undefined;\n      if (!wfActivitiesImpl) {\n        // If no implementations provided for this workflow, skip (TypeScript typing should enforce completeness for declared ones)\n        continue;\n      }\n\n      const wfDefs = workflowDef.activities ?? {};\n\n      for (const [activityName, impl] of Object.entries(wfActivitiesImpl)) {\n        const activityDef = wfDefs[activityName];\n        if (!activityDef) {\n          throw new ActivityDefinitionNotFoundError(\n            `${workflowName}.${activityName}`,\n            Object.keys(wfDefs),\n          );\n        }\n\n        // Assign workflow activity directly at root level (flat structure)\n        (wrappedActivities as Record<string, unknown>)[activityName] = makeWrapped(\n          `${workflowName}.${activityName}`,\n          activityDef,\n          impl as (args: unknown) => Future<Result<unknown, ApplicationFailure>>,\n        );\n      }\n    }\n  }\n\n  return wrappedActivities;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqLA,SAAgB,yBACd,SAC8B;CAC9B,MAAM,EAAE,UAAU,eAAe;CAGjC,MAAM,oBAAoB,EAAE;CAG5B,SAAS,YACP,cACA,aACA,cACA;AACA,SAAO,OAAO,GAAG,SAAoB;GACnC,MAAM,QAAQ,oBAAoB,KAAK;GAGvC,MAAM,cAAc,MAAM,YAAY,MAAM,aAAa,SAAS,MAAM;AACxE,OAAI,YAAY,OACd,OAAM,IAAI,6BAA6B,cAAc,YAAY,OAAO;GAO1E,MAAM,SAAS,MAHM,aAAa,YAAY,MAGb;AAGjC,OAAI,OAAO,MAAM,EAAE;IAEjB,MAAM,eAAe,MAAM,YAAY,OAAO,aAAa,SAAS,OAAO,MAAM;AACjF,QAAI,aAAa,OACf,OAAM,IAAI,8BAA8B,cAAc,aAAa,OAAO;AAE5E,WAAO,aAAa;SAKpB,OAAM,OAAO;;;AAMnB,KAAI,SAAS,WACX,MAAK,MAAM,CAAC,cAAc,SAAS,OAAO,QAAQ,WAAW,EAAE;AAE7D,MAAI,SAAS,aAAa,gBAAgB,SAAS,UACjD;EAGF,MAAM,cAAc,SAAS,WAAW;AACxC,MAAI,CAAC,YACH,OAAM,IAAI,gCAAgC,cAAc,OAAO,KAAK,SAAS,WAAW,CAAC;AAI1F,oBAA8C,gBAAgB,YAC7D,cACA,aACA,KACD;;AAKL,KAAI,SAAS,UACX,MAAK,MAAM,CAAC,cAAc,gBAAgB,OAAO,QAAQ,SAAS,UAAU,EAAE;EAC5E,MAAM,mBAAoB,WAAuC;AAGjE,MAAI,CAAC,iBAEH;EAGF,MAAM,SAAS,YAAY,cAAc,EAAE;AAE3C,OAAK,MAAM,CAAC,cAAc,SAAS,OAAO,QAAQ,iBAAiB,EAAE;GACnE,MAAM,cAAc,OAAO;AAC3B,OAAI,CAAC,YACH,OAAM,IAAI,gCACR,GAAG,aAAa,GAAG,gBACnB,OAAO,KAAK,OAAO,CACpB;AAIF,qBAA8C,gBAAgB,YAC7D,GAAG,aAAa,GAAG,gBACnB,aACA,KACD;;;AAKP,QAAO"}

package/dist/{errors-Vr-sKdW7.d.mts → errors-CG1y7SHO.d.cts}

@@ -132,5 +132,18 @@ declare class ChildWorkflowNotFoundError extends WorkerError {
 declare class ChildWorkflowError extends WorkerError {
   constructor(message: string, cause?: unknown);
 }
+/**
+ * Error returned in the `Result.Error` branch when a typed cancellation
+ * scope is cancelled via Temporal's cancellation propagation. Returned by
+ * both `context.cancellableScope` (when the workflow or an ancestor scope
+ * cancels) and `context.nonCancellableScope` (when cancellation is raised
+ * from inside the scope). Distinct from arbitrary thrown errors so call
+ * sites can branch on cancellation explicitly while still surfacing
+ * non-cancellation errors as Future rejections.
+ */
+declare class WorkflowCancelledError extends WorkerError {
+  constructor(cause?: unknown);
+}
 //#endregion
-export { ChildWorkflowNotFoundError as a, SignalInputValidationError as c, WorkflowInputValidationError as d, WorkflowOutputValidationError as f, WorkerInferOutput as g, WorkerInferInput as h, ChildWorkflowError as i, UpdateInputValidationError as l, ClientInferOutput as m, ActivityInputValidationError as n, QueryInputValidationError as o, ClientInferInput as p, ActivityOutputValidationError as r, QueryOutputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateOutputValidationError as u };
+export { WorkerInferOutput as _, ChildWorkflowNotFoundError as a, SignalInputValidationError as c, WorkflowCancelledError as d, WorkflowInputValidationError as f, WorkerInferInput as g, ClientInferOutput as h, ChildWorkflowError as i, UpdateInputValidationError as l, ClientInferInput as m, ActivityInputValidationError as n, QueryInputValidationError as o, WorkflowOutputValidationError as p, ActivityOutputValidationError as r, QueryOutputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateOutputValidationError as u };
+//# sourceMappingURL=errors-CG1y7SHO.d.cts.map

package/dist/errors-CG1y7SHO.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-CG1y7SHO.d.cts","names":[],"sources":["../src/types.ts","../src/errors.ts"],"mappings":";;;;;;AAOA;;KAAY,gBAAA;EAA6B,KAAA,EAAO,SAAA;AAAA,KAAe,gBAAA,CAAiB,WAAA,CAC9E,CAAA;;;;;KAOU,iBAAA;EAA8B,MAAA,EAAQ,SAAA;AAAA,KAAe,gBAAA,CAAiB,UAAA,CAChF,CAAA;;;;;KAOU,gBAAA;EAA6B,KAAA,EAAO,SAAA;AAAA,KAAe,gBAAA,CAAiB,UAAA,CAC9E,CAAA;;;;;KAOU,iBAAA;EAA8B,MAAA,EAAQ,SAAA;AAAA,KAAe,gBAAA,CAAiB,WAAA,CAChF,CAAA;;;;;;uBC1Ba,WAAA,SAAoB,KAAA;EAAA,UACxB,WAAA,CAAa,OAAA,UAAiB,KAAA;AAAA;;;;cAa5B,+BAAA,SAAwC,WAAA;EAAA,SAEjC,YAAA;EAAA,SACA,oBAAA;cADA,YAAA,UACA,oBAAA;AAAA;;;;cAaP,4BAAA,SAAqC,WAAA;EAAA,SAE9B,YAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,YAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAW9C,6BAAA,SAAsC,WAAA;EAAA,SAE/B,YAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,YAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAW9C,4BAAA,SAAqC,WAAA;EAAA,SAE9B,YAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,YAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAW9C,6BAAA,SAAsC,WAAA;EAAA,SAE/B,YAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,YAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAW9C,0BAAA,SAAmC,WAAA;EAAA,SAE5B,UAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,UAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAW9C,yBAAA,SAAkC,WAAA;EAAA,SAE3B,SAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,SAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAW9C,0BAAA,SAAmC,WAAA;EAAA,SAE5B,SAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,SAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;AA3HG;;;AAAA,cAsIjD,0BAAA,SAAmC,WAAA;EAAA,SAE5B,UAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,UAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;AArH3D;cAgIa,2BAAA,SAAoC,WAAA;EAAA,SAE7B,UAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,UAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAW9C,0BAAA,SAAmC,WAAA;EAAA,SAE5B,YAAA;EAAA,SACA,kBAAA;cADA,YAAA,UACA,kBAAA;AAAA;;;;cAWP,kBAAA,SAA2B,WAAA;cAC1B,OAAA,UAAiB,KAAA;AAAA;;;;;;;;;;cAelB,sBAAA,SAA+B,WAAA;cAC9B,KAAA;AAAA"}

package/dist/{errors-CXpHOFmk.d.cts → errors-DZhaNhwr.d.mts}

@@ -132,5 +132,18 @@ declare class ChildWorkflowNotFoundError extends WorkerError {
 declare class ChildWorkflowError extends WorkerError {
   constructor(message: string, cause?: unknown);
 }
+/**
+ * Error returned in the `Result.Error` branch when a typed cancellation
+ * scope is cancelled via Temporal's cancellation propagation. Returned by
+ * both `context.cancellableScope` (when the workflow or an ancestor scope
+ * cancels) and `context.nonCancellableScope` (when cancellation is raised
+ * from inside the scope). Distinct from arbitrary thrown errors so call
+ * sites can branch on cancellation explicitly while still surfacing
+ * non-cancellation errors as Future rejections.
+ */
+declare class WorkflowCancelledError extends WorkerError {
+  constructor(cause?: unknown);
+}
 //#endregion
-export { ChildWorkflowNotFoundError as a, SignalInputValidationError as c, WorkflowInputValidationError as d, WorkflowOutputValidationError as f, WorkerInferOutput as g, WorkerInferInput as h, ChildWorkflowError as i, UpdateInputValidationError as l, ClientInferOutput as m, ActivityInputValidationError as n, QueryInputValidationError as o, ClientInferInput as p, ActivityOutputValidationError as r, QueryOutputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateOutputValidationError as u };
+export { WorkerInferOutput as _, ChildWorkflowNotFoundError as a, SignalInputValidationError as c, WorkflowCancelledError as d, WorkflowInputValidationError as f, WorkerInferInput as g, ClientInferOutput as h, ChildWorkflowError as i, UpdateInputValidationError as l, ClientInferInput as m, ActivityInputValidationError as n, QueryInputValidationError as o, WorkflowOutputValidationError as p, ActivityOutputValidationError as r, QueryOutputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateOutputValidationError as u };
+//# sourceMappingURL=errors-DZhaNhwr.d.mts.map

package/dist/errors-DZhaNhwr.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-DZhaNhwr.d.mts","names":[],"sources":["../src/types.ts","../src/errors.ts"],"mappings":";;;;;;AAOA;;KAAY,gBAAA;EAA6B,KAAA,EAAO,SAAA;AAAA,KAAe,gBAAA,CAAiB,WAAA,CAC9E,CAAA;;;;;KAOU,iBAAA;EAA8B,MAAA,EAAQ,SAAA;AAAA,KAAe,gBAAA,CAAiB,UAAA,CAChF,CAAA;;;;;KAOU,gBAAA;EAA6B,KAAA,EAAO,SAAA;AAAA,KAAe,gBAAA,CAAiB,UAAA,CAC9E,CAAA;;;;;KAOU,iBAAA;EAA8B,MAAA,EAAQ,SAAA;AAAA,KAAe,gBAAA,CAAiB,WAAA,CAChF,CAAA;;;;;;uBC1Ba,WAAA,SAAoB,KAAA;EAAA,UACxB,WAAA,CAAa,OAAA,UAAiB,KAAA;AAAA;;;;cAa5B,+BAAA,SAAwC,WAAA;EAAA,SAEjC,YAAA;EAAA,SACA,oBAAA;cADA,YAAA,UACA,oBAAA;AAAA;;;;cAaP,4BAAA,SAAqC,WAAA;EAAA,SAE9B,YAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,YAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAW9C,6BAAA,SAAsC,WAAA;EAAA,SAE/B,YAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,YAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAW9C,4BAAA,SAAqC,WAAA;EAAA,SAE9B,YAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,YAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAW9C,6BAAA,SAAsC,WAAA;EAAA,SAE/B,YAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,YAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAW9C,0BAAA,SAAmC,WAAA;EAAA,SAE5B,UAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,UAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAW9C,yBAAA,SAAkC,WAAA;EAAA,SAE3B,SAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,SAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAW9C,0BAAA,SAAmC,WAAA;EAAA,SAE5B,SAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,SAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;AA3HG;;;AAAA,cAsIjD,0BAAA,SAAmC,WAAA;EAAA,SAE5B,UAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,UAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;AArH3D;cAgIa,2BAAA,SAAoC,WAAA;EAAA,SAE7B,UAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;cADvC,UAAA,UACA,MAAA,EAAQ,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA;;;;cAW9C,0BAAA,SAAmC,WAAA;EAAA,SAE5B,YAAA;EAAA,SACA,kBAAA;cADA,YAAA,UACA,kBAAA;AAAA;;;;cAWP,kBAAA,SAA2B,WAAA;cAC1B,OAAA,UAAiB,KAAA;AAAA;;;;;;;;;;cAelB,sBAAA,SAA+B,WAAA;cAC9B,KAAA;AAAA"}

package/dist/internal-BoNcEtYh.mjs

@@ -0,0 +1,354 @@
+import { makeContinueAsNewFunc, proxyActivities } from "@temporalio/workflow";
+//#region src/format.ts
+/**
+* Pattern for string keys safe to render with dot notation. A "safe" key is a
+* JavaScript identifier (letters/digits/underscore/$, not starting with a
+* digit). Anything else — keys containing dots, spaces, leading digits, the
+* empty string, the literal string `"0"` etc. — gets bracket-quoted so the
+* path is unambiguous. Reserved words are accepted: we are formatting a
+* diagnostic, not generating runnable code.
+*/
+const SAFE_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/**
+* Render a Standard Schema {@link StandardSchemaV1.Issue} into a human-readable
+* string that includes the failing field's path.
+*/
+function formatIssue(issue) {
+	if (issue.path === void 0 || issue.path.length === 0) return issue.message;
+	let path = "";
+	for (let i = 0; i < issue.path.length; i++) {
+		const segment = issue.path[i];
+		const key = segment !== null && typeof segment === "object" && "key" in segment ? segment.key : segment;
+		if (typeof key === "number") path += `[${key}]`;
+		else if (typeof key === "string" && SAFE_IDENTIFIER.test(key)) path += i === 0 ? key : `.${key}`;
+		else if (typeof key === "string") path += `[${JSON.stringify(key)}]`;
+		else path += `[${String(key)}]`;
+	}
+	return `at ${path}: ${issue.message}`;
+}
+/**
+* Join a list of validation issues into a single message, with each issue
+* rendered via {@link formatIssue} so field paths surface in the error text.
+*/
+function summarizeIssues(issues) {
+	return issues.map(formatIssue).join("; ");
+}
+/**
+* Build the message attached to a `ChildWorkflowError` for input/output
+* validation failures. Centralized so the worker and any future call sites
+* format identically.
+*/
+function formatChildWorkflowValidationMessage(workflowName, direction, issues) {
+	return `Child workflow "${workflowName}" ${direction} validation failed: ${summarizeIssues(issues)}`;
+}
+//#endregion
+//#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 = summarizeIssues(issues);
+		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 = summarizeIssues(issues);
+		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 = summarizeIssues(issues);
+		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 = summarizeIssues(issues);
+		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 = summarizeIssues(issues);
+		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 = summarizeIssues(issues);
+		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 = summarizeIssues(issues);
+		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 = summarizeIssues(issues);
+		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 = summarizeIssues(issues);
+		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";
+	}
+};
+/**
+* Error returned in the `Result.Error` branch when a typed cancellation
+* scope is cancelled via Temporal's cancellation propagation. Returned by
+* both `context.cancellableScope` (when the workflow or an ancestor scope
+* cancels) and `context.nonCancellableScope` (when cancellation is raised
+* from inside the scope). Distinct from arbitrary thrown errors so call
+* sites can branch on cancellation explicitly while still surfacing
+* non-cancellation errors as Future rejections.
+*/
+var WorkflowCancelledError = class extends WorkerError {
+	constructor(cause) {
+		super("Workflow cancellation scope was cancelled", cause);
+		this.name = "WorkflowCancelledError";
+	}
+};
+//#endregion
+//#region src/internal.ts
+/**
+* Internal helpers shared across the worker package's entry points.
+*
+* Not part of the public API — this module is not listed in the package's
+* `exports` map, so consumers can't import from `@temporal-contract/worker/internal`.
+* In-package tests import it directly via relative path.
+*/
+/**
+* Extract the single payload from a Temporal handler's `...args` array.
+*
+* Temporal invokes handlers with whatever was passed via `args: [...]` at the
+* call site. The typed-contract layer always sends `args: [validatedInput]`,
+* so the common case is a one-element array containing the wrapped input.
+*
+* If a non-typed-contract caller passes multiple positional arguments
+* (`args: [a, b, c]`), we surface the whole array as the input — the schema
+* will then reject it unless the contract specifically modeled a tuple.
+*/
+function extractHandlerInput(args) {
+	return args.length === 1 ? args[0] : args;
+}
+/**
+* Build the raw `Record<name, fn>` proxy of activities for a workflow,
+* applying per-activity `ActivityOptions` overrides where requested.
+*
+* **Fast path (no overrides):** a single `proxyActivities(defaultOptions)`
+* call is made and returned directly. The proxy synthesizes a function for
+* any property access by name, so downstream code that looks up
+* `proxy[activityName]` works identically to before.
+*
+* **Override path:** one extra `proxyActivities(merged)` call is made *only*
+* for each activity that has an override. Activities without an entry keep
+* using the single default proxy. The result is a `Proxy` that returns the
+* override-bound function for named keys and falls back to the default proxy
+* for everything else — so the per-execution overhead scales with the number
+* of overrides, not the number of activities.
+*
+* Per-override merge is shallow: the override's properties replace the
+* default's, including the entire nested `retry` block. This matches
+* Temporal's "one ActivityOptions per `proxyActivities` call" semantics.
+*/
+function buildRawActivitiesProxy(workflowActivities, contractActivities, defaultOptions, overrides) {
+	const defaultProxy = proxyActivities(defaultOptions);
+	const overrideEntries = overrides ? Object.entries(overrides).filter((entry) => entry[1] !== void 0) : [];
+	if (overrideEntries.length === 0) return defaultProxy;
+	const declared = new Set([...Object.keys(workflowActivities ?? {}), ...Object.keys(contractActivities ?? {})]);
+	for (const [name] of overrideEntries) if (!declared.has(name)) throw new Error(`activityOptionsByName entry "${name}" does not match any declared activity. Available: ${[...declared].join(", ") || "none"}.`);
+	const overriddenFns = {};
+	for (const [name, override] of overrideEntries) {
+		const fn = proxyActivities({
+			...defaultOptions,
+			...override
+		})[name];
+		if (fn !== void 0) overriddenFns[name] = fn;
+	}
+	return new Proxy(overriddenFns, { get(target, prop) {
+		if (typeof prop !== "string") return void 0;
+		return target[prop] ?? defaultProxy[prop];
+	} });
+}
+/**
+* Build the typed `continueAsNew` function bound to the running workflow's
+* contract. Two overloads — same-workflow and cross-contract — share one
+* implementation; the public type signature lives on `WorkflowContext` so
+* call sites are type-safe.
+*
+* Validation runs *before* Temporal's `makeContinueAsNewFunc(...)` is invoked.
+* On failure, throws a `WorkflowInputValidationError` (matching the behaviour
+* of `declareWorkflow`'s incoming-input validation), which surfaces back to
+* Temporal as a workflow failure rather than silently proceeding with an
+* invalid run.
+*
+* Temporal's `continueAsNew` never returns — it throws a `ContinueAsNew`
+* exception that the runtime intercepts. The returned function preserves
+* `Promise<never>` to encode that.
+*
+* @internal
+*/
+function createContinueAsNew(currentContract, currentWorkflowName) {
+	return async function continueAsNew(arg1, arg2, arg3, arg4) {
+		const isCrossContract = looksLikeCrossContractCall(arg1, arg2);
+		let targetContract;
+		let targetName;
+		let rawArgs;
+		let options;
+		if (isCrossContract) {
+			targetContract = arg1;
+			targetName = arg2;
+			rawArgs = arg3;
+			options = arg4;
+		} else {
+			targetContract = currentContract;
+			targetName = String(currentWorkflowName);
+			rawArgs = arg1;
+			options = arg2;
+		}
+		const targetDef = targetContract.workflows[targetName];
+		if (!targetDef) throw new WorkflowInputValidationError(targetName, [{ message: `continueAsNew target workflow "${targetName}" is not declared on the supplied contract.` }]);
+		const inputResult = await targetDef.input["~standard"].validate(rawArgs);
+		if (inputResult.issues) throw new WorkflowInputValidationError(targetName, inputResult.issues);
+		await makeContinueAsNewFunc({
+			workflowType: targetName,
+			taskQueue: targetContract.taskQueue,
+			...options
+		})(inputResult.value);
+	};
+}
+/**
+* Structural check: does `(arg1, arg2)` look like the
+* `(contract, workflowName, ...)` cross-contract overload of `continueAsNew`?
+*
+* Returns `true` only when:
+*   1. `arg1` is a non-null object with a string `taskQueue` and a non-null
+*      object `workflows` (handles `workflows: null`, where
+*      `typeof null === "object"`).
+*   2. `arg2` is a string.
+*
+* Both halves matter. A same-workflow input that happens to contain
+* `taskQueue` and `workflows` keys would otherwise be misclassified — but
+* none of the same-workflow signatures (`continueAsNew(args)`,
+* `continueAsNew(args, options)`) accept a string as `arg2`, so the
+* second check makes the false-positive surface vanishingly small.
+*
+* We deliberately do *not* check that `arg1.workflows[arg2]` is a valid
+* workflow definition. If it isn't, the dispatcher falls through to the
+* `targetContract.workflows[targetName]` lookup which throws a clear
+* "target workflow X is not declared" error — better than silently
+* misrouting a typo back to the current workflow.
+*/
+function looksLikeCrossContractCall(arg1, arg2) {
+	if (typeof arg1 !== "object" || arg1 === null) return false;
+	if (typeof arg2 !== "string") return false;
+	const candidate = arg1;
+	if (typeof candidate["taskQueue"] !== "string") return false;
+	const workflows = candidate["workflows"];
+	return typeof workflows === "object" && workflows !== null;
+}
+//#endregion
+export { formatChildWorkflowValidationMessage as _, ActivityInputValidationError as a, ChildWorkflowNotFoundError as c, SignalInputValidationError as d, UpdateInputValidationError as f, WorkflowOutputValidationError as g, WorkflowInputValidationError as h, ActivityDefinitionNotFoundError as i, QueryInputValidationError as l, WorkflowCancelledError as m, createContinueAsNew as n, ActivityOutputValidationError as o, UpdateOutputValidationError as p, extractHandlerInput as r, ChildWorkflowError as s, buildRawActivitiesProxy as t, QueryOutputValidationError as u };
+
+//# sourceMappingURL=internal-BoNcEtYh.mjs.map