@temporal-contract/worker 2.1.0 → 2.2.0

package/dist/activity.d.cts

@@ -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

@@ -15,7 +15,27 @@ import { ResultAsync } from "neverthrow";
  */
 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.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporal-contract/worker",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Worker utilities with neverthrow Result/ResultAsync for implementing temporal-contract workflows and activities",
   "keywords": [
     "contract",
@@ -60,7 +60,7 @@
   },
   "dependencies": {
     "@standard-schema/spec": "1.1.0",
-    "@temporal-contract/contract": "2.1.0"
+    "@temporal-contract/contract": "2.2.0"
   },
   "devDependencies": {
     "@temporalio/client": "1.17.0",
@@ -76,10 +76,10 @@
     "typescript": "6.0.3",
     "vitest": "4.1.5",
     "zod": "4.4.3",
-    "@temporal-contract/testing": "2.1.0",
-    "@temporal-contract/tsconfig": "1.0.0",
-    "@temporal-contract/client": "2.1.0",
-    "@temporal-contract/typedoc": "0.1.0"
+    "@temporal-contract/client": "2.2.0",
+    "@temporal-contract/testing": "2.2.0",
+    "@temporal-contract/typedoc": "0.1.0",
+    "@temporal-contract/tsconfig": "1.0.0"
   },
   "peerDependencies": {
     "@temporalio/common": "^1",