@temporal-contract/worker 2.0.0 → 2.2.0

package/dist/activity.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_internal = require("./internal-C8MB-kez.cjs");
+const require_internal = require("./internal-Cwch3OHR.cjs");
 let _temporalio_common = require("@temporalio/common");
 //#region src/activity.ts
 /**

package/dist/activity.d.cts

@@ -1,4 +1,4 @@
-import { _ as WorkerInferOutput, g as WorkerInferInput, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-BeIXtRJe.cjs";
+import { n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError, v as WorkerInferInput, y as WorkerInferOutput } from "./errors-DTq5OTwH.cjs";
 import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
 import { ResultAsync } from "neverthrow";
 import { ApplicationFailure, ApplicationFailure as ApplicationFailure$1 } from "@temporalio/common";
@@ -15,7 +15,27 @@ import { ApplicationFailure, ApplicationFailure as ApplicationFailure$1 } from "
  */
 type ResultActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => ResultAsync<WorkerInferOutput<TActivity>, ApplicationFailure$1>;
 /**
- * Map of all activity implementations for a contract (global + all workflow-specific)
+ * Map of all activity implementations for a contract (global + all workflow-specific).
+ *
+ * **Shape note — input is nested by workflow, output is flat.** This
+ * asymmetry is deliberate:
+ *
+ * - The implementation map you write **mirrors the contract's structure**:
+ *   global activities sit at the root, workflow-local activities nest
+ *   under their owning workflow's name. Mirroring the contract gives
+ *   IDE autocomplete that matches `defineContract`, prevents typos that
+ *   put a workflow-local activity at the global level, and makes
+ *   ownership visible at definition time.
+ * - The handler returned by {@link declareActivitiesHandler} (see
+ *   {@link ActivitiesHandler}) is **flat** because Temporal's worker
+ *   sees a single activity namespace at runtime —
+ *   `proxyActivities<...>()` resolves names from one map regardless of
+ *   which workflow consumes them. `defineContract` enforces no name
+ *   collisions across global + workflow-local scopes, so the flat
+ *   output has no ambiguity to resolve.
+ *
+ * In short: write nested (mirror the contract); the wrapper flattens
+ * for Temporal.
  */
 type ContractResultActivitiesImplementations<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? ResultActivitiesImplementations<TContract["activities"]> : {}) & { [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? ResultActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} };
 type ResultActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: ResultActivityImplementation<TActivities[K]> };
@@ -30,9 +50,12 @@ type ActivityImplementation<TActivity extends ActivityDefinition> = (args: Worke
 type ActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: ActivityImplementation<TActivities[K]> };
 type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 /**
- * Activities handler ready for Temporal Worker
+ * Activities handler ready for Temporal's `Worker.create({ activities })`.
  *
- * Flat structure: all activities (global + all workflow-specific) are at the root level
+ * Flat shape: every activity (global + all workflow-local) lives at the
+ * root of the returned map. See the doc comment on
+ * {@link ContractResultActivitiesImplementations} for why the input you
+ * write is nested by workflow while this output is flat.
  */
 type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? ActivitiesImplementations<TContract["activities"]> : {}) & UnionToIntersection<{ [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? ActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} }[keyof TContract["workflows"]]>;
 /**

package/dist/activity.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"activity.d.cts","names":[],"sources":["../src/activity.ts"],"mappings":";;;;;;AA+BwD;;;;;;;;;AAAA,KAWnD,4BAAA,mBAA+C,kBAAA,KAClD,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,WAAA,CAAY,iBAAA,CAAkB,SAAA,GAAY,oBAAA;;;;KAK1C,uCAAA,mBAA0D,kBAAA,KAE5D,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,+BAAA,CAAgC,SAAA,8CAIZ,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,+BAAA,CAAgC,SAAA,cAAuB,SAAA;AAAA,KAI5D,+BAAA,qBAAoD,MAAA,SAAe,kBAAA,mBAC1D,WAAA,GAAc,4BAAA,CAA6B,WAAA,CAAY,CAAA;;;;KAMhE,+BAAA,mBAAkD,kBAAA;EACrD,QAAA,EAAU,SAAA;EACV,UAAA,EAAY,uCAAA,CAAwC,SAAA;AAAA;AAAA,KAGjD,sBAAA,mBAAyC,kBAAA,KAC5C,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,OAAA,CAAQ,iBAAA,CAAkB,SAAA;AAAA,KAE1B,yBAAA,qBAA8C,MAAA,SAAe,kBAAA,mBACpD,WAAA,GAAc,sBAAA,CAAuB,WAAA,CAAY,CAAA;AAAA,KAG1D,mBAAA,OAA0B,CAAA,oBAAqB,CAAA,EAAG,CAAA,6BACrD,CAAA,sBAEE,CAAA;;;;;;KAQQ,iBAAA,mBAAoC,kBAAA,KAE7C,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,yBAAA,CAA0B,SAAA,wBAG5B,mBAAA,uBAEwB,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,yBAAA,CAA0B,SAAA,cAAuB,SAAA,8BAE/C,SAAA;;;;;;;;;;;;;;;;;;;;;;AAjD4D;;;;;;;;;;;;;;;;;;;;;AAKJ;;;;;;;;;;;;;;;;;;AAQP;;iBAqG/C,wBAAA,mBAA2C,kBAAA,CAAA,CACzD,OAAA,EAAS,+BAAA,CAAgC,SAAA,IACxC,iBAAA,CAAkB,SAAA"}
+{"version":3,"file":"activity.d.cts","names":[],"sources":["../src/activity.ts"],"mappings":";;;;;;AA+BwD;;;;;;;;;AAAA,KAWnD,4BAAA,mBAA+C,kBAAA,KAClD,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,WAAA,CAAY,iBAAA,CAAkB,SAAA,GAAY,oBAAA;;;;;;;;;;;;;;AAAkB;;;;;;;;;;KAyB5D,uCAAA,mBAA0D,kBAAA,KAE5D,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,+BAAA,CAAgC,SAAA,8CAIZ,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,+BAAA,CAAgC,SAAA,cAAuB,SAAA;AAAA,KAI5D,+BAAA,qBAAoD,MAAA,SAAe,kBAAA,mBAC1D,WAAA,GAAc,4BAAA,CAA6B,WAAA,CAAY,CAAA;;;;KAMhE,+BAAA,mBAAkD,kBAAA;EACrD,QAAA,EAAU,SAAA;EACV,UAAA,EAAY,uCAAA,CAAwC,SAAA;AAAA;AAAA,KAGjD,sBAAA,mBAAyC,kBAAA,KAC5C,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,OAAA,CAAQ,iBAAA,CAAkB,SAAA;AAAA,KAE1B,yBAAA,qBAA8C,MAAA,SAAe,kBAAA,mBACpD,WAAA,GAAc,sBAAA,CAAuB,WAAA,CAAY,CAAA;AAAA,KAG1D,mBAAA,OAA0B,CAAA,oBAAqB,CAAA,EAAG,CAAA,6BACrD,CAAA,sBAEE,CAAA;;;;;;;;;KAWQ,iBAAA,mBAAoC,kBAAA,KAE7C,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,yBAAA,CAA0B,SAAA,wBAG5B,mBAAA,uBAEwB,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,yBAAA,CAA0B,SAAA,cAAuB,SAAA,8BAE/C,SAAA;;;;;;;;;;;;;;;;;;;;AA/CwD;;;;;;;;;;;;;;;;;;AAQP;;;;;;;;;;;;;;;;;;;;;AAKvB;;;;iBAmGxB,wBAAA,mBAA2C,kBAAA,CAAA,CACzD,OAAA,EAAS,+BAAA,CAAgC,SAAA,IACxC,iBAAA,CAAkB,SAAA"}

package/dist/activity.d.mts

@@ -1,7 +1,7 @@
-import { _ as WorkerInferOutput, g as WorkerInferInput, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-BjNG_jUi.mjs";
+import { n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError, v as WorkerInferInput, y as WorkerInferOutput } from "./errors-DbPMxULo.mjs";
+import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
 import { ApplicationFailure, ApplicationFailure as ApplicationFailure$1 } from "@temporalio/common";
 import { ResultAsync } from "neverthrow";
-import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
 
 //#region src/activity.d.ts
 /**
@@ -15,7 +15,27 @@ import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contr
  */
 type ResultActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => ResultAsync<WorkerInferOutput<TActivity>, ApplicationFailure$1>;
 /**
- * Map of all activity implementations for a contract (global + all workflow-specific)
+ * Map of all activity implementations for a contract (global + all workflow-specific).
+ *
+ * **Shape note — input is nested by workflow, output is flat.** This
+ * asymmetry is deliberate:
+ *
+ * - The implementation map you write **mirrors the contract's structure**:
+ *   global activities sit at the root, workflow-local activities nest
+ *   under their owning workflow's name. Mirroring the contract gives
+ *   IDE autocomplete that matches `defineContract`, prevents typos that
+ *   put a workflow-local activity at the global level, and makes
+ *   ownership visible at definition time.
+ * - The handler returned by {@link declareActivitiesHandler} (see
+ *   {@link ActivitiesHandler}) is **flat** because Temporal's worker
+ *   sees a single activity namespace at runtime —
+ *   `proxyActivities<...>()` resolves names from one map regardless of
+ *   which workflow consumes them. `defineContract` enforces no name
+ *   collisions across global + workflow-local scopes, so the flat
+ *   output has no ambiguity to resolve.
+ *
+ * In short: write nested (mirror the contract); the wrapper flattens
+ * for Temporal.
  */
 type ContractResultActivitiesImplementations<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? ResultActivitiesImplementations<TContract["activities"]> : {}) & { [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? ResultActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} };
 type ResultActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: ResultActivityImplementation<TActivities[K]> };
@@ -30,9 +50,12 @@ type ActivityImplementation<TActivity extends ActivityDefinition> = (args: Worke
 type ActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: ActivityImplementation<TActivities[K]> };
 type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 /**
- * Activities handler ready for Temporal Worker
+ * Activities handler ready for Temporal's `Worker.create({ activities })`.
  *
- * Flat structure: all activities (global + all workflow-specific) are at the root level
+ * Flat shape: every activity (global + all workflow-local) lives at the
+ * root of the returned map. See the doc comment on
+ * {@link ContractResultActivitiesImplementations} for why the input you
+ * write is nested by workflow while this output is flat.
  */
 type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? ActivitiesImplementations<TContract["activities"]> : {}) & UnionToIntersection<{ [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? ActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} }[keyof TContract["workflows"]]>;
 /**

package/dist/activity.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"activity.d.mts","names":[],"sources":["../src/activity.ts"],"mappings":";;;;;;AA+BwD;;;;;;;;;AAAA,KAWnD,4BAAA,mBAA+C,kBAAA,KAClD,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,WAAA,CAAY,iBAAA,CAAkB,SAAA,GAAY,oBAAA;;;;KAK1C,uCAAA,mBAA0D,kBAAA,KAE5D,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,+BAAA,CAAgC,SAAA,8CAIZ,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,+BAAA,CAAgC,SAAA,cAAuB,SAAA;AAAA,KAI5D,+BAAA,qBAAoD,MAAA,SAAe,kBAAA,mBAC1D,WAAA,GAAc,4BAAA,CAA6B,WAAA,CAAY,CAAA;;;;KAMhE,+BAAA,mBAAkD,kBAAA;EACrD,QAAA,EAAU,SAAA;EACV,UAAA,EAAY,uCAAA,CAAwC,SAAA;AAAA;AAAA,KAGjD,sBAAA,mBAAyC,kBAAA,KAC5C,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,OAAA,CAAQ,iBAAA,CAAkB,SAAA;AAAA,KAE1B,yBAAA,qBAA8C,MAAA,SAAe,kBAAA,mBACpD,WAAA,GAAc,sBAAA,CAAuB,WAAA,CAAY,CAAA;AAAA,KAG1D,mBAAA,OAA0B,CAAA,oBAAqB,CAAA,EAAG,CAAA,6BACrD,CAAA,sBAEE,CAAA;;;;;;KAQQ,iBAAA,mBAAoC,kBAAA,KAE7C,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,yBAAA,CAA0B,SAAA,wBAG5B,mBAAA,uBAEwB,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,yBAAA,CAA0B,SAAA,cAAuB,SAAA,8BAE/C,SAAA;;;;;;;;;;;;;;;;;;;;;;AAjD4D;;;;;;;;;;;;;;;;;;;;;AAKJ;;;;;;;;;;;;;;;;;;AAQP;;iBAqG/C,wBAAA,mBAA2C,kBAAA,CAAA,CACzD,OAAA,EAAS,+BAAA,CAAgC,SAAA,IACxC,iBAAA,CAAkB,SAAA"}
+{"version":3,"file":"activity.d.mts","names":[],"sources":["../src/activity.ts"],"mappings":";;;;;;AA+BwD;;;;;;;;;AAAA,KAWnD,4BAAA,mBAA+C,kBAAA,KAClD,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,WAAA,CAAY,iBAAA,CAAkB,SAAA,GAAY,oBAAA;;;;;;;;;;;;;;AAAkB;;;;;;;;;;KAyB5D,uCAAA,mBAA0D,kBAAA,KAE5D,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,+BAAA,CAAgC,SAAA,8CAIZ,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,+BAAA,CAAgC,SAAA,cAAuB,SAAA;AAAA,KAI5D,+BAAA,qBAAoD,MAAA,SAAe,kBAAA,mBAC1D,WAAA,GAAc,4BAAA,CAA6B,WAAA,CAAY,CAAA;;;;KAMhE,+BAAA,mBAAkD,kBAAA;EACrD,QAAA,EAAU,SAAA;EACV,UAAA,EAAY,uCAAA,CAAwC,SAAA;AAAA;AAAA,KAGjD,sBAAA,mBAAyC,kBAAA,KAC5C,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,OAAA,CAAQ,iBAAA,CAAkB,SAAA;AAAA,KAE1B,yBAAA,qBAA8C,MAAA,SAAe,kBAAA,mBACpD,WAAA,GAAc,sBAAA,CAAuB,WAAA,CAAY,CAAA;AAAA,KAG1D,mBAAA,OAA0B,CAAA,oBAAqB,CAAA,EAAG,CAAA,6BACrD,CAAA,sBAEE,CAAA;;;;;;;;;KAWQ,iBAAA,mBAAoC,kBAAA,KAE7C,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,yBAAA,CAA0B,SAAA,wBAG5B,mBAAA,uBAEwB,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,yBAAA,CAA0B,SAAA,cAAuB,SAAA,8BAE/C,SAAA;;;;;;;;;;;;;;;;;;;;AA/CwD;;;;;;;;;;;;;;;;;;AAQP;;;;;;;;;;;;;;;;;;;;;AAKvB;;;;iBAmGxB,wBAAA,mBAA2C,kBAAA,CAAA,CACzD,OAAA,EAAS,+BAAA,CAAgC,SAAA,IACxC,iBAAA,CAAkB,SAAA"}

package/dist/activity.mjs

@@ -1,4 +1,4 @@
-import { a as ActivityInputValidationError, i as ActivityDefinitionNotFoundError, o as ActivityOutputValidationError, r as extractHandlerInput } from "./internal--45IXCxX.mjs";
+import { c as ActivityInputValidationError, i as extractHandlerInput, l as ActivityOutputValidationError, s as ActivityDefinitionNotFoundError } from "./internal-BzG1KhEK.mjs";
 import { ApplicationFailure } from "@temporalio/common";
 //#region src/activity.ts
 /**

package/dist/activity.mjs.map

@@ -1 +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 use neverthrow's\n// `ResultAsync` directly. Workflow code (see workflow.ts) uses the same\n// neverthrow API — neverthrow's evaluation is compatible with Temporal's\n// 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 type { ResultAsync } from \"neverthrow\";\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 neverthrow's `ResultAsync`.\n *\n * Returns `ResultAsync<Output, ApplicationFailure>` for explicit error\n * handling instead of throwing. The wrapper rethrows `err()` payloads at\n * the activity boundary; Temporal recognizes `ApplicationFailure` natively\n * and applies the configured retry policy (with `nonRetryable: true`\n * opting an instance out per-call).\n */\ntype ResultActivityImplementation<TActivity extends ActivityDefinition> = (\n  args: WorkerInferInput<TActivity>,\n) => ResultAsync<WorkerInferOutput<TActivity>, ApplicationFailure>;\n\n/**\n * Map of all activity implementations for a contract (global + all workflow-specific)\n */\ntype ContractResultActivitiesImplementations<TContract extends ContractDefinition> =\n  // Global activities\n  (TContract[\"activities\"] extends Record<string, ActivityDefinition>\n    ? ResultActivitiesImplementations<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        ? ResultActivitiesImplementations<TContract[\"workflows\"][TWorkflow][\"activities\"]>\n        : {};\n    };\n\ntype ResultActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = {\n  [K in keyof TActivities]: ResultActivityImplementation<TActivities[K]>;\n};\n\n/**\n * Options for creating activities handler\n */\ntype DeclareActivitiesHandlerOptions<TContract extends ContractDefinition> = {\n  contract: TContract;\n  activities: ContractResultActivitiesImplementations<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 * - `ResultAsync<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 { ResultAsync, errAsync, okAsync } from 'neverthrow';\n * import myContract from './contract';\n *\n * export const activities = declareActivitiesHandler({\n *   contract: myContract,\n *   activities: {\n *     // Activity returns ResultAsync instead of throwing.\n *     sendEmail: (args) =>\n *       ResultAsync.fromPromise(\n *         emailService.send(args),\n *         (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 *           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 *       ).map(() => ({ sent: true })),\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 * `ResultAsync<T, ApplicationFailure>` shape and produces ordinary\n * Promise-returning Temporal handlers (`err(...)` → thrown\n * `ApplicationFailure`; `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) => ResultAsync<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 neverthrow activity (returns ResultAsync<T, ApplicationFailure>);\n      // awaiting yields a Result<T, ApplicationFailure>.\n      const result = await activityImpl(inputResult.value);\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 err(...) payload 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) => ResultAsync<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) => ResultAsync<unknown, ApplicationFailure>,\n        );\n      }\n    }\n  }\n\n  return wrappedActivities;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8KA,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;GAK1E,MAAM,SAAS,MAAM,aAAa,YAAY,MAAM;AAGpD,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"}
+{"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 use neverthrow's\n// `ResultAsync` directly. Workflow code (see workflow.ts) uses the same\n// neverthrow API — neverthrow's evaluation is compatible with Temporal's\n// 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 type { ResultAsync } from \"neverthrow\";\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 neverthrow's `ResultAsync`.\n *\n * Returns `ResultAsync<Output, ApplicationFailure>` for explicit error\n * handling instead of throwing. The wrapper rethrows `err()` payloads at\n * the activity boundary; Temporal recognizes `ApplicationFailure` natively\n * and applies the configured retry policy (with `nonRetryable: true`\n * opting an instance out per-call).\n */\ntype ResultActivityImplementation<TActivity extends ActivityDefinition> = (\n  args: WorkerInferInput<TActivity>,\n) => ResultAsync<WorkerInferOutput<TActivity>, ApplicationFailure>;\n\n/**\n * Map of all activity implementations for a contract (global + all workflow-specific).\n *\n * **Shape note — input is nested by workflow, output is flat.** This\n * asymmetry is deliberate:\n *\n * - The implementation map you write **mirrors the contract's structure**:\n *   global activities sit at the root, workflow-local activities nest\n *   under their owning workflow's name. Mirroring the contract gives\n *   IDE autocomplete that matches `defineContract`, prevents typos that\n *   put a workflow-local activity at the global level, and makes\n *   ownership visible at definition time.\n * - The handler returned by {@link declareActivitiesHandler} (see\n *   {@link ActivitiesHandler}) is **flat** because Temporal's worker\n *   sees a single activity namespace at runtime —\n *   `proxyActivities<...>()` resolves names from one map regardless of\n *   which workflow consumes them. `defineContract` enforces no name\n *   collisions across global + workflow-local scopes, so the flat\n *   output has no ambiguity to resolve.\n *\n * In short: write nested (mirror the contract); the wrapper flattens\n * for Temporal.\n */\ntype ContractResultActivitiesImplementations<TContract extends ContractDefinition> =\n  // Global activities\n  (TContract[\"activities\"] extends Record<string, ActivityDefinition>\n    ? ResultActivitiesImplementations<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        ? ResultActivitiesImplementations<TContract[\"workflows\"][TWorkflow][\"activities\"]>\n        : {};\n    };\n\ntype ResultActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = {\n  [K in keyof TActivities]: ResultActivityImplementation<TActivities[K]>;\n};\n\n/**\n * Options for creating activities handler\n */\ntype DeclareActivitiesHandlerOptions<TContract extends ContractDefinition> = {\n  contract: TContract;\n  activities: ContractResultActivitiesImplementations<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's `Worker.create({ activities })`.\n *\n * Flat shape: every activity (global + all workflow-local) lives at the\n * root of the returned map. See the doc comment on\n * {@link ContractResultActivitiesImplementations} for why the input you\n * write is nested by workflow while this output is flat.\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 * - `ResultAsync<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 { ResultAsync, errAsync, okAsync } from 'neverthrow';\n * import myContract from './contract';\n *\n * export const activities = declareActivitiesHandler({\n *   contract: myContract,\n *   activities: {\n *     // Activity returns ResultAsync instead of throwing.\n *     sendEmail: (args) =>\n *       ResultAsync.fromPromise(\n *         emailService.send(args),\n *         (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 *           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 *       ).map(() => ({ sent: true })),\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 * `ResultAsync<T, ApplicationFailure>` shape and produces ordinary\n * Promise-returning Temporal handlers (`err(...)` → thrown\n * `ApplicationFailure`; `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) => ResultAsync<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 neverthrow activity (returns ResultAsync<T, ApplicationFailure>);\n      // awaiting yields a Result<T, ApplicationFailure>.\n      const result = await activityImpl(inputResult.value);\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 err(...) payload 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) => ResultAsync<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) => ResultAsync<unknown, ApplicationFailure>,\n        );\n      }\n    }\n  }\n\n  return wrappedActivities;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqMA,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;GAK1E,MAAM,SAAS,MAAM,aAAa,YAAY,MAAM;AAGpD,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-BeIXtRJe.d.cts → errors-DTq5OTwH.d.cts}

@@ -127,23 +127,82 @@ declare class ChildWorkflowNotFoundError extends WorkerError {
   constructor(workflowName: string, availableWorkflows?: readonly string[]);
 }
 /**
- * Generic error for child workflow operations
+ * Generic error for child workflow operations.
+ *
+ * When the child execution itself fails (Temporal's `ChildWorkflowFailure`),
+ * `cause` is set to the *unwrapped* underlying failure (`ApplicationFailure`,
+ * `TimeoutFailure`, `TerminatedFailure`, etc.) lifted from Temporal's wrapper —
+ * mirroring the client-side `WorkflowFailedError.cause` behavior, so callers
+ * can branch on the failure category in one step instead of unwrapping twice.
  */
 declare class ChildWorkflowError extends WorkerError {
   constructor(message: string, cause?: unknown);
 }
+/**
+ * Discriminated variant of {@link ChildWorkflowError} surfaced when a child
+ * workflow operation (start, execute, or wait-for-result) was cancelled —
+ * either because the parent workflow itself was cancelled, the child was
+ * explicitly cancelled, or its enclosing cancellation scope was. Detected via
+ * `@temporalio/workflow`'s `isCancellation(...)`, which sees through nested
+ * `ChildWorkflowFailure` / `CancelledFailure` chains.
+ *
+ * Extends {@link ChildWorkflowError} so existing `instanceof ChildWorkflowError`
+ * checks still match cancellation, while `instanceof ChildWorkflowCancelledError`
+ * lets call sites narrow further when they need to branch on cancellation
+ * explicitly without inspecting `error.cause` against a Temporal SDK class —
+ * the worker-side analogue of the client-side cause-forwarding pattern.
+ */
+declare class ChildWorkflowCancelledError extends ChildWorkflowError {
+  readonly workflowName: string;
+  constructor(workflowName: string, cause?: unknown);
+}
 /**
  * Error surfaced in the `err(...)` branch of a `ResultAsync` 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 ResultAsync rejections.
+ * thrown errors so call sites can branch on cancellation explicitly.
+ *
+ * Non-cancellation errors thrown inside a scope surface as a sibling
+ * {@link WorkflowScopeError} on the same `err(...)` channel, so callers can
+ * use `instanceof` to discriminate without falling back to `try/catch`.
  */
 declare class WorkflowCancelledError extends WorkerError {
   constructor(cause?: unknown);
 }
+/**
+ * Error surfaced in the `err(...)` branch of a `ResultAsync` when the
+ * function passed to `cancellableScope` / `nonCancellableScope` throws a
+ * non-cancellation error.
+ *
+ * The original error is preserved on `cause` so call sites can introspect
+ * it without losing identity:
+ *
+ * @example
+ * ```ts
+ * const result = await context.cancellableScope(async () => {
+ *   return await context.activities.processStep(args);
+ * });
+ *
+ * if (result.isErr()) {
+ *   if (result.error instanceof WorkflowCancelledError) {
+ *     // graceful cancellation
+ *   } else if (result.error instanceof WorkflowScopeError) {
+ *     // domain error — `result.error.cause` is the original throwable
+ *   }
+ * }
+ * ```
+ *
+ * Introduced so the scope helpers route every failure through neverthrow's
+ * railway. Previously, non-cancellation errors were re-thrown out of the
+ * helper, which became a `ResultAsync` rejection (`new ResultAsync(promise)`
+ * does not catch) — they leaked as unhandled rejections rather than
+ * surfacing on the typed error channel callers actually inspect.
+ */
+declare class WorkflowScopeError extends WorkerError {
+  constructor(cause: unknown);
+}
 //#endregion
-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-BeIXtRJe.d.cts.map
+export { ClientInferOutput as _, ChildWorkflowError as a, QueryOutputValidationError as c, UpdateOutputValidationError as d, WorkflowCancelledError as f, ClientInferInput as g, WorkflowScopeError as h, ChildWorkflowCancelledError as i, SignalInputValidationError as l, WorkflowOutputValidationError as m, ActivityInputValidationError as n, ChildWorkflowNotFoundError as o, WorkflowInputValidationError as p, ActivityOutputValidationError as r, QueryInputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateInputValidationError as u, WorkerInferInput as v, WorkerInferOutput as y };
+//# sourceMappingURL=errors-DTq5OTwH.d.cts.map

package/dist/{errors-BeIXtRJe.d.cts.map → errors-DTq5OTwH.d.cts.map}

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

package/dist/{errors-BjNG_jUi.d.mts → errors-DbPMxULo.d.mts}

@@ -127,23 +127,82 @@ declare class ChildWorkflowNotFoundError extends WorkerError {
   constructor(workflowName: string, availableWorkflows?: readonly string[]);
 }
 /**
- * Generic error for child workflow operations
+ * Generic error for child workflow operations.
+ *
+ * When the child execution itself fails (Temporal's `ChildWorkflowFailure`),
+ * `cause` is set to the *unwrapped* underlying failure (`ApplicationFailure`,
+ * `TimeoutFailure`, `TerminatedFailure`, etc.) lifted from Temporal's wrapper —
+ * mirroring the client-side `WorkflowFailedError.cause` behavior, so callers
+ * can branch on the failure category in one step instead of unwrapping twice.
  */
 declare class ChildWorkflowError extends WorkerError {
   constructor(message: string, cause?: unknown);
 }
+/**
+ * Discriminated variant of {@link ChildWorkflowError} surfaced when a child
+ * workflow operation (start, execute, or wait-for-result) was cancelled —
+ * either because the parent workflow itself was cancelled, the child was
+ * explicitly cancelled, or its enclosing cancellation scope was. Detected via
+ * `@temporalio/workflow`'s `isCancellation(...)`, which sees through nested
+ * `ChildWorkflowFailure` / `CancelledFailure` chains.
+ *
+ * Extends {@link ChildWorkflowError} so existing `instanceof ChildWorkflowError`
+ * checks still match cancellation, while `instanceof ChildWorkflowCancelledError`
+ * lets call sites narrow further when they need to branch on cancellation
+ * explicitly without inspecting `error.cause` against a Temporal SDK class —
+ * the worker-side analogue of the client-side cause-forwarding pattern.
+ */
+declare class ChildWorkflowCancelledError extends ChildWorkflowError {
+  readonly workflowName: string;
+  constructor(workflowName: string, cause?: unknown);
+}
 /**
  * Error surfaced in the `err(...)` branch of a `ResultAsync` 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 ResultAsync rejections.
+ * thrown errors so call sites can branch on cancellation explicitly.
+ *
+ * Non-cancellation errors thrown inside a scope surface as a sibling
+ * {@link WorkflowScopeError} on the same `err(...)` channel, so callers can
+ * use `instanceof` to discriminate without falling back to `try/catch`.
  */
 declare class WorkflowCancelledError extends WorkerError {
   constructor(cause?: unknown);
 }
+/**
+ * Error surfaced in the `err(...)` branch of a `ResultAsync` when the
+ * function passed to `cancellableScope` / `nonCancellableScope` throws a
+ * non-cancellation error.
+ *
+ * The original error is preserved on `cause` so call sites can introspect
+ * it without losing identity:
+ *
+ * @example
+ * ```ts
+ * const result = await context.cancellableScope(async () => {
+ *   return await context.activities.processStep(args);
+ * });
+ *
+ * if (result.isErr()) {
+ *   if (result.error instanceof WorkflowCancelledError) {
+ *     // graceful cancellation
+ *   } else if (result.error instanceof WorkflowScopeError) {
+ *     // domain error — `result.error.cause` is the original throwable
+ *   }
+ * }
+ * ```
+ *
+ * Introduced so the scope helpers route every failure through neverthrow's
+ * railway. Previously, non-cancellation errors were re-thrown out of the
+ * helper, which became a `ResultAsync` rejection (`new ResultAsync(promise)`
+ * does not catch) — they leaked as unhandled rejections rather than
+ * surfacing on the typed error channel callers actually inspect.
+ */
+declare class WorkflowScopeError extends WorkerError {
+  constructor(cause: unknown);
+}
 //#endregion
-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-BjNG_jUi.d.mts.map
+export { ClientInferOutput as _, ChildWorkflowError as a, QueryOutputValidationError as c, UpdateOutputValidationError as d, WorkflowCancelledError as f, ClientInferInput as g, WorkflowScopeError as h, ChildWorkflowCancelledError as i, SignalInputValidationError as l, WorkflowOutputValidationError as m, ActivityInputValidationError as n, ChildWorkflowNotFoundError as o, WorkflowInputValidationError as p, ActivityOutputValidationError as r, QueryInputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateInputValidationError as u, WorkerInferInput as v, WorkerInferOutput as y };
+//# sourceMappingURL=errors-DbPMxULo.d.mts.map

package/dist/{errors-BjNG_jUi.d.mts.map → errors-DbPMxULo.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"errors-BjNG_jUi.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"}
+{"version":3,"file":"errors-DbPMxULo.d.mts","names":[],"sources":["../src/types.ts","../src/errors.ts"],"mappings":"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"}

package/dist/{internal--45IXCxX.mjs → internal-BzG1KhEK.mjs}

@@ -1,47 +1,7 @@
-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
+import { summarizeIssues } from "@temporal-contract/contract";
+import { isCancellation, makeContinueAsNewFunc, proxyActivities } from "@temporalio/workflow";
+import { ChildWorkflowFailure } from "@temporalio/common";
+import { _internal_makeResultAsync as makeResultAsync } from "@temporal-contract/contract/result-async";
 //#region src/errors.ts
 /**
 * Base error class for worker errors
@@ -186,7 +146,13 @@ var ChildWorkflowNotFoundError = class extends WorkerError {
 	}
 };
 /**
-* Generic error for child workflow operations
+* Generic error for child workflow operations.
+*
+* When the child execution itself fails (Temporal's `ChildWorkflowFailure`),
+* `cause` is set to the *unwrapped* underlying failure (`ApplicationFailure`,
+* `TimeoutFailure`, `TerminatedFailure`, etc.) lifted from Temporal's wrapper —
+* mirroring the client-side `WorkflowFailedError.cause` behavior, so callers
+* can branch on the failure category in one step instead of unwrapping twice.
 */
 var ChildWorkflowError = class extends WorkerError {
 	constructor(message, cause) {
@@ -195,13 +161,37 @@ var ChildWorkflowError = class extends WorkerError {
 	}
 };
 /**
+* Discriminated variant of {@link ChildWorkflowError} surfaced when a child
+* workflow operation (start, execute, or wait-for-result) was cancelled —
+* either because the parent workflow itself was cancelled, the child was
+* explicitly cancelled, or its enclosing cancellation scope was. Detected via
+* `@temporalio/workflow`'s `isCancellation(...)`, which sees through nested
+* `ChildWorkflowFailure` / `CancelledFailure` chains.
+*
+* Extends {@link ChildWorkflowError} so existing `instanceof ChildWorkflowError`
+* checks still match cancellation, while `instanceof ChildWorkflowCancelledError`
+* lets call sites narrow further when they need to branch on cancellation
+* explicitly without inspecting `error.cause` against a Temporal SDK class —
+* the worker-side analogue of the client-side cause-forwarding pattern.
+*/
+var ChildWorkflowCancelledError = class extends ChildWorkflowError {
+	constructor(workflowName, cause) {
+		super(`Child workflow "${workflowName}" was cancelled`, cause);
+		this.workflowName = workflowName;
+		this.name = "ChildWorkflowCancelledError";
+	}
+};
+/**
 * Error surfaced in the `err(...)` branch of a `ResultAsync` 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 ResultAsync rejections.
+* thrown errors so call sites can branch on cancellation explicitly.
+*
+* Non-cancellation errors thrown inside a scope surface as a sibling
+* {@link WorkflowScopeError} on the same `err(...)` channel, so callers can
+* use `instanceof` to discriminate without falling back to `try/catch`.
 */
 var WorkflowCancelledError = class extends WorkerError {
 	constructor(cause) {
@@ -209,6 +199,42 @@ var WorkflowCancelledError = class extends WorkerError {
 		this.name = "WorkflowCancelledError";
 	}
 };
+/**
+* Error surfaced in the `err(...)` branch of a `ResultAsync` when the
+* function passed to `cancellableScope` / `nonCancellableScope` throws a
+* non-cancellation error.
+*
+* The original error is preserved on `cause` so call sites can introspect
+* it without losing identity:
+*
+* @example
+* ```ts
+* const result = await context.cancellableScope(async () => {
+*   return await context.activities.processStep(args);
+* });
+*
+* if (result.isErr()) {
+*   if (result.error instanceof WorkflowCancelledError) {
+*     // graceful cancellation
+*   } else if (result.error instanceof WorkflowScopeError) {
+*     // domain error — `result.error.cause` is the original throwable
+*   }
+* }
+* ```
+*
+* Introduced so the scope helpers route every failure through neverthrow's
+* railway. Previously, non-cancellation errors were re-thrown out of the
+* helper, which became a `ResultAsync` rejection (`new ResultAsync(promise)`
+* does not catch) — they leaked as unhandled rejections rather than
+* surfacing on the typed error channel callers actually inspect.
+*/
+var WorkflowScopeError = class extends WorkerError {
+	constructor(cause) {
+		const message = cause instanceof Error ? `Workflow cancellation scope caught a non-cancellation error: ${cause.message}` : "Workflow cancellation scope caught a non-cancellation error";
+		super(message, cause);
+		this.name = "WorkflowScopeError";
+	}
+};
 //#endregion
 //#region src/internal.ts
 /**
@@ -219,6 +245,15 @@ var WorkflowCancelledError = class extends WorkerError {
 * In-package tests import it directly via relative path.
 */
 /**
+* Build the message attached to a `ChildWorkflowError` for input/output
+* validation failures. Centralized so the worker formats child-workflow
+* validation diagnostics identically across call sites. Composes the shared
+* `summarizeIssues` from `@temporal-contract/contract`.
+*/
+function formatChildWorkflowValidationMessage(workflowName, direction, issues) {
+	return `Child workflow "${workflowName}" ${direction} validation failed: ${summarizeIssues(issues)}`;
+}
+/**
 * Extract the single payload from a Temporal handler's `...args` array.
 *
 * Temporal invokes handlers with whatever was passed via `args: [...]` at the
@@ -348,7 +383,50 @@ function looksLikeCrossContractCall(arg1, arg2) {
 	const workflows = candidate["workflows"];
 	return typeof workflows === "object" && workflows !== null;
 }
+/**
+* Map a thrown error from `startChild` / `executeChild` / `handle.result()`
+* (the worker-side child-workflow API) into the discriminated union surfaced
+* by the typed worker. Mirrors the client's `classifyResultError`:
+*
+* - Cancellation (detected via `@temporalio/workflow`'s `isCancellation`,
+*   which sees through nested `ChildWorkflowFailure → CancelledFailure`
+*   chains) → {@link ChildWorkflowCancelledError}, with the original error
+*   carried as `cause`.
+* - Temporal's `ChildWorkflowFailure` (a wrapper whose actionable failure —
+*   `ApplicationFailure`, `TimeoutFailure`, `TerminatedFailure`, etc. — lives
+*   on its `cause` field) → {@link ChildWorkflowError}, with that *inner*
+*   cause forwarded so consumers can match `err.cause instanceof
+*   ApplicationFailure` without unwrapping twice. (If the wrapper's `cause`
+*   is `undefined`, the wrapper itself is forwarded so identity is
+*   preserved.)
+* - Anything else → {@link ChildWorkflowError} carrying the raw thrown value
+*   as `cause`.
+*
+* The `operation` discriminator drives the human-readable error message so
+* call sites don't have to format their own.
+*
+* Note: `ChildWorkflowNotFoundError` is *not* produced here — it's only
+* thrown from the input-validation path when the workflow definition is
+* missing on the contract, before any Temporal call happens.
+*/
+function classifyChildWorkflowError(operation, error, childWorkflowName) {
+	if (isCancellation(error)) return new ChildWorkflowCancelledError(childWorkflowName, error);
+	if (error instanceof ChildWorkflowFailure) {
+		const inner = error.cause ?? error;
+		const innerMessage = inner instanceof Error ? inner.message : String(inner);
+		return new ChildWorkflowError(`${describeChildWorkflowOperation(operation, childWorkflowName)}: ${innerMessage}`, inner);
+	}
+	const message = error instanceof Error ? error.message : String(error);
+	return new ChildWorkflowError(`${describeChildWorkflowOperation(operation, childWorkflowName)}: ${message}`, error);
+}
+function describeChildWorkflowOperation(operation, childWorkflowName) {
+	switch (operation) {
+		case "startChild": return `Failed to start child workflow "${childWorkflowName}"`;
+		case "executeChild": return `Failed to execute child workflow "${childWorkflowName}"`;
+		case "result": return `Child workflow "${childWorkflowName}" execution failed`;
+	}
+}
 //#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 };
+export { UpdateOutputValidationError as _, formatChildWorkflowValidationMessage as a, WorkflowOutputValidationError as b, ActivityInputValidationError as c, ChildWorkflowError as d, ChildWorkflowNotFoundError as f, UpdateInputValidationError as g, SignalInputValidationError as h, extractHandlerInput as i, ActivityOutputValidationError as l, QueryOutputValidationError as m, classifyChildWorkflowError as n, makeResultAsync as o, QueryInputValidationError as p, createContinueAsNew as r, ActivityDefinitionNotFoundError as s, buildRawActivitiesProxy as t, ChildWorkflowCancelledError as u, WorkflowCancelledError as v, WorkflowScopeError as x, WorkflowInputValidationError as y };
 
-//# sourceMappingURL=internal--45IXCxX.mjs.map
+//# sourceMappingURL=internal-BzG1KhEK.mjs.map