@temporal-contract/worker 0.0.6 → 0.1.0

package/README.md

@@ -14,43 +14,50 @@ 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!' });
+  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 +72,37 @@ 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,
-  implementation: async (context, input) => {
+  implementation: async ({ executeChildWorkflow }, input) => {
     // Execute child workflow from same contract and wait for result
-    const childResult = await context.executeChildWorkflow(myContract, 'processPayment', {
+    const childResult = await 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 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 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 +111,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-5pVNjW7l.d.cts

@@ -0,0 +1,161 @@
+import { g as WorkerInferOutput, h as WorkerInferInput } from "./errors-CXpHOFmk.cjs";
+import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
+import { Future, Result } from "@swan-io/boxed";
+
+//#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
+//#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
+ */
+interface 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 { getWorkflowActivityNames as a, getWorkflowActivities as i, ActivityError as n, getWorkflowNames as o, declareActivitiesHandler as r, isWorkflowActivity as s, ActivitiesHandler as t };

package/dist/activity-BUEBZ7SL.d.mts

@@ -0,0 +1,161 @@
+import { g as WorkerInferOutput, h as WorkerInferInput } from "./errors-Vr-sKdW7.mjs";
+import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
+import { Future, Result } from "@swan-io/boxed";
+
+//#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
+//#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
+ */
+interface 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 { getWorkflowActivityNames as a, getWorkflowActivities as i, ActivityError as n, getWorkflowNames as o, declareActivitiesHandler as r, isWorkflowActivity as s, ActivitiesHandler as t };

package/dist/activity.cjs

@@ -1,5 +1,83 @@
 const require_errors = require('./errors-DjSZg-93.cjs');
 
+//#region src/activity-utils.ts
+/**
+* Extract activity definitions for a specific workflow from a contract
+*
+* This includes both:
+* - Workflow-specific activities defined under workflow.activities
+* - Global activities defined under contract.activities
+*
+* @param contract - The contract definition
+* @param workflowName - The name of the workflow
+* @returns Activity definitions for the workflow (workflow-specific + global activities merged)
+*
+* @example
+* ```ts
+* const orderWorkflowActivities = getWorkflowActivities(myContract, 'processOrder');
+* // Returns: { processPayment: ActivityDef, reserveInventory: ActivityDef, sendEmail: ActivityDef }
+* // where sendEmail is a global activity
+* ```
+*/
+function getWorkflowActivities(contract, workflowName) {
+	const workflowActivities = contract.workflows[workflowName]?.activities || {};
+	return {
+		...contract.activities || {},
+		...workflowActivities
+	};
+}
+/**
+* Extract all activity names for a specific workflow from a contract
+*
+* @param contract - The contract definition
+* @param workflowName - The name of the workflow
+* @returns Array of activity names (strings) available for the workflow
+*
+* @example
+* ```ts
+* const activityNames = getWorkflowActivityNames(myContract, 'processOrder');
+* // Returns: ['processPayment', 'reserveInventory', 'sendEmail']
+* ```
+*/
+function getWorkflowActivityNames(contract, workflowName) {
+	const activities = getWorkflowActivities(contract, workflowName);
+	return Object.keys(activities);
+}
+/**
+* Check if an activity belongs to a specific workflow
+*
+* @param contract - The contract definition
+* @param workflowName - The name of the workflow
+* @param activityName - The name of the activity to check
+* @returns True if the activity is available for the workflow, false otherwise
+*
+* @example
+* ```ts
+* if (isWorkflowActivity(myContract, 'processOrder', 'processPayment')) {
+*   // Activity is available for this workflow
+* }
+* ```
+*/
+function isWorkflowActivity(contract, workflowName, activityName) {
+	return activityName in getWorkflowActivities(contract, workflowName);
+}
+/**
+* Get all workflow names from a contract
+*
+* @param contract - The contract definition
+* @returns Array of workflow names defined in the contract
+*
+* @example
+* ```ts
+* const workflows = getWorkflowNames(myContract);
+* // Returns: ['processOrder', 'processRefund']
+* ```
+*/
+function getWorkflowNames(contract) {
+	return Object.keys(contract.workflows);
+}
+
+//#endregion
 //#region src/activity.ts
 /**
 * Activity error class that should be used to wrap all technical exceptions
@@ -28,7 +106,7 @@ var ActivityError = class ActivityError extends Error {
 * @example
 * ```ts
 * import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
-* import { Result, Future } from '@temporal-contract/boxed';
+* import { Result, Future } from '@swan-io/boxed';
 * import myContract from './contract';
 *
 * export const activities = declareActivitiesHandler({
@@ -106,4 +184,8 @@ exports.ActivityDefinitionNotFoundError = require_errors.ActivityDefinitionNotFo
 exports.ActivityError = ActivityError;
 exports.ActivityInputValidationError = require_errors.ActivityInputValidationError;
 exports.ActivityOutputValidationError = require_errors.ActivityOutputValidationError;
-exports.declareActivitiesHandler = declareActivitiesHandler;
+exports.declareActivitiesHandler = declareActivitiesHandler;
+exports.getWorkflowActivities = getWorkflowActivities;
+exports.getWorkflowActivityNames = getWorkflowActivityNames;
+exports.getWorkflowNames = getWorkflowNames;
+exports.isWorkflowActivity = isWorkflowActivity;

package/dist/activity.d.cts

@@ -1,98 +1,3 @@
-import { g as WorkerInferOutput, h as WorkerInferInput, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-BqYWpdvd.cjs";
-import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
-import { Future, Result } from "@temporal-contract/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
- */
-interface 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 '@temporal-contract/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 };
+import { n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-CXpHOFmk.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-5pVNjW7l.cjs";
+export { ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler, getWorkflowActivities, getWorkflowActivityNames, getWorkflowNames, isWorkflowActivity };

package/dist/activity.d.mts

@@ -1,98 +1,3 @@
-import { g as WorkerInferOutput, h as WorkerInferInput, n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-C1RFkCuD.mjs";
-import { Future, Result } from "@temporal-contract/boxed";
-import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
-
-//#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
- */
-interface 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 '@temporal-contract/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 };
+import { n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-Vr-sKdW7.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-BUEBZ7SL.mjs";
+export { ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler, getWorkflowActivities, getWorkflowActivityNames, getWorkflowNames, isWorkflowActivity };

package/dist/activity.mjs

@@ -1,5 +1,83 @@
 import { n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-BqVTpfcf.mjs";
 
+//#region src/activity-utils.ts
+/**
+* Extract activity definitions for a specific workflow from a contract
+*
+* This includes both:
+* - Workflow-specific activities defined under workflow.activities
+* - Global activities defined under contract.activities
+*
+* @param contract - The contract definition
+* @param workflowName - The name of the workflow
+* @returns Activity definitions for the workflow (workflow-specific + global activities merged)
+*
+* @example
+* ```ts
+* const orderWorkflowActivities = getWorkflowActivities(myContract, 'processOrder');
+* // Returns: { processPayment: ActivityDef, reserveInventory: ActivityDef, sendEmail: ActivityDef }
+* // where sendEmail is a global activity
+* ```
+*/
+function getWorkflowActivities(contract, workflowName) {
+	const workflowActivities = contract.workflows[workflowName]?.activities || {};
+	return {
+		...contract.activities || {},
+		...workflowActivities
+	};
+}
+/**
+* Extract all activity names for a specific workflow from a contract
+*
+* @param contract - The contract definition
+* @param workflowName - The name of the workflow
+* @returns Array of activity names (strings) available for the workflow
+*
+* @example
+* ```ts
+* const activityNames = getWorkflowActivityNames(myContract, 'processOrder');
+* // Returns: ['processPayment', 'reserveInventory', 'sendEmail']
+* ```
+*/
+function getWorkflowActivityNames(contract, workflowName) {
+	const activities = getWorkflowActivities(contract, workflowName);
+	return Object.keys(activities);
+}
+/**
+* Check if an activity belongs to a specific workflow
+*
+* @param contract - The contract definition
+* @param workflowName - The name of the workflow
+* @param activityName - The name of the activity to check
+* @returns True if the activity is available for the workflow, false otherwise
+*
+* @example
+* ```ts
+* if (isWorkflowActivity(myContract, 'processOrder', 'processPayment')) {
+*   // Activity is available for this workflow
+* }
+* ```
+*/
+function isWorkflowActivity(contract, workflowName, activityName) {
+	return activityName in getWorkflowActivities(contract, workflowName);
+}
+/**
+* Get all workflow names from a contract
+*
+* @param contract - The contract definition
+* @returns Array of workflow names defined in the contract
+*
+* @example
+* ```ts
+* const workflows = getWorkflowNames(myContract);
+* // Returns: ['processOrder', 'processRefund']
+* ```
+*/
+function getWorkflowNames(contract) {
+	return Object.keys(contract.workflows);
+}
+
+//#endregion
 //#region src/activity.ts
 /**
 * Activity error class that should be used to wrap all technical exceptions
@@ -28,7 +106,7 @@ var ActivityError = class ActivityError extends Error {
 * @example
 * ```ts
 * import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
-* import { Result, Future } from '@temporal-contract/boxed';
+* import { Result, Future } from '@swan-io/boxed';
 * import myContract from './contract';
 *
 * export const activities = declareActivitiesHandler({
@@ -102,4 +180,4 @@ function declareActivitiesHandler(options) {
 }
 
 //#endregion
-export { ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler };
+export { ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler, getWorkflowActivities, getWorkflowActivityNames, getWorkflowNames, isWorkflowActivity };

package/dist/{errors-BqYWpdvd.d.cts → errors-CXpHOFmk.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)

package/dist/{errors-C1RFkCuD.d.mts → errors-Vr-sKdW7.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)

package/dist/worker.d.cts

@@ -1,9 +1,8 @@
-import { ActivitiesHandler } from "./activity.cjs";
+import { t as ActivitiesHandler } from "./activity-5pVNjW7l.cjs";
 import { ContractDefinition } from "@temporal-contract/contract";
 import { Worker, WorkerOptions } from "@temporalio/worker";
 
 //#region src/worker.d.ts
-
 /**
  * Options for creating a Temporal worker
  */

package/dist/worker.d.mts

@@ -1,9 +1,8 @@
-import { ActivitiesHandler } from "./activity.mjs";
+import { t as ActivitiesHandler } from "./activity-BUEBZ7SL.mjs";
 import { Worker, WorkerOptions } from "@temporalio/worker";
 import { ContractDefinition } from "@temporal-contract/contract";
 
 //#region src/worker.d.ts
-
 /**
  * Options for creating a Temporal worker
  */

package/dist/workflow.d.cts

@@ -1,10 +1,9 @@
-import { a as ChildWorkflowNotFoundError, c as SignalInputValidationError, d as WorkflowInputValidationError, f as WorkflowOutputValidationError, g as WorkerInferOutput, h as WorkerInferInput, i as ChildWorkflowError, l as UpdateInputValidationError, m as ClientInferOutput, n as ActivityInputValidationError, o as QueryInputValidationError, p as ClientInferInput, r as ActivityOutputValidationError, s as QueryOutputValidationError, u as UpdateOutputValidationError } from "./errors-BqYWpdvd.cjs";
+import { a as ChildWorkflowNotFoundError, c as SignalInputValidationError, d as WorkflowInputValidationError, f as WorkflowOutputValidationError, g as WorkerInferOutput, h as WorkerInferInput, i as ChildWorkflowError, l as UpdateInputValidationError, m as ClientInferOutput, n as ActivityInputValidationError, o as QueryInputValidationError, p as ClientInferInput, r as ActivityOutputValidationError, s as QueryOutputValidationError, u as UpdateOutputValidationError } from "./errors-CXpHOFmk.cjs";
 import { ActivityDefinition, ContractDefinition, QueryDefinition, SignalDefinition, UpdateDefinition, WorkflowDefinition } from "@temporal-contract/contract";
 import { Future, Result } from "@temporal-contract/boxed";
 import { ActivityOptions, ChildWorkflowOptions, WorkflowInfo } from "@temporalio/workflow";
 
 //#region src/workflow.d.ts
-
 /**
  * Create a typed workflow implementation with automatic validation
  *
@@ -158,7 +157,7 @@ interface WorkflowContext<TContract extends ContractDefinition, TWorkflowName ex
    * }
    * ```
    */
-  defineSignal: <K$1 extends keyof TContract["workflows"][TWorkflowName]["signals"]>(signalName: K$1, handler: SignalHandlerImplementation<TContract["workflows"][TWorkflowName]["signals"][K$1] extends SignalDefinition ? TContract["workflows"][TWorkflowName]["signals"][K$1] : never>) => void;
+  defineSignal: <K extends keyof TContract["workflows"][TWorkflowName]["signals"]>(signalName: K, handler: SignalHandlerImplementation<TContract["workflows"][TWorkflowName]["signals"][K] extends SignalDefinition ? TContract["workflows"][TWorkflowName]["signals"][K] : never>) => void;
   /**
    * Define a query handler within the workflow implementation
    * Allows the query handler to access workflow state
@@ -176,7 +175,7 @@ interface WorkflowContext<TContract extends ContractDefinition, TWorkflowName ex
    * }
    * ```
    */
-  defineQuery: <K$1 extends keyof TContract["workflows"][TWorkflowName]["queries"]>(queryName: K$1, handler: QueryHandlerImplementation<TContract["workflows"][TWorkflowName]["queries"][K$1] extends QueryDefinition ? TContract["workflows"][TWorkflowName]["queries"][K$1] : never>) => void;
+  defineQuery: <K extends keyof TContract["workflows"][TWorkflowName]["queries"]>(queryName: K, handler: QueryHandlerImplementation<TContract["workflows"][TWorkflowName]["queries"][K] extends QueryDefinition ? TContract["workflows"][TWorkflowName]["queries"][K] : never>) => void;
   /**
    * Define an update handler within the workflow implementation
    * Allows the update handler to access and modify workflow state
@@ -195,7 +194,7 @@ interface WorkflowContext<TContract extends ContractDefinition, TWorkflowName ex
    * }
    * ```
    */
-  defineUpdate: <K$1 extends keyof TContract["workflows"][TWorkflowName]["updates"]>(updateName: K$1, handler: UpdateHandlerImplementation<TContract["workflows"][TWorkflowName]["updates"][K$1] extends UpdateDefinition ? TContract["workflows"][TWorkflowName]["updates"][K$1] : never>) => void;
+  defineUpdate: <K extends keyof TContract["workflows"][TWorkflowName]["updates"]>(updateName: K, handler: UpdateHandlerImplementation<TContract["workflows"][TWorkflowName]["updates"][K] extends UpdateDefinition ? TContract["workflows"][TWorkflowName]["updates"][K] : never>) => void;
   /**
    * Start a child workflow and return a typed handle with Future/Result pattern
    *

package/dist/workflow.d.mts

@@ -1,10 +1,9 @@
-import { a as ChildWorkflowNotFoundError, c as SignalInputValidationError, d as WorkflowInputValidationError, f as WorkflowOutputValidationError, g as WorkerInferOutput, h as WorkerInferInput, i as ChildWorkflowError, l as UpdateInputValidationError, m as ClientInferOutput, n as ActivityInputValidationError, o as QueryInputValidationError, p as ClientInferInput, r as ActivityOutputValidationError, s as QueryOutputValidationError, u as UpdateOutputValidationError } from "./errors-C1RFkCuD.mjs";
+import { a as ChildWorkflowNotFoundError, c as SignalInputValidationError, d as WorkflowInputValidationError, f as WorkflowOutputValidationError, g as WorkerInferOutput, h as WorkerInferInput, i as ChildWorkflowError, l as UpdateInputValidationError, m as ClientInferOutput, n as ActivityInputValidationError, o as QueryInputValidationError, p as ClientInferInput, r as ActivityOutputValidationError, s as QueryOutputValidationError, u as UpdateOutputValidationError } from "./errors-Vr-sKdW7.mjs";
 import { Future, Result } from "@temporal-contract/boxed";
 import { ActivityOptions, ChildWorkflowOptions, WorkflowInfo } from "@temporalio/workflow";
 import { ActivityDefinition, ContractDefinition, QueryDefinition, SignalDefinition, UpdateDefinition, WorkflowDefinition } from "@temporal-contract/contract";
 
 //#region src/workflow.d.ts
-
 /**
  * Create a typed workflow implementation with automatic validation
  *
@@ -158,7 +157,7 @@ interface WorkflowContext<TContract extends ContractDefinition, TWorkflowName ex
    * }
    * ```
    */
-  defineSignal: <K$1 extends keyof TContract["workflows"][TWorkflowName]["signals"]>(signalName: K$1, handler: SignalHandlerImplementation<TContract["workflows"][TWorkflowName]["signals"][K$1] extends SignalDefinition ? TContract["workflows"][TWorkflowName]["signals"][K$1] : never>) => void;
+  defineSignal: <K extends keyof TContract["workflows"][TWorkflowName]["signals"]>(signalName: K, handler: SignalHandlerImplementation<TContract["workflows"][TWorkflowName]["signals"][K] extends SignalDefinition ? TContract["workflows"][TWorkflowName]["signals"][K] : never>) => void;
   /**
    * Define a query handler within the workflow implementation
    * Allows the query handler to access workflow state
@@ -176,7 +175,7 @@ interface WorkflowContext<TContract extends ContractDefinition, TWorkflowName ex
    * }
    * ```
    */
-  defineQuery: <K$1 extends keyof TContract["workflows"][TWorkflowName]["queries"]>(queryName: K$1, handler: QueryHandlerImplementation<TContract["workflows"][TWorkflowName]["queries"][K$1] extends QueryDefinition ? TContract["workflows"][TWorkflowName]["queries"][K$1] : never>) => void;
+  defineQuery: <K extends keyof TContract["workflows"][TWorkflowName]["queries"]>(queryName: K, handler: QueryHandlerImplementation<TContract["workflows"][TWorkflowName]["queries"][K] extends QueryDefinition ? TContract["workflows"][TWorkflowName]["queries"][K] : never>) => void;
   /**
    * Define an update handler within the workflow implementation
    * Allows the update handler to access and modify workflow state
@@ -195,7 +194,7 @@ interface WorkflowContext<TContract extends ContractDefinition, TWorkflowName ex
    * }
    * ```
    */
-  defineUpdate: <K$1 extends keyof TContract["workflows"][TWorkflowName]["updates"]>(updateName: K$1, handler: UpdateHandlerImplementation<TContract["workflows"][TWorkflowName]["updates"][K$1] extends UpdateDefinition ? TContract["workflows"][TWorkflowName]["updates"][K$1] : never>) => void;
+  defineUpdate: <K extends keyof TContract["workflows"][TWorkflowName]["updates"]>(updateName: K, handler: UpdateHandlerImplementation<TContract["workflows"][TWorkflowName]["updates"][K] extends UpdateDefinition ? TContract["workflows"][TWorkflowName]["updates"][K] : never>) => void;
   /**
    * Start a child workflow and return a typed handle with Future/Result pattern
    *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporal-contract/worker",
-  "version": "0.0.6",
+  "version": "0.1.0",
   "description": "Worker utilities with Result/Future pattern for implementing temporal-contract workflows and activities",
   "keywords": [
     "contract",
@@ -63,22 +63,24 @@
   ],
   "dependencies": {
     "@standard-schema/spec": "1.1.0",
-    "@temporal-contract/boxed": "0.0.6",
-    "@temporal-contract/contract": "0.0.6"
+    "@swan-io/boxed": "3.2.1",
+    "@temporal-contract/boxed": "0.1.0",
+    "@temporal-contract/contract": "0.1.0"
   },
   "devDependencies": {
-    "@temporalio/client": "1.14.0",
-    "@temporalio/worker": "1.14.0",
-    "@temporalio/workflow": "1.14.0",
-    "@types/node": "25.0.3",
-    "@vitest/coverage-v8": "4.0.16",
-    "tsdown": "0.18.1",
+    "@temporalio/client": "1.14.1",
+    "@temporalio/worker": "1.14.1",
+    "@temporalio/workflow": "1.14.1",
+    "@types/node": "25.0.9",
+    "@vitest/coverage-v8": "4.0.17",
+    "tsdown": "0.20.0-beta.4",
     "typescript": "5.9.3",
-    "vitest": "4.0.16",
-    "zod": "4.2.1",
-    "@temporal-contract/client": "0.0.6",
-    "@temporal-contract/testing": "0.0.6",
-    "@temporal-contract/tsconfig": "0.0.6"
+    "vitest": "4.0.17",
+    "zod": "4.3.5",
+    "@temporal-contract/client": "0.1.0",
+    "@temporal-contract/testing": "0.1.0",
+    "@temporal-contract/tsconfig": "0.1.0",
+    "@temporal-contract/typedoc": "0.1.0"
   },
   "peerDependencies": {
     "@temporalio/worker": "^1",
@@ -86,6 +88,7 @@
   },
   "scripts": {
     "build": "tsdown src/activity.ts src/worker.ts src/workflow.ts --format cjs,esm --dts --clean",
+    "build:docs": "typedoc",
     "dev": "tsdown src/activity.ts src/worker.ts src/workflow.ts --format cjs,esm --dts --watch",
     "test": "vitest run --project unit",
     "test:integration": "vitest run --project integration",