@temporal-contract/worker 0.1.0 → 0.2.0

package/README.md

@@ -41,6 +41,7 @@ import { declareWorkflow } from "@temporal-contract/worker/workflow";
 export const processOrder = declareWorkflow({
   workflowName: "processOrder",
   contract: myContract,
+  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!" });
@@ -77,9 +78,10 @@ import { declareWorkflow } from "@temporal-contract/worker/workflow";
 export const parentWorkflow = declareWorkflow({
   workflowName: "parentWorkflow",
   contract: myContract,
-  implementation: async ({ executeChildWorkflow }, input) => {
+  activityOptions: { startToCloseTimeout: "1 minute" },
+  implementation: async (context, input) => {
     // Execute child workflow from same contract and wait for result
-    const childResult = await executeChildWorkflow(myContract, "processPayment", {
+    const childResult = await context.executeChildWorkflow(myContract, "processPayment", {
       workflowId: `payment-${input.orderId}`,
       args: { amount: input.totalAmount },
     });
@@ -90,7 +92,7 @@ export const parentWorkflow = declareWorkflow({
     });
 
     // Execute child workflow from another contract (another worker)
-    const notificationResult = await executeChildWorkflow(
+    const notificationResult = await context.executeChildWorkflow(
       notificationContract,
       "sendNotification",
       {
@@ -100,7 +102,7 @@ export const parentWorkflow = declareWorkflow({
     );
 
     // Or start child workflow without waiting
-    const handleResult = await startChildWorkflow(myContract, "sendEmail", {
+    const handleResult = await context.startChildWorkflow(myContract, "sendEmail", {
       workflowId: `email-${input.orderId}`,
       args: { to: "user@example.com", body: "Order received" },
     });

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-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 };
+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-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 };
+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-Vr-sKdW7.d.mts → errors-4jH78z8m.d.cts}

@@ -133,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-CXpHOFmk.d.cts → errors-CmTXZ3JW.d.mts}

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

package/dist/errors-Di6Ja4Rt.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-Di6Ja4Rt.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\n\n/**\n * Base error class for worker errors\n */\nabstract class WorkerError extends Error {\n  protected constructor(message: string, cause?: unknown) {\n    super(message, { cause });\n    this.name = \"WorkerError\";\n    // Maintains proper stack trace for where our error was thrown (only available on V8)\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor);\n    }\n  }\n}\n\n/**\n * Error thrown when an activity definition is not found in the contract\n */\nexport class ActivityDefinitionNotFoundError extends WorkerError {\n  constructor(\n    public readonly activityName: string,\n    public readonly availableDefinitions: readonly string[] = [],\n  ) {\n    const available = availableDefinitions.length > 0 ? availableDefinitions.join(\", \") : \"none\";\n    super(\n      `Activity definition not found for: \"${activityName}\". Available activities: ${available}`,\n    );\n    this.name = \"ActivityDefinitionNotFoundError\";\n  }\n}\n\n/**\n * Error thrown when activity input validation fails\n */\nexport class ActivityInputValidationError extends WorkerError {\n  constructor(\n    public readonly activityName: string,\n    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,\n  ) {\n    const message = issues.map((issue) => issue.message).join(\"; \");\n    super(`Activity \"${activityName}\" input validation failed: ${message}`);\n    this.name = \"ActivityInputValidationError\";\n  }\n}\n\n/**\n * Error thrown when activity output validation fails\n */\nexport class ActivityOutputValidationError extends WorkerError {\n  constructor(\n    public readonly activityName: string,\n    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,\n  ) {\n    const message = issues.map((issue) => issue.message).join(\"; \");\n    super(`Activity \"${activityName}\" output validation failed: ${message}`);\n    this.name = \"ActivityOutputValidationError\";\n  }\n}\n\n/**\n * Error thrown when workflow input validation fails\n */\nexport class WorkflowInputValidationError extends WorkerError {\n  constructor(\n    public readonly workflowName: string,\n    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,\n  ) {\n    const message = issues.map((issue) => issue.message).join(\"; \");\n    super(`Workflow \"${workflowName}\" input validation failed: ${message}`);\n    this.name = \"WorkflowInputValidationError\";\n  }\n}\n\n/**\n * Error thrown when workflow output validation fails\n */\nexport class WorkflowOutputValidationError extends WorkerError {\n  constructor(\n    public readonly workflowName: string,\n    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,\n  ) {\n    const message = issues.map((issue) => issue.message).join(\"; \");\n    super(`Workflow \"${workflowName}\" output validation failed: ${message}`);\n    this.name = \"WorkflowOutputValidationError\";\n  }\n}\n\n/**\n * Error thrown when signal input validation fails\n */\nexport class SignalInputValidationError extends WorkerError {\n  constructor(\n    public readonly signalName: string,\n    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,\n  ) {\n    const message = issues.map((issue) => issue.message).join(\"; \");\n    super(`Signal \"${signalName}\" input validation failed: ${message}`);\n    this.name = \"SignalInputValidationError\";\n  }\n}\n\n/**\n * Error thrown when query input validation fails\n */\nexport class QueryInputValidationError extends WorkerError {\n  constructor(\n    public readonly queryName: string,\n    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,\n  ) {\n    const message = issues.map((issue) => issue.message).join(\"; \");\n    super(`Query \"${queryName}\" input validation failed: ${message}`);\n    this.name = \"QueryInputValidationError\";\n  }\n}\n\n/**\n * Error thrown when query output validation fails\n */\nexport class QueryOutputValidationError extends WorkerError {\n  constructor(\n    public readonly queryName: string,\n    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,\n  ) {\n    const message = issues.map((issue) => issue.message).join(\"; \");\n    super(`Query \"${queryName}\" output validation failed: ${message}`);\n    this.name = \"QueryOutputValidationError\";\n  }\n}\n\n/**\n * Error thrown when update input validation fails\n */\nexport class UpdateInputValidationError extends WorkerError {\n  constructor(\n    public readonly updateName: string,\n    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,\n  ) {\n    const message = issues.map((issue) => issue.message).join(\"; \");\n    super(`Update \"${updateName}\" input validation failed: ${message}`);\n    this.name = \"UpdateInputValidationError\";\n  }\n}\n\n/**\n * Error thrown when update output validation fails\n */\nexport class UpdateOutputValidationError extends WorkerError {\n  constructor(\n    public readonly updateName: string,\n    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,\n  ) {\n    const message = issues.map((issue) => issue.message).join(\"; \");\n    super(`Update \"${updateName}\" output validation failed: ${message}`);\n    this.name = \"UpdateOutputValidationError\";\n  }\n}\n\n/**\n * Error thrown when a child workflow is not found in the contract\n */\nexport class ChildWorkflowNotFoundError extends WorkerError {\n  constructor(\n    public readonly workflowName: string,\n    public readonly availableWorkflows: readonly string[] = [],\n  ) {\n    const available = availableWorkflows.length > 0 ? availableWorkflows.join(\", \") : \"none\";\n    super(`Child workflow not found: \"${workflowName}\". Available workflows: ${available}`);\n    this.name = \"ChildWorkflowNotFoundError\";\n  }\n}\n\n/**\n * Generic error for child workflow operations\n */\nexport class ChildWorkflowError extends WorkerError {\n  constructor(message: string, cause?: unknown) {\n    super(message, cause);\n    this.name = \"ChildWorkflowError\";\n  }\n}\n"],"mappings":";;;;AAKA,IAAe,cAAf,cAAmC,MAAM;CACvC,AAAU,YAAY,SAAiB,OAAiB;AACtD,QAAM,SAAS,EAAE,OAAO,CAAC;AACzB,OAAK,OAAO;AAEZ,MAAI,MAAM,kBACR,OAAM,kBAAkB,MAAM,KAAK,YAAY;;;;;;AAQrD,IAAa,kCAAb,cAAqD,YAAY;CAC/D,YACE,AAAgB,cAChB,AAAgB,uBAA0C,EAAE,EAC5D;EACA,MAAM,YAAY,qBAAqB,SAAS,IAAI,qBAAqB,KAAK,KAAK,GAAG;AACtF,QACE,uCAAuC,aAAa,2BAA2B,YAChF;EANe;EACA;AAMhB,OAAK,OAAO;;;;;;AAOhB,IAAa,+BAAb,cAAkD,YAAY;CAC5D,YACE,AAAgB,cAChB,AAAgB,QAChB;EACA,MAAM,UAAU,OAAO,KAAK,UAAU,MAAM,QAAQ,CAAC,KAAK,KAAK;AAC/D,QAAM,aAAa,aAAa,6BAA6B,UAAU;EAJvD;EACA;AAIhB,OAAK,OAAO;;;;;;AAOhB,IAAa,gCAAb,cAAmD,YAAY;CAC7D,YACE,AAAgB,cAChB,AAAgB,QAChB;EACA,MAAM,UAAU,OAAO,KAAK,UAAU,MAAM,QAAQ,CAAC,KAAK,KAAK;AAC/D,QAAM,aAAa,aAAa,8BAA8B,UAAU;EAJxD;EACA;AAIhB,OAAK,OAAO;;;;;;AAOhB,IAAa,+BAAb,cAAkD,YAAY;CAC5D,YACE,AAAgB,cAChB,AAAgB,QAChB;EACA,MAAM,UAAU,OAAO,KAAK,UAAU,MAAM,QAAQ,CAAC,KAAK,KAAK;AAC/D,QAAM,aAAa,aAAa,6BAA6B,UAAU;EAJvD;EACA;AAIhB,OAAK,OAAO;;;;;;AAOhB,IAAa,gCAAb,cAAmD,YAAY;CAC7D,YACE,AAAgB,cAChB,AAAgB,QAChB;EACA,MAAM,UAAU,OAAO,KAAK,UAAU,MAAM,QAAQ,CAAC,KAAK,KAAK;AAC/D,QAAM,aAAa,aAAa,8BAA8B,UAAU;EAJxD;EACA;AAIhB,OAAK,OAAO;;;;;;AAOhB,IAAa,6BAAb,cAAgD,YAAY;CAC1D,YACE,AAAgB,YAChB,AAAgB,QAChB;EACA,MAAM,UAAU,OAAO,KAAK,UAAU,MAAM,QAAQ,CAAC,KAAK,KAAK;AAC/D,QAAM,WAAW,WAAW,6BAA6B,UAAU;EAJnD;EACA;AAIhB,OAAK,OAAO;;;;;;AAOhB,IAAa,4BAAb,cAA+C,YAAY;CACzD,YACE,AAAgB,WAChB,AAAgB,QAChB;EACA,MAAM,UAAU,OAAO,KAAK,UAAU,MAAM,QAAQ,CAAC,KAAK,KAAK;AAC/D,QAAM,UAAU,UAAU,6BAA6B,UAAU;EAJjD;EACA;AAIhB,OAAK,OAAO;;;;;;AAOhB,IAAa,6BAAb,cAAgD,YAAY;CAC1D,YACE,AAAgB,WAChB,AAAgB,QAChB;EACA,MAAM,UAAU,OAAO,KAAK,UAAU,MAAM,QAAQ,CAAC,KAAK,KAAK;AAC/D,QAAM,UAAU,UAAU,8BAA8B,UAAU;EAJlD;EACA;AAIhB,OAAK,OAAO;;;;;;AAOhB,IAAa,6BAAb,cAAgD,YAAY;CAC1D,YACE,AAAgB,YAChB,AAAgB,QAChB;EACA,MAAM,UAAU,OAAO,KAAK,UAAU,MAAM,QAAQ,CAAC,KAAK,KAAK;AAC/D,QAAM,WAAW,WAAW,6BAA6B,UAAU;EAJnD;EACA;AAIhB,OAAK,OAAO;;;;;;AAOhB,IAAa,8BAAb,cAAiD,YAAY;CAC3D,YACE,AAAgB,YAChB,AAAgB,QAChB;EACA,MAAM,UAAU,OAAO,KAAK,UAAU,MAAM,QAAQ,CAAC,KAAK,KAAK;AAC/D,QAAM,WAAW,WAAW,8BAA8B,UAAU;EAJpD;EACA;AAIhB,OAAK,OAAO;;;;;;AAOhB,IAAa,6BAAb,cAAgD,YAAY;CAC1D,YACE,AAAgB,cAChB,AAAgB,qBAAwC,EAAE,EAC1D;EACA,MAAM,YAAY,mBAAmB,SAAS,IAAI,mBAAmB,KAAK,KAAK,GAAG;AAClF,QAAM,8BAA8B,aAAa,0BAA0B,YAAY;EAJvE;EACA;AAIhB,OAAK,OAAO;;;;;;AAOhB,IAAa,qBAAb,cAAwC,YAAY;CAClD,YAAY,SAAiB,OAAiB;AAC5C,QAAM,SAAS,MAAM;AACrB,OAAK,OAAO"}

package/dist/worker.cjs

@@ -1,6 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 let _temporalio_worker = require("@temporalio/worker");
 let node_url = require("node:url");
-let node_path = require("node:path");
 
 //#region src/worker.ts
 /**
@@ -40,9 +40,14 @@ async function createWorker(options) {
 	});
 }
 /**
-* Helper to create a workflowsPath from a file URL
+* Helper to resolve a workflow file path relative to the current module's URL.
 *
-* Useful for creating the workflowsPath option when using ES modules
+* Useful when using ES modules (`import.meta.url`) to locate workflow files.
+* The `relativePath` should include the file extension explicitly (e.g. `./workflows.js`)
+* to ensure the resolved path is unambiguous in both source and built contexts.
+*
+* @param baseURL - The base URL to resolve from, typically `import.meta.url`
+* @param relativePath - Relative path to the workflows file, **including extension**
 *
 * @example
 * ```ts
@@ -51,13 +56,14 @@ async function createWorker(options) {
 * const worker = await createWorker({
 *   contract: myContract,
 *   connection,
-*   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows'),
+*   // Include the extension explicitly to work in both source (.ts) and build (.js) contexts
+*   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows.js'),
 *   activities,
 * });
 * ```
 */
 function workflowsPathFromURL(baseURL, relativePath) {
-	return (0, node_url.fileURLToPath)(new URL(`${relativePath}${(0, node_path.extname)(baseURL)}`, baseURL));
+	return (0, node_url.fileURLToPath)(new URL(relativePath, baseURL));
 }
 
 //#endregion

package/dist/worker.d.cts

@@ -1,4 +1,4 @@
-import { t as ActivitiesHandler } from "./activity-5pVNjW7l.cjs";
+import { ActivitiesHandler } from "./activity.cjs";
 import { ContractDefinition } from "@temporal-contract/contract";
 import { Worker, WorkerOptions } from "@temporalio/worker";
 
@@ -6,7 +6,7 @@ import { Worker, WorkerOptions } from "@temporalio/worker";
 /**
  * Options for creating a Temporal worker
  */
-interface CreateWorkerOptions<TContract extends ContractDefinition> extends Omit<WorkerOptions, "activities" | "taskQueue"> {
+type CreateWorkerOptions<TContract extends ContractDefinition> = Omit<WorkerOptions, "activities" | "taskQueue"> & {
   /**
    * The contract definition for this worker
    */
@@ -15,7 +15,7 @@ interface CreateWorkerOptions<TContract extends ContractDefinition> extends Omit
    * Activities handler for this worker
    */
   activities: ActivitiesHandler<TContract>;
-}
+};
 /**
  * Create a typed Temporal worker with contract-based configuration
  *
@@ -46,9 +46,14 @@ interface CreateWorkerOptions<TContract extends ContractDefinition> extends Omit
  */
 declare function createWorker<TContract extends ContractDefinition>(options: CreateWorkerOptions<TContract>): Promise<Worker>;
 /**
- * Helper to create a workflowsPath from a file URL
+ * Helper to resolve a workflow file path relative to the current module's URL.
  *
- * Useful for creating the workflowsPath option when using ES modules
+ * Useful when using ES modules (`import.meta.url`) to locate workflow files.
+ * The `relativePath` should include the file extension explicitly (e.g. `./workflows.js`)
+ * to ensure the resolved path is unambiguous in both source and built contexts.
+ *
+ * @param baseURL - The base URL to resolve from, typically `import.meta.url`
+ * @param relativePath - Relative path to the workflows file, **including extension**
  *
  * @example
  * ```ts
@@ -57,11 +62,13 @@ declare function createWorker<TContract extends ContractDefinition>(options: Cre
  * const worker = await createWorker({
  *   contract: myContract,
  *   connection,
- *   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows'),
+ *   // Include the extension explicitly to work in both source (.ts) and build (.js) contexts
+ *   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows.js'),
  *   activities,
  * });
  * ```
  */
 declare function workflowsPathFromURL(baseURL: string, relativePath: string): string;
 //#endregion
-export { CreateWorkerOptions, createWorker, workflowsPathFromURL };
+export { CreateWorkerOptions, createWorker, workflowsPathFromURL };
+//# sourceMappingURL=worker.d.cts.map

package/dist/worker.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.cts","names":[],"sources":["../src/worker.ts"],"mappings":";;;;;;;AASA;KAAY,mBAAA,mBAAsC,kBAAA,IAAsB,IAAA,CACtE,aAAA;EAD6B;;;EAO7B,QAAA,EAAU,SAAA;EAAA;;;EAKV,UAAA,EAAY,iBAAA,CAAkB,SAAA;AAAA;;;;;;;;;;;;AA+BhC;;;;;;;;;;;;;;;;;iBAAsB,YAAA,mBAA+B,kBAAA,CAAA,CACnD,OAAA,EAAS,mBAAA,CAAoB,SAAA,IAC5B,OAAA,CAAQ,MAAA;;AAkCX;;;;;;;;;;;;;;;;;;;;;;iBAAgB,oBAAA,CAAqB,OAAA,UAAiB,YAAA"}