@temporal-contract/worker 0.0.7 → 0.2.0

package/README.md

@@ -14,43 +14,51 @@ pnpm add @temporal-contract/worker @temporal-contract/contract @temporalio/workf
 
 ```typescript
 // activities.ts
-import { declareActivitiesHandler } from '@temporal-contract/worker/activity';
+import { declareActivitiesHandler, ActivityError } from "@temporal-contract/worker/activity";
+import { Future, Result } from "@swan-io/boxed";
 
 export const activities = declareActivitiesHandler({
   contract: myContract,
   activities: {
-    sendEmail: async ({ to, body }) => ({ sent: true })
-  }
+    sendEmail: ({ to, body }) => {
+      return Future.fromPromise(emailService.send({ to, body }))
+        .mapError(
+          (error) =>
+            new ActivityError(
+              "EMAIL_FAILED",
+              error instanceof Error ? error.message : "Failed to send email",
+              error,
+            ),
+        )
+        .mapOk(() => ({ sent: true }));
+    },
+  },
 });
 
 // workflows.ts
-import { declareWorkflow } from '@temporal-contract/worker/workflow';
+import { declareWorkflow } from "@temporal-contract/worker/workflow";
 
 export const processOrder = declareWorkflow({
-  workflowName: 'processOrder',
+  workflowName: "processOrder",
   contract: myContract,
-  implementation: async (context, input) => {
-    await context.activities.sendEmail({ to: 'user@example.com', body: 'Done!' });
+  activityOptions: { startToCloseTimeout: "1 minute" },
+  implementation: async ({ activities }, input) => {
+    // Activities return plain values (Result is unwrapped internally)
+    await activities.sendEmail({ to: "user@example.com", body: "Done!" });
     return { success: true };
-  }
+  },
 });
 
 // worker.ts
-import { NativeConnection } from '@temporalio/worker';
-import { createWorker } from '@temporal-contract/worker/worker';
-import { activities } from './activities';
-import myContract from './contract';
+import { Worker } from "@temporalio/worker";
+import { activities } from "./activities";
+import myContract from "./contract";
 
 async function run() {
-  const connection = await NativeConnection.connect({
-    address: 'localhost:7233',
-  });
-
-  const worker = await createWorker({
-    contract: myContract,
-    connection,
-    workflowsPath: require.resolve('./workflows'),
+  const worker = await Worker.create({
+    workflowsPath: require.resolve("./workflows"),
     activities,
+    taskQueue: myContract.taskQueue,
   });
 
   await worker.run();
@@ -65,33 +73,38 @@ Execute child workflows with type-safe Future/Result pattern. Supports both same
 
 ```typescript
 // workflows.ts
-import { declareWorkflow } from '@temporal-contract/worker/workflow';
+import { declareWorkflow } from "@temporal-contract/worker/workflow";
 
 export const parentWorkflow = declareWorkflow({
-  workflowName: 'parentWorkflow',
+  workflowName: "parentWorkflow",
   contract: myContract,
+  activityOptions: { startToCloseTimeout: "1 minute" },
   implementation: async (context, input) => {
     // Execute child workflow from same contract and wait for result
-    const childResult = await context.executeChildWorkflow(myContract, 'processPayment', {
+    const childResult = await context.executeChildWorkflow(myContract, "processPayment", {
       workflowId: `payment-${input.orderId}`,
-      args: { amount: input.totalAmount }
+      args: { amount: input.totalAmount },
     });
 
     childResult.match({
-      Ok: (output) => console.log('Payment processed:', output),
-      Error: (error) => console.error('Payment failed:', error),
+      Ok: (output) => console.log("Payment processed:", output),
+      Error: (error) => console.error("Payment failed:", error),
     });
 
     // Execute child workflow from another contract (another worker)
-    const notificationResult = await context.executeChildWorkflow(notificationContract, 'sendNotification', {
-      workflowId: `notification-${input.orderId}`,
-      args: { message: 'Order received' }
-    });
+    const notificationResult = await context.executeChildWorkflow(
+      notificationContract,
+      "sendNotification",
+      {
+        workflowId: `notification-${input.orderId}`,
+        args: { message: "Order received" },
+      },
+    );
 
     // Or start child workflow without waiting
-    const handleResult = await context.startChildWorkflow(myContract, 'sendEmail', {
+    const handleResult = await context.startChildWorkflow(myContract, "sendEmail", {
       workflowId: `email-${input.orderId}`,
-      args: { to: 'user@example.com', body: 'Order received' }
+      args: { to: "user@example.com", body: "Order received" },
     });
 
     handleResult.match({
@@ -100,11 +113,11 @@ export const parentWorkflow = declareWorkflow({
         const result = await handle.result();
         // ...
       },
-      Error: (error) => console.error('Failed to start:', error),
+      Error: (error) => console.error("Failed to start:", error),
     });
 
     return { success: true };
-  }
+  },
 });
 ```
 

package/dist/activity-utils-B3vP03_P.d.mts

@@ -0,0 +1,68 @@
+import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
+
+//#region src/activity-utils.d.ts
+/**
+ * Extract activity definitions for a specific workflow from a contract
+ *
+ * This includes both:
+ * - Workflow-specific activities defined under workflow.activities
+ * - Global activities defined under contract.activities
+ *
+ * @param contract - The contract definition
+ * @param workflowName - The name of the workflow
+ * @returns Activity definitions for the workflow (workflow-specific + global activities merged)
+ *
+ * @example
+ * ```ts
+ * const orderWorkflowActivities = getWorkflowActivities(myContract, 'processOrder');
+ * // Returns: { processPayment: ActivityDef, reserveInventory: ActivityDef, sendEmail: ActivityDef }
+ * // where sendEmail is a global activity
+ * ```
+ */
+declare function getWorkflowActivities<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]>(contract: TContract, workflowName: TWorkflowName): Record<string, ActivityDefinition>;
+/**
+ * Extract all activity names for a specific workflow from a contract
+ *
+ * @param contract - The contract definition
+ * @param workflowName - The name of the workflow
+ * @returns Array of activity names (strings) available for the workflow
+ *
+ * @example
+ * ```ts
+ * const activityNames = getWorkflowActivityNames(myContract, 'processOrder');
+ * // Returns: ['processPayment', 'reserveInventory', 'sendEmail']
+ * ```
+ */
+declare function getWorkflowActivityNames<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]>(contract: TContract, workflowName: TWorkflowName): string[];
+/**
+ * Check if an activity belongs to a specific workflow
+ *
+ * @param contract - The contract definition
+ * @param workflowName - The name of the workflow
+ * @param activityName - The name of the activity to check
+ * @returns True if the activity is available for the workflow, false otherwise
+ *
+ * @example
+ * ```ts
+ * if (isWorkflowActivity(myContract, 'processOrder', 'processPayment')) {
+ *   // Activity is available for this workflow
+ * }
+ * ```
+ */
+declare function isWorkflowActivity<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]>(contract: TContract, workflowName: TWorkflowName, activityName: string): boolean;
+/**
+ * Get all workflow names from a contract
+ *
+ * @param contract - The contract definition
+ * @returns Array of workflow names defined in the contract
+ *
+ * @example
+ * ```ts
+ * const workflows = getWorkflowNames(myContract);
+ * // Returns: ['processOrder', 'processRefund']
+ * ```
+ */
+declare function getWorkflowNames<TContract extends ContractDefinition>(contract: TContract): Array<keyof TContract["workflows"]>;
+//#endregion
+export { isWorkflowActivity as i, getWorkflowActivityNames as n, getWorkflowNames as r, getWorkflowActivities as t };
+//# sourceMappingURL=activity-utils-B3vP03_P.d.mts.map

package/dist/activity-utils-B3vP03_P.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-utils-B3vP03_P.d.mts","names":[],"sources":["../src/activity-utils.ts"],"mappings":";;;;;AAqBA;;;;;;;;;;;;;;;;iBAAgB,qBAAA,mBACI,kBAAA,8BACU,SAAA,cAAA,CAC5B,QAAA,EAAU,SAAA,EAAW,YAAA,EAAc,aAAA,GAAgB,MAAA,SAAe,kBAAA;;;;;;;AA2BpE;;;;;;;iBAAgB,wBAAA,mBACI,kBAAA,8BACU,SAAA,cAAA,CAC5B,QAAA,EAAU,SAAA,EAAW,YAAA,EAAc,aAAA;;;;;;;;;;;;AAoBrC;;;;iBAAgB,kBAAA,mBACI,kBAAA,8BACU,SAAA,cAAA,CAC5B,QAAA,EAAU,SAAA,EAAW,YAAA,EAAc,aAAA,EAAe,YAAA;;;;;;;;;;;;;iBAiBpC,gBAAA,mBAAmC,kBAAA,CAAA,CACjD,QAAA,EAAU,SAAA,GACT,KAAA,OAAY,SAAA"}

package/dist/activity-utils-RsXOceIH.d.cts

@@ -0,0 +1,68 @@
+import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
+
+//#region src/activity-utils.d.ts
+/**
+ * Extract activity definitions for a specific workflow from a contract
+ *
+ * This includes both:
+ * - Workflow-specific activities defined under workflow.activities
+ * - Global activities defined under contract.activities
+ *
+ * @param contract - The contract definition
+ * @param workflowName - The name of the workflow
+ * @returns Activity definitions for the workflow (workflow-specific + global activities merged)
+ *
+ * @example
+ * ```ts
+ * const orderWorkflowActivities = getWorkflowActivities(myContract, 'processOrder');
+ * // Returns: { processPayment: ActivityDef, reserveInventory: ActivityDef, sendEmail: ActivityDef }
+ * // where sendEmail is a global activity
+ * ```
+ */
+declare function getWorkflowActivities<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]>(contract: TContract, workflowName: TWorkflowName): Record<string, ActivityDefinition>;
+/**
+ * Extract all activity names for a specific workflow from a contract
+ *
+ * @param contract - The contract definition
+ * @param workflowName - The name of the workflow
+ * @returns Array of activity names (strings) available for the workflow
+ *
+ * @example
+ * ```ts
+ * const activityNames = getWorkflowActivityNames(myContract, 'processOrder');
+ * // Returns: ['processPayment', 'reserveInventory', 'sendEmail']
+ * ```
+ */
+declare function getWorkflowActivityNames<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]>(contract: TContract, workflowName: TWorkflowName): string[];
+/**
+ * Check if an activity belongs to a specific workflow
+ *
+ * @param contract - The contract definition
+ * @param workflowName - The name of the workflow
+ * @param activityName - The name of the activity to check
+ * @returns True if the activity is available for the workflow, false otherwise
+ *
+ * @example
+ * ```ts
+ * if (isWorkflowActivity(myContract, 'processOrder', 'processPayment')) {
+ *   // Activity is available for this workflow
+ * }
+ * ```
+ */
+declare function isWorkflowActivity<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]>(contract: TContract, workflowName: TWorkflowName, activityName: string): boolean;
+/**
+ * Get all workflow names from a contract
+ *
+ * @param contract - The contract definition
+ * @returns Array of workflow names defined in the contract
+ *
+ * @example
+ * ```ts
+ * const workflows = getWorkflowNames(myContract);
+ * // Returns: ['processOrder', 'processRefund']
+ * ```
+ */
+declare function getWorkflowNames<TContract extends ContractDefinition>(contract: TContract): Array<keyof TContract["workflows"]>;
+//#endregion
+export { isWorkflowActivity as i, getWorkflowActivityNames as n, getWorkflowNames as r, getWorkflowActivities as t };
+//# sourceMappingURL=activity-utils-RsXOceIH.d.cts.map

package/dist/activity-utils-RsXOceIH.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-utils-RsXOceIH.d.cts","names":[],"sources":["../src/activity-utils.ts"],"mappings":";;;;;AAqBA;;;;;;;;;;;;;;;;iBAAgB,qBAAA,mBACI,kBAAA,8BACU,SAAA,cAAA,CAC5B,QAAA,EAAU,SAAA,EAAW,YAAA,EAAc,aAAA,GAAgB,MAAA,SAAe,kBAAA;;;;;;;AA2BpE;;;;;;;iBAAgB,wBAAA,mBACI,kBAAA,8BACU,SAAA,cAAA,CAC5B,QAAA,EAAU,SAAA,EAAW,YAAA,EAAc,aAAA;;;;;;;;;;;;AAoBrC;;;;iBAAgB,kBAAA,mBACI,kBAAA,8BACU,SAAA,cAAA,CAC5B,QAAA,EAAU,SAAA,EAAW,YAAA,EAAc,aAAA,EAAe,YAAA;;;;;;;;;;;;;iBAiBpC,gBAAA,mBAAmC,kBAAA,CAAA,CACjD,QAAA,EAAU,SAAA,GACT,KAAA,OAAY,SAAA"}

package/dist/activity.cjs

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_errors = require('./errors-DjSZg-93.cjs');
 
 //#region src/activity-utils.ts

package/dist/activity.d.cts

@@ -1,3 +1,99 @@
-import { n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-BqYWpdvd.cjs";
-import { a as getWorkflowActivityNames, i as getWorkflowActivities, n as ActivityError, o as getWorkflowNames, r as declareActivitiesHandler, s as isWorkflowActivity, t as ActivitiesHandler } from "./activity-Csptpwgf.cjs";
-export { ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler, getWorkflowActivities, getWorkflowActivityNames, getWorkflowNames, isWorkflowActivity };
+import { g as WorkerInferOutput, h as WorkerInferInput, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-4jH78z8m.cjs";
+import { i as isWorkflowActivity, n as getWorkflowActivityNames, r as getWorkflowNames, t as getWorkflowActivities } from "./activity-utils-RsXOceIH.cjs";
+import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
+import { Future, Result } from "@swan-io/boxed";
+
+//#region src/activity.d.ts
+/**
+ * Activity error class that should be used to wrap all technical exceptions
+ * Forces proper error handling and enables retry policies
+ */
+declare class ActivityError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string, cause?: unknown);
+}
+/**
+ * Activity implementation using Future/Result pattern
+ *
+ * Returns Future<Result<Output, ActivityError>> for explicit error handling instead of throwing exceptions.
+ * All errors must be wrapped in ActivityError to enable proper retry policies.
+ */
+type BoxedActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Future<Result<WorkerInferOutput<TActivity>, ActivityError>>;
+/**
+ * Map of all activity implementations for a contract (global + all workflow-specific)
+ */
+type ContractBoxedActivitiesImplementations<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? BoxedActivitiesImplementations<TContract["activities"]> : {}) & { [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? BoxedActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} };
+type BoxedActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: BoxedActivityImplementation<TActivities[K]> };
+/**
+ * Options for creating activities handler
+ */
+type DeclareActivitiesHandlerOptions<TContract extends ContractDefinition> = {
+  contract: TContract;
+  activities: ContractBoxedActivitiesImplementations<TContract>;
+};
+type ActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Promise<WorkerInferOutput<TActivity>>;
+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
+ *
+ * Flat structure: all activities (global + all workflow-specific) are at the root level
+ */
+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"]]>;
+/**
+ * Create a typed activities handler with automatic validation and Result pattern
+ *
+ * This wraps all activity implementations with:
+ * - Validation at network boundaries
+ * - Result<T, ActivityError> pattern for explicit error handling
+ * - Automatic conversion from Result to Promise (throwing on Error)
+ *
+ * TypeScript ensures ALL activities (global + workflow-specific) are implemented.
+ *
+ * Use this to create the activities object for the Temporal Worker.
+ *
+ * @example
+ * ```ts
+ * import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
+ * import { Result, Future } from '@swan-io/boxed';
+ * import myContract from './contract';
+ *
+ * export const activities = declareActivitiesHandler({
+ *   contract: myContract,
+ *   activities: {
+ *     // Activity returns Result instead of throwing
+ *     // All technical exceptions must be wrapped in ActivityError for retry policies
+ *     sendEmail: (args) => {
+ *       return Future.make(async resolve => {
+ *         try {
+ *           await emailService.send(args);
+ *           resolve(Result.Ok({ sent: true }));
+ *         } catch (error) {
+ *           // Wrap technical errors in ActivityError to enable retries
+ *           resolve(Result.Error(
+ *             new ActivityError(
+ *               'EMAIL_SEND_FAILED',
+ *               'Failed to send email',
+ *               error // Original error as cause for debugging
+ *             )
+ *           ));
+ *         }
+ *       });
+ *     },
+ *   },
+ * });
+ *
+ * // Use with Temporal Worker
+ * import { Worker } from '@temporalio/worker';
+ *
+ * const worker = await Worker.create({
+ *   workflowsPath: require.resolve('./workflows'),
+ *   activities: activities,
+ *   taskQueue: contract.taskQueue,
+ * });
+ * ```
+ */
+declare function declareActivitiesHandler<TContract extends ContractDefinition>(options: DeclareActivitiesHandlerOptions<TContract>): ActivitiesHandler<TContract>;
+//#endregion
+export { ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler, getWorkflowActivities, getWorkflowActivityNames, getWorkflowNames, isWorkflowActivity };
+//# sourceMappingURL=activity.d.cts.map

package/dist/activity.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.d.cts","names":[],"sources":["../src/activity.ts"],"mappings":";;;;;;;AA2BA;;;cAAa,aAAA,SAAsB,KAAA;EAAA,SAEf,IAAA;cAAA,IAAA,UAChB,OAAA,UACA,KAAA;AAAA;;;;;;AASH;KAQI,2BAAA,mBAA8C,kBAAA,KACjD,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,MAAA,CAAO,MAAA,CAAO,iBAAA,CAAkB,SAAA,GAAY,aAAA;;;;KAK5C,sCAAA,mBAAyD,kBAAA,KAE3D,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,8BAAA,CAA+B,SAAA,8CAIX,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,8BAAA,CAA+B,SAAA,cAAuB,SAAA;AAAA,KAI3D,8BAAA,qBAAmD,MAAA,SAAe,kBAAA,mBACzD,WAAA,GAAc,2BAAA,CAA4B,WAAA,CAAY,CAAA;;;;KAM/D,+BAAA,mBAAkD,kBAAA;EACrD,QAAA,EAAU,SAAA;EACV,UAAA,EAAY,sCAAA,CAAuC,SAAA;AAAA;AAAA,KAGhD,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;;;AA3C0D;;;KAmDlD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAjD2D;;;;;;;;;;;;;;;;;;;;;AAKJ;iBAoGrD,wBAAA,mBAA2C,kBAAA,CAAA,CACzD,OAAA,EAAS,+BAAA,CAAgC,SAAA,IACxC,iBAAA,CAAkB,SAAA"}

package/dist/activity.d.mts

@@ -1,3 +1,99 @@
-import { n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-C1RFkCuD.mjs";
-import { a as getWorkflowActivityNames, i as getWorkflowActivities, n as ActivityError, o as getWorkflowNames, r as declareActivitiesHandler, s as isWorkflowActivity, t as ActivitiesHandler } from "./activity-UOnp_bSX.mjs";
-export { ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler, getWorkflowActivities, getWorkflowActivityNames, getWorkflowNames, isWorkflowActivity };
+import { g as WorkerInferOutput, h as WorkerInferInput, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-CmTXZ3JW.mjs";
+import { i as isWorkflowActivity, n as getWorkflowActivityNames, r as getWorkflowNames, t as getWorkflowActivities } from "./activity-utils-B3vP03_P.mjs";
+import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
+import { Future, Result } from "@swan-io/boxed";
+
+//#region src/activity.d.ts
+/**
+ * Activity error class that should be used to wrap all technical exceptions
+ * Forces proper error handling and enables retry policies
+ */
+declare class ActivityError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string, cause?: unknown);
+}
+/**
+ * Activity implementation using Future/Result pattern
+ *
+ * Returns Future<Result<Output, ActivityError>> for explicit error handling instead of throwing exceptions.
+ * All errors must be wrapped in ActivityError to enable proper retry policies.
+ */
+type BoxedActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Future<Result<WorkerInferOutput<TActivity>, ActivityError>>;
+/**
+ * Map of all activity implementations for a contract (global + all workflow-specific)
+ */
+type ContractBoxedActivitiesImplementations<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? BoxedActivitiesImplementations<TContract["activities"]> : {}) & { [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? BoxedActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} };
+type BoxedActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: BoxedActivityImplementation<TActivities[K]> };
+/**
+ * Options for creating activities handler
+ */
+type DeclareActivitiesHandlerOptions<TContract extends ContractDefinition> = {
+  contract: TContract;
+  activities: ContractBoxedActivitiesImplementations<TContract>;
+};
+type ActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Promise<WorkerInferOutput<TActivity>>;
+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
+ *
+ * Flat structure: all activities (global + all workflow-specific) are at the root level
+ */
+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"]]>;
+/**
+ * Create a typed activities handler with automatic validation and Result pattern
+ *
+ * This wraps all activity implementations with:
+ * - Validation at network boundaries
+ * - Result<T, ActivityError> pattern for explicit error handling
+ * - Automatic conversion from Result to Promise (throwing on Error)
+ *
+ * TypeScript ensures ALL activities (global + workflow-specific) are implemented.
+ *
+ * Use this to create the activities object for the Temporal Worker.
+ *
+ * @example
+ * ```ts
+ * import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
+ * import { Result, Future } from '@swan-io/boxed';
+ * import myContract from './contract';
+ *
+ * export const activities = declareActivitiesHandler({
+ *   contract: myContract,
+ *   activities: {
+ *     // Activity returns Result instead of throwing
+ *     // All technical exceptions must be wrapped in ActivityError for retry policies
+ *     sendEmail: (args) => {
+ *       return Future.make(async resolve => {
+ *         try {
+ *           await emailService.send(args);
+ *           resolve(Result.Ok({ sent: true }));
+ *         } catch (error) {
+ *           // Wrap technical errors in ActivityError to enable retries
+ *           resolve(Result.Error(
+ *             new ActivityError(
+ *               'EMAIL_SEND_FAILED',
+ *               'Failed to send email',
+ *               error // Original error as cause for debugging
+ *             )
+ *           ));
+ *         }
+ *       });
+ *     },
+ *   },
+ * });
+ *
+ * // Use with Temporal Worker
+ * import { Worker } from '@temporalio/worker';
+ *
+ * const worker = await Worker.create({
+ *   workflowsPath: require.resolve('./workflows'),
+ *   activities: activities,
+ *   taskQueue: contract.taskQueue,
+ * });
+ * ```
+ */
+declare function declareActivitiesHandler<TContract extends ContractDefinition>(options: DeclareActivitiesHandlerOptions<TContract>): ActivitiesHandler<TContract>;
+//#endregion
+export { ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler, getWorkflowActivities, getWorkflowActivityNames, getWorkflowNames, isWorkflowActivity };
+//# sourceMappingURL=activity.d.mts.map

package/dist/activity.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.d.mts","names":[],"sources":["../src/activity.ts"],"mappings":";;;;;;;AA2BA;;;cAAa,aAAA,SAAsB,KAAA;EAAA,SAEf,IAAA;cAAA,IAAA,UAChB,OAAA,UACA,KAAA;AAAA;;;;;;AASH;KAQI,2BAAA,mBAA8C,kBAAA,KACjD,IAAA,EAAM,gBAAA,CAAiB,SAAA,MACpB,MAAA,CAAO,MAAA,CAAO,iBAAA,CAAkB,SAAA,GAAY,aAAA;;;;KAK5C,sCAAA,mBAAyD,kBAAA,KAE3D,SAAA,uBAAgC,MAAA,SAAe,kBAAA,IAC5C,8BAAA,CAA+B,SAAA,8CAIX,SAAA,gBAAyB,SAAA,cAAuB,SAAA,wBAAiC,MAAA,SAEnG,kBAAA,IAEE,8BAAA,CAA+B,SAAA,cAAuB,SAAA;AAAA,KAI3D,8BAAA,qBAAmD,MAAA,SAAe,kBAAA,mBACzD,WAAA,GAAc,2BAAA,CAA4B,WAAA,CAAY,CAAA;;;;KAM/D,+BAAA,mBAAkD,kBAAA;EACrD,QAAA,EAAU,SAAA;EACV,UAAA,EAAY,sCAAA,CAAuC,SAAA;AAAA;AAAA,KAGhD,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;;;AA3C0D;;;KAmDlD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAjD2D;;;;;;;;;;;;;;;;;;;;;AAKJ;iBAoGrD,wBAAA,mBAA2C,kBAAA,CAAA,CACzD,OAAA,EAAS,+BAAA,CAAgC,SAAA,IACxC,iBAAA,CAAkB,SAAA"}

package/dist/activity.mjs

@@ -1,4 +1,4 @@
-import { n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-BqVTpfcf.mjs";
+import { n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-Di6Ja4Rt.mjs";
 
 //#region src/activity-utils.ts
 /**
@@ -180,4 +180,5 @@ function declareActivitiesHandler(options) {
 }
 
 //#endregion
-export { ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler, getWorkflowActivities, getWorkflowActivityNames, getWorkflowNames, isWorkflowActivity };
+export { ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler, getWorkflowActivities, getWorkflowActivityNames, getWorkflowNames, isWorkflowActivity };
+//# sourceMappingURL=activity.mjs.map

package/dist/activity.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.mjs","names":[],"sources":["../src/activity-utils.ts","../src/activity.ts"],"sourcesContent":["// Helper utilities for working with activities\nimport { ActivityDefinition, ContractDefinition } from \"@temporal-contract/contract\";\n\n/**\n * Extract activity definitions for a specific workflow from a contract\n *\n * This includes both:\n * - Workflow-specific activities defined under workflow.activities\n * - Global activities defined under contract.activities\n *\n * @param contract - The contract definition\n * @param workflowName - The name of the workflow\n * @returns Activity definitions for the workflow (workflow-specific + global activities merged)\n *\n * @example\n * ```ts\n * const orderWorkflowActivities = getWorkflowActivities(myContract, 'processOrder');\n * // Returns: { processPayment: ActivityDef, reserveInventory: ActivityDef, sendEmail: ActivityDef }\n * // where sendEmail is a global activity\n * ```\n */\nexport function getWorkflowActivities<\n  TContract extends ContractDefinition,\n  TWorkflowName extends keyof TContract[\"workflows\"],\n>(contract: TContract, workflowName: TWorkflowName): Record<string, ActivityDefinition> {\n  const workflowDef = contract.workflows[workflowName as string];\n  const workflowActivities =\n    (workflowDef as { activities?: Record<string, ActivityDefinition> })?.activities || {};\n  const globalActivities = contract.activities || {};\n\n  // Merge global and workflow-specific activities\n  // Workflow-specific activities take precedence over global ones with the same name\n  return {\n    ...globalActivities,\n    ...workflowActivities,\n  };\n}\n\n/**\n * Extract all activity names for a specific workflow from a contract\n *\n * @param contract - The contract definition\n * @param workflowName - The name of the workflow\n * @returns Array of activity names (strings) available for the workflow\n *\n * @example\n * ```ts\n * const activityNames = getWorkflowActivityNames(myContract, 'processOrder');\n * // Returns: ['processPayment', 'reserveInventory', 'sendEmail']\n * ```\n */\nexport function getWorkflowActivityNames<\n  TContract extends ContractDefinition,\n  TWorkflowName extends keyof TContract[\"workflows\"],\n>(contract: TContract, workflowName: TWorkflowName): string[] {\n  const activities = getWorkflowActivities(contract, workflowName);\n  return Object.keys(activities);\n}\n\n/**\n * Check if an activity belongs to a specific workflow\n *\n * @param contract - The contract definition\n * @param workflowName - The name of the workflow\n * @param activityName - The name of the activity to check\n * @returns True if the activity is available for the workflow, false otherwise\n *\n * @example\n * ```ts\n * if (isWorkflowActivity(myContract, 'processOrder', 'processPayment')) {\n *   // Activity is available for this workflow\n * }\n * ```\n */\nexport function isWorkflowActivity<\n  TContract extends ContractDefinition,\n  TWorkflowName extends keyof TContract[\"workflows\"],\n>(contract: TContract, workflowName: TWorkflowName, activityName: string): boolean {\n  const activities = getWorkflowActivities(contract, workflowName);\n  return activityName in activities;\n}\n\n/**\n * Get all workflow names from a contract\n *\n * @param contract - The contract definition\n * @returns Array of workflow names defined in the contract\n *\n * @example\n * ```ts\n * const workflows = getWorkflowNames(myContract);\n * // Returns: ['processOrder', 'processRefund']\n * ```\n */\nexport function getWorkflowNames<TContract extends ContractDefinition>(\n  contract: TContract,\n): Array<keyof TContract[\"workflows\"]> {\n  return Object.keys(contract.workflows) as Array<keyof TContract[\"workflows\"]>;\n}\n","// Entry point for activities\nimport { ActivityDefinition, ContractDefinition } from \"@temporal-contract/contract\";\nimport { Future, Result } from \"@swan-io/boxed\";\nimport { WorkerInferInput, WorkerInferOutput } from \"./types.js\";\nimport {\n  ActivityDefinitionNotFoundError,\n  ActivityInputValidationError,\n  ActivityOutputValidationError,\n} from \"./errors.js\";\n\nexport {\n  ActivityDefinitionNotFoundError,\n  ActivityInputValidationError,\n  ActivityOutputValidationError,\n} from \"./errors.js\";\n\nexport {\n  getWorkflowActivities,\n  getWorkflowActivityNames,\n  isWorkflowActivity,\n  getWorkflowNames,\n} from \"./activity-utils.js\";\n\n/**\n * Activity error class that should be used to wrap all technical exceptions\n * Forces proper error handling and enables retry policies\n */\nexport class ActivityError extends Error {\n  constructor(\n    public readonly code: string,\n    message: string,\n    cause?: unknown,\n  ) {\n    super(message, { cause });\n    this.name = \"ActivityError\";\n    // Maintains proper stack trace for where our error was thrown (only available on V8)\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, ActivityError);\n    }\n  }\n}\n\n/**\n * Activity implementation using Future/Result pattern\n *\n * Returns Future<Result<Output, ActivityError>> for explicit error handling instead of throwing exceptions.\n * All errors must be wrapped in ActivityError to enable proper retry policies.\n */\ntype BoxedActivityImplementation<TActivity extends ActivityDefinition> = (\n  args: WorkerInferInput<TActivity>,\n) => Future<Result<WorkerInferOutput<TActivity>, ActivityError>>;\n\n/**\n * Map of all activity implementations for a contract (global + all workflow-specific)\n */\ntype ContractBoxedActivitiesImplementations<TContract extends ContractDefinition> =\n  // Global activities\n  (TContract[\"activities\"] extends Record<string, ActivityDefinition>\n    ? BoxedActivitiesImplementations<TContract[\"activities\"]>\n    : {}) &\n    // All workflow-specific activities merged\n    {\n      [TWorkflow in keyof TContract[\"workflows\"]]: TContract[\"workflows\"][TWorkflow][\"activities\"] extends Record<\n        string,\n        ActivityDefinition\n      >\n        ? BoxedActivitiesImplementations<TContract[\"workflows\"][TWorkflow][\"activities\"]>\n        : {};\n    };\n\ntype BoxedActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = {\n  [K in keyof TActivities]: BoxedActivityImplementation<TActivities[K]>;\n};\n\n/**\n * Options for creating activities handler\n */\ntype DeclareActivitiesHandlerOptions<TContract extends ContractDefinition> = {\n  contract: TContract;\n  activities: ContractBoxedActivitiesImplementations<TContract>;\n};\n\ntype ActivityImplementation<TActivity extends ActivityDefinition> = (\n  args: WorkerInferInput<TActivity>,\n) => Promise<WorkerInferOutput<TActivity>>;\n\ntype ActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = {\n  [K in keyof TActivities]: ActivityImplementation<TActivities[K]>;\n};\n\ntype UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (\n  k: infer I,\n) => void\n  ? I\n  : never;\n\n/**\n * Activities handler ready for Temporal Worker\n *\n * Flat structure: all activities (global + all workflow-specific) are at the root level\n */\nexport type ActivitiesHandler<TContract extends ContractDefinition> =\n  // Global activities\n  (TContract[\"activities\"] extends Record<string, ActivityDefinition>\n    ? ActivitiesImplementations<TContract[\"activities\"]>\n    : {}) &\n    // All workflow-specific activities merged at root level (flat)\n    UnionToIntersection<\n      {\n        [TWorkflow in keyof TContract[\"workflows\"]]: TContract[\"workflows\"][TWorkflow][\"activities\"] extends Record<\n          string,\n          ActivityDefinition\n        >\n          ? ActivitiesImplementations<TContract[\"workflows\"][TWorkflow][\"activities\"]>\n          : {};\n      }[keyof TContract[\"workflows\"]]\n    >;\n\n/**\n * Create a typed activities handler with automatic validation and Result pattern\n *\n * This wraps all activity implementations with:\n * - Validation at network boundaries\n * - Result<T, ActivityError> 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, ActivityError } from '@temporal-contract/worker/activity';\n * import { Result, Future } from '@swan-io/boxed';\n * import myContract from './contract';\n *\n * export const activities = declareActivitiesHandler({\n *   contract: myContract,\n *   activities: {\n *     // Activity returns Result instead of throwing\n *     // All technical exceptions must be wrapped in ActivityError for retry policies\n *     sendEmail: (args) => {\n *       return Future.make(async resolve => {\n *         try {\n *           await emailService.send(args);\n *           resolve(Result.Ok({ sent: true }));\n *         } catch (error) {\n *           // Wrap technical errors in ActivityError to enable retries\n *           resolve(Result.Error(\n *             new ActivityError(\n *               'EMAIL_SEND_FAILED',\n *               'Failed to send email',\n *               error // Original error as cause for debugging\n *             )\n *           ));\n *         }\n *       });\n *     },\n *   },\n * });\n *\n * // Use with Temporal Worker\n * import { Worker } from '@temporalio/worker';\n *\n * const worker = await Worker.create({\n *   workflowsPath: require.resolve('./workflows'),\n *   activities: activities,\n *   taskQueue: contract.taskQueue,\n * });\n * ```\n */\nexport function declareActivitiesHandler<TContract extends ContractDefinition>(\n  options: DeclareActivitiesHandlerOptions<TContract>,\n): ActivitiesHandler<TContract> {\n  const { contract, activities } = options;\n\n  // Prepare Temporal-compatible activities with validation and Result unwrapping\n  const wrappedActivities = {} as ActivitiesHandler<TContract>;\n\n  // Helper to create a wrapped implementation from a definition and impl\n  function makeWrapped(\n    activityName: string,\n    activityDef: ActivityDefinition,\n    activityImpl: (args: unknown) => Future<Result<unknown, ActivityError>>,\n  ) {\n    return async (...args: unknown[]) => {\n      // Extract single parameter (Temporal passes arguments as an array)\n      const input = args.length === 1 ? args[0] : args;\n\n      // Validate input\n      const inputResult = await activityDef.input[\"~standard\"].validate(input);\n      if (inputResult.issues) {\n        throw new ActivityInputValidationError(activityName, inputResult.issues);\n      }\n\n      // Execute boxed activity (returns Future<Result<T, ActivityError>>)\n      const futureResult = activityImpl(inputResult.value);\n\n      // Await Future and unwrap Result\n      const result = await futureResult;\n\n      // Process result: validate output or throw error\n      if (result.isOk()) {\n        // Validate output on success\n        const outputResult = await activityDef.output[\"~standard\"].validate(result.value);\n        if (outputResult.issues) {\n          throw new ActivityOutputValidationError(activityName, outputResult.issues);\n        }\n        return outputResult.value;\n      } else {\n        // Convert Result.Error to thrown ActivityError for Temporal\n        throw result.error;\n      }\n    };\n  }\n\n  // 1) Wrap global activities defined directly under contract.activities\n  if (contract.activities) {\n    for (const [activityName, impl] of Object.entries(activities)) {\n      // Skip workflow namespaces if present at root\n      if (contract.workflows && activityName in contract.workflows) {\n        continue;\n      }\n\n      const activityDef = contract.activities[activityName];\n      if (!activityDef) {\n        throw new ActivityDefinitionNotFoundError(activityName, Object.keys(contract.activities));\n      }\n\n      // Assign wrapped global activity\n      (wrappedActivities as Record<string, unknown>)[activityName] = makeWrapped(\n        activityName,\n        activityDef,\n        impl as (args: unknown) => Future<Result<unknown, ActivityError>>,\n      );\n    }\n  }\n\n  // 2) Wrap workflow-scoped activities at root level (flat)\n  if (contract.workflows) {\n    for (const [workflowName, workflowDef] of Object.entries(contract.workflows)) {\n      const wfActivitiesImpl = (activities as Record<string, unknown>)[workflowName] as\n        | Record<string, unknown>\n        | undefined;\n      if (!wfActivitiesImpl) {\n        // If no implementations provided for this workflow, skip (TypeScript typing should enforce completeness for declared ones)\n        continue;\n      }\n\n      const wfDefs = workflowDef.activities ?? {};\n\n      for (const [activityName, impl] of Object.entries(wfActivitiesImpl)) {\n        const activityDef = wfDefs[activityName];\n        if (!activityDef) {\n          throw new ActivityDefinitionNotFoundError(\n            `${workflowName}.${activityName}`,\n            Object.keys(wfDefs),\n          );\n        }\n\n        // Assign workflow activity directly at root level (flat structure)\n        (wrappedActivities as Record<string, unknown>)[activityName] = makeWrapped(\n          `${workflowName}.${activityName}`,\n          activityDef,\n          impl as (args: unknown) => Future<Result<unknown, ActivityError>>,\n        );\n      }\n    }\n  }\n\n  return wrappedActivities;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,sBAGd,UAAqB,cAAiE;CAEtF,MAAM,qBADc,SAAS,UAAU,eAEiC,cAAc,EAAE;AAKxF,QAAO;EACL,GALuB,SAAS,cAAc,EAAE;EAMhD,GAAG;EACJ;;;;;;;;;;;;;;;AAgBH,SAAgB,yBAGd,UAAqB,cAAuC;CAC5D,MAAM,aAAa,sBAAsB,UAAU,aAAa;AAChE,QAAO,OAAO,KAAK,WAAW;;;;;;;;;;;;;;;;;AAkBhC,SAAgB,mBAGd,UAAqB,cAA6B,cAA+B;AAEjF,QAAO,gBADY,sBAAsB,UAAU,aAAa;;;;;;;;;;;;;;AAgBlE,SAAgB,iBACd,UACqC;AACrC,QAAO,OAAO,KAAK,SAAS,UAAU;;;;;;;;;ACtExC,IAAa,gBAAb,MAAa,sBAAsB,MAAM;CACvC,YACE,AAAgB,MAChB,SACA,OACA;AACA,QAAM,SAAS,EAAE,OAAO,CAAC;EAJT;AAKhB,OAAK,OAAO;AAEZ,MAAI,MAAM,kBACR,OAAM,kBAAkB,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsIlD,SAAgB,yBACd,SAC8B;CAC9B,MAAM,EAAE,UAAU,eAAe;CAGjC,MAAM,oBAAoB,EAAE;CAG5B,SAAS,YACP,cACA,aACA,cACA;AACA,SAAO,OAAO,GAAG,SAAoB;GAEnC,MAAM,QAAQ,KAAK,WAAW,IAAI,KAAK,KAAK;GAG5C,MAAM,cAAc,MAAM,YAAY,MAAM,aAAa,SAAS,MAAM;AACxE,OAAI,YAAY,OACd,OAAM,IAAI,6BAA6B,cAAc,YAAY,OAAO;GAO1E,MAAM,SAAS,MAHM,aAAa,YAAY,MAAM;AAMpD,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;SAGpB,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;AAI3F,EAAC,kBAA8C,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;AAIH,GAAC,kBAA8C,gBAAgB,YAC7D,GAAG,aAAa,GAAG,gBACnB,aACA,KACD;;;AAKP,QAAO"}

package/dist/{errors-C1RFkCuD.d.mts → errors-4jH78z8m.d.cts}

@@ -2,7 +2,6 @@ import { AnySchema } from "@temporal-contract/contract";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
 //#region src/types.d.ts
-
 /**
  * Infer input type from a definition (worker perspective)
  * Worker receives the output type (after input schema parsing/transformation)
@@ -134,4 +133,5 @@ declare class ChildWorkflowError extends WorkerError {
   constructor(message: string, cause?: unknown);
 }
 //#endregion
-export { ChildWorkflowNotFoundError as a, SignalInputValidationError as c, WorkflowInputValidationError as d, WorkflowOutputValidationError as f, WorkerInferOutput as g, WorkerInferInput as h, ChildWorkflowError as i, UpdateInputValidationError as l, ClientInferOutput as m, ActivityInputValidationError as n, QueryInputValidationError as o, ClientInferInput as p, ActivityOutputValidationError as r, QueryOutputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateOutputValidationError as u };
+export { ChildWorkflowNotFoundError as a, SignalInputValidationError as c, WorkflowInputValidationError as d, WorkflowOutputValidationError as f, WorkerInferOutput as g, WorkerInferInput as h, ChildWorkflowError as i, UpdateInputValidationError as l, ClientInferOutput as m, ActivityInputValidationError as n, QueryInputValidationError as o, ClientInferInput as p, ActivityOutputValidationError as r, QueryOutputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateOutputValidationError as u };
+//# sourceMappingURL=errors-4jH78z8m.d.cts.map

package/dist/errors-4jH78z8m.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-4jH78z8m.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;;;;;;uBC3Ba,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;AA1HG;;;AAAA,cAqIjD,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"}

package/dist/{errors-BqYWpdvd.d.cts → errors-CmTXZ3JW.d.mts}

@@ -2,7 +2,6 @@ import { AnySchema } from "@temporal-contract/contract";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
 //#region src/types.d.ts
-
 /**
  * Infer input type from a definition (worker perspective)
  * Worker receives the output type (after input schema parsing/transformation)
@@ -134,4 +133,5 @@ declare class ChildWorkflowError extends WorkerError {
   constructor(message: string, cause?: unknown);
 }
 //#endregion
-export { ChildWorkflowNotFoundError as a, SignalInputValidationError as c, WorkflowInputValidationError as d, WorkflowOutputValidationError as f, WorkerInferOutput as g, WorkerInferInput as h, ChildWorkflowError as i, UpdateInputValidationError as l, ClientInferOutput as m, ActivityInputValidationError as n, QueryInputValidationError as o, ClientInferInput as p, ActivityOutputValidationError as r, QueryOutputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateOutputValidationError as u };
+export { ChildWorkflowNotFoundError as a, SignalInputValidationError as c, WorkflowInputValidationError as d, WorkflowOutputValidationError as f, WorkerInferOutput as g, WorkerInferInput as h, ChildWorkflowError as i, UpdateInputValidationError as l, ClientInferOutput as m, ActivityInputValidationError as n, QueryInputValidationError as o, ClientInferInput as p, ActivityOutputValidationError as r, QueryOutputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateOutputValidationError as u };
+//# sourceMappingURL=errors-CmTXZ3JW.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors-CmTXZ3JW.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;;;;;;uBC3Ba,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;AA1HG;;;AAAA,cAqIjD,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"}

package/dist/{errors-BqVTpfcf.mjs → errors-Di6Ja4Rt.mjs}

@@ -152,4 +152,5 @@ var ChildWorkflowError = class extends WorkerError {
 };
 
 //#endregion
-export { ChildWorkflowNotFoundError as a, SignalInputValidationError as c, WorkflowInputValidationError as d, WorkflowOutputValidationError as f, ChildWorkflowError as i, UpdateInputValidationError as l, ActivityInputValidationError as n, QueryInputValidationError as o, ActivityOutputValidationError as r, QueryOutputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateOutputValidationError as u };
+export { ChildWorkflowNotFoundError as a, SignalInputValidationError as c, WorkflowInputValidationError as d, WorkflowOutputValidationError as f, ChildWorkflowError as i, UpdateInputValidationError as l, ActivityInputValidationError as n, QueryInputValidationError as o, ActivityOutputValidationError as r, QueryOutputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateOutputValidationError as u };
+//# sourceMappingURL=errors-Di6Ja4Rt.mjs.map