@temporal-contract/client 0.0.5 → 0.0.7

package/dist/index.cjs

@@ -1,5 +1,4 @@
-let __temporalio_client = require("@temporalio/client");
-let __temporal_contract_boxed = require("@temporal-contract/boxed");
+let _swan_io_boxed = require("@swan-io/boxed");
 
 //#region src/errors.ts
 /**
@@ -13,6 +12,16 @@ var TypedClientError = class extends Error {
 	}
 };
 /**
+* Generic runtime failure wrapper when no specific error type applies
+*/
+var RuntimeClientError = class extends TypedClientError {
+	constructor(operation, cause) {
+		super(`Operation "${operation}" failed: ${cause instanceof Error ? cause.message : String(cause ?? "unknown error")}`);
+		this.operation = operation;
+		this.cause = cause;
+	}
+};
+/**
 * Thrown when a workflow is not found in the contract
 */
 var WorkflowNotFoundError = class extends TypedClientError {
@@ -101,8 +110,8 @@ var TypedClient = class TypedClient {
 	* });
 	* ```
 	*/
-	static create(contract, options) {
-		return new TypedClient(contract, new __temporalio_client.Client(options));
+	static create(contract, client) {
+		return new TypedClient(contract, client);
 	}
 	/**
 	* Start a workflow and return a typed handle with Future pattern
@@ -126,16 +135,16 @@ var TypedClient = class TypedClient {
 	* ```
 	*/
 	startWorkflow(workflowName, { args, ...temporalOptions }) {
-		return __temporal_contract_boxed.Future.make((resolve) => {
-			const definition = this.contract.workflows[workflowName];
-			if (!definition) {
-				resolve(__temporal_contract_boxed.Result.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
-				return;
-			}
+		return _swan_io_boxed.Future.make((resolve) => {
 			(async () => {
+				const definition = this.contract.workflows[workflowName];
+				if (!definition) {
+					resolve(_swan_io_boxed.Result.Error(createWorkflowNotFoundError(workflowName, this.contract)));
+					return;
+				}
 				const inputResult = await definition.input["~standard"].validate(args);
 				if (inputResult.issues) {
-					resolve(__temporal_contract_boxed.Result.Error(new WorkflowValidationError(String(workflowName), "input", inputResult.issues)));
+					resolve(_swan_io_boxed.Result.Error(createWorkflowValidationError(workflowName, "input", inputResult.issues)));
 					return;
 				}
 				const validatedInput = inputResult.value;
@@ -146,9 +155,9 @@ var TypedClient = class TypedClient {
 						args: [validatedInput]
 					});
 					const typedHandle = this.createTypedHandle(handle, definition);
-					resolve(__temporal_contract_boxed.Result.Ok(typedHandle));
+					resolve(_swan_io_boxed.Result.Ok(typedHandle));
 				} catch (error) {
-					resolve(__temporal_contract_boxed.Result.Error(new TypedClientError(`Failed to start workflow: ${error instanceof Error ? error.message : String(error)}`)));
+					resolve(_swan_io_boxed.Result.Error(createRuntimeClientError("startWorkflow", error)));
 				}
 			})();
 		});
@@ -172,16 +181,16 @@ var TypedClient = class TypedClient {
 	* ```
 	*/
 	executeWorkflow(workflowName, { args, ...temporalOptions }) {
-		return __temporal_contract_boxed.Future.make((resolve) => {
-			const definition = this.contract.workflows[workflowName];
-			if (!definition) {
-				resolve(__temporal_contract_boxed.Result.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
-				return;
-			}
+		return _swan_io_boxed.Future.make((resolve) => {
 			(async () => {
+				const definition = this.contract.workflows[workflowName];
+				if (!definition) {
+					resolve(_swan_io_boxed.Result.Error(createWorkflowNotFoundError(workflowName, this.contract)));
+					return;
+				}
 				const inputResult = await definition.input["~standard"].validate(args);
 				if (inputResult.issues) {
-					resolve(__temporal_contract_boxed.Result.Error(new WorkflowValidationError(String(workflowName), "input", inputResult.issues)));
+					resolve(_swan_io_boxed.Result.Error(createWorkflowValidationError(workflowName, "input", inputResult.issues)));
 					return;
 				}
 				const validatedInput = inputResult.value;
@@ -193,12 +202,12 @@ var TypedClient = class TypedClient {
 					});
 					const outputResult = await definition.output["~standard"].validate(result);
 					if (outputResult.issues) {
-						resolve(__temporal_contract_boxed.Result.Error(new WorkflowValidationError(String(workflowName), "output", outputResult.issues)));
+						resolve(_swan_io_boxed.Result.Error(createWorkflowValidationError(workflowName, "output", outputResult.issues)));
 						return;
 					}
-					resolve(__temporal_contract_boxed.Result.Ok(outputResult.value));
+					resolve(_swan_io_boxed.Result.Ok(outputResult.value));
 				} catch (error) {
-					resolve(__temporal_contract_boxed.Result.Error(new TypedClientError(`Failed to execute workflow: ${error instanceof Error ? error.message : String(error)}`)));
+					resolve(_swan_io_boxed.Result.Error(createRuntimeClientError("executeWorkflow", error)));
 				}
 			})();
 		});
@@ -219,154 +228,137 @@ var TypedClient = class TypedClient {
 	* ```
 	*/
 	getHandle(workflowName, workflowId) {
-		return __temporal_contract_boxed.Future.make((resolve) => {
+		return _swan_io_boxed.Future.make((resolve) => {
 			const definition = this.contract.workflows[workflowName];
 			if (!definition) {
-				resolve(__temporal_contract_boxed.Result.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
+				resolve(_swan_io_boxed.Result.Error(createWorkflowNotFoundError(workflowName, this.contract)));
 				return;
 			}
 			try {
 				const handle = this.client.workflow.getHandle(workflowId);
 				const typedHandle = this.createTypedHandle(handle, definition);
-				resolve(__temporal_contract_boxed.Result.Ok(typedHandle));
+				resolve(_swan_io_boxed.Result.Ok(typedHandle));
 			} catch (error) {
-				resolve(__temporal_contract_boxed.Result.Error(new TypedClientError(`Failed to get workflow handle: ${error instanceof Error ? error.message : String(error)}`)));
+				resolve(_swan_io_boxed.Result.Error(createRuntimeClientError("getHandle", error)));
 			}
 		});
 	}
-	createTypedHandle(handle, definition) {
+	createTypedHandle(workflowHandle, definition) {
 		const queries = {};
 		for (const [queryName, queryDef] of Object.entries(definition.queries ?? {})) queries[queryName] = (args) => {
-			return __temporal_contract_boxed.Future.make((resolve) => {
+			return _swan_io_boxed.Future.make((resolve) => {
 				(async () => {
 					const inputResult = await queryDef.input["~standard"].validate(args);
 					if (inputResult.issues) {
-						resolve(__temporal_contract_boxed.Result.Error(new QueryValidationError(queryName, "input", inputResult.issues)));
+						resolve(_swan_io_boxed.Result.Error(new QueryValidationError(queryName, "input", inputResult.issues)));
 						return;
 					}
 					try {
-						const result = await handle.query(queryName, inputResult.value);
+						const result = await workflowHandle.query(queryName, inputResult.value);
 						const outputResult = await queryDef.output["~standard"].validate(result);
 						if (outputResult.issues) {
-							resolve(__temporal_contract_boxed.Result.Error(new QueryValidationError(queryName, "output", outputResult.issues)));
+							resolve(_swan_io_boxed.Result.Error(new QueryValidationError(queryName, "output", outputResult.issues)));
 							return;
 						}
-						resolve(__temporal_contract_boxed.Result.Ok(outputResult.value));
+						resolve(_swan_io_boxed.Result.Ok(outputResult.value));
 					} catch (error) {
-						resolve(__temporal_contract_boxed.Result.Error(new TypedClientError(`Query failed: ${error instanceof Error ? error.message : String(error)}`)));
+						resolve(_swan_io_boxed.Result.Error(createRuntimeClientError("query", error)));
 					}
 				})();
 			});
 		};
 		const signals = {};
 		for (const [signalName, signalDef] of Object.entries(definition.signals ?? {})) signals[signalName] = (args) => {
-			return __temporal_contract_boxed.Future.make((resolve) => {
+			return _swan_io_boxed.Future.make((resolve) => {
 				(async () => {
 					const inputResult = await signalDef.input["~standard"].validate(args);
 					if (inputResult.issues) {
-						resolve(__temporal_contract_boxed.Result.Error(new SignalValidationError(signalName, inputResult.issues)));
+						resolve(_swan_io_boxed.Result.Error(new SignalValidationError(signalName, inputResult.issues)));
 						return;
 					}
 					try {
-						await handle.signal(signalName, inputResult.value);
-						resolve(__temporal_contract_boxed.Result.Ok(void 0));
+						await workflowHandle.signal(signalName, inputResult.value);
+						resolve(_swan_io_boxed.Result.Ok(void 0));
 					} catch (error) {
-						resolve(__temporal_contract_boxed.Result.Error(new TypedClientError(`Signal failed: ${error instanceof Error ? error.message : String(error)}`)));
+						resolve(_swan_io_boxed.Result.Error(createRuntimeClientError("signal", error)));
 					}
 				})();
 			});
 		};
 		const updates = {};
 		for (const [updateName, updateDef] of Object.entries(definition.updates ?? {})) updates[updateName] = (args) => {
-			return __temporal_contract_boxed.Future.make((resolve) => {
+			return _swan_io_boxed.Future.make((resolve) => {
 				(async () => {
 					const inputResult = await updateDef.input["~standard"].validate(args);
 					if (inputResult.issues) {
-						resolve(__temporal_contract_boxed.Result.Error(new UpdateValidationError(updateName, "input", inputResult.issues)));
+						resolve(_swan_io_boxed.Result.Error(new UpdateValidationError(updateName, "input", inputResult.issues)));
 						return;
 					}
 					try {
-						const result = await handle.executeUpdate(updateName, { args: [inputResult.value] });
+						const result = await workflowHandle.executeUpdate(updateName, { args: [inputResult.value] });
 						const outputResult = await updateDef.output["~standard"].validate(result);
 						if (outputResult.issues) {
-							resolve(__temporal_contract_boxed.Result.Error(new UpdateValidationError(updateName, "output", outputResult.issues)));
+							resolve(_swan_io_boxed.Result.Error(new UpdateValidationError(updateName, "output", outputResult.issues)));
 							return;
 						}
-						resolve(__temporal_contract_boxed.Result.Ok(outputResult.value));
+						resolve(_swan_io_boxed.Result.Ok(outputResult.value));
 					} catch (error) {
-						resolve(__temporal_contract_boxed.Result.Error(new TypedClientError(`Update failed: ${error instanceof Error ? error.message : String(error)}`)));
+						resolve(_swan_io_boxed.Result.Error(createRuntimeClientError("update", error)));
 					}
 				})();
 			});
 		};
 		return {
-			workflowId: handle.workflowId,
+			workflowId: workflowHandle.workflowId,
 			queries,
 			signals,
 			updates,
 			result: () => {
-				return __temporal_contract_boxed.Future.make((resolve) => {
+				return _swan_io_boxed.Future.make((resolve) => {
 					(async () => {
 						try {
-							const result = await handle.result();
+							const result = await workflowHandle.result();
 							const outputResult = await definition.output["~standard"].validate(result);
 							if (outputResult.issues) {
-								resolve(__temporal_contract_boxed.Result.Error(new WorkflowValidationError(handle.workflowId, "output", outputResult.issues)));
+								resolve(_swan_io_boxed.Result.Error(new WorkflowValidationError(workflowHandle.workflowId, "output", outputResult.issues)));
 								return;
 							}
-							resolve(__temporal_contract_boxed.Result.Ok(outputResult.value));
+							resolve(_swan_io_boxed.Result.Ok(outputResult.value));
 						} catch (error) {
-							resolve(__temporal_contract_boxed.Result.Error(new TypedClientError(`Workflow execution failed: ${error instanceof Error ? error.message : String(error)}`)));
+							resolve(_swan_io_boxed.Result.Error(createRuntimeClientError("result", error)));
 						}
 					})();
 				});
 			},
 			terminate: (reason) => {
-				return __temporal_contract_boxed.Future.make((resolve) => {
-					(async () => {
-						try {
-							await handle.terminate(reason);
-							resolve(__temporal_contract_boxed.Result.Ok(void 0));
-						} catch (error) {
-							resolve(__temporal_contract_boxed.Result.Error(new TypedClientError(`Terminate failed: ${error instanceof Error ? error.message : String(error)}`)));
-						}
-					})();
-				});
+				return _swan_io_boxed.Future.fromPromise(workflowHandle.terminate(reason)).mapError((error) => createRuntimeClientError("terminate", error)).mapOk(() => void 0);
 			},
 			cancel: () => {
-				return __temporal_contract_boxed.Future.make((resolve) => {
-					(async () => {
-						try {
-							await handle.cancel();
-							resolve(__temporal_contract_boxed.Result.Ok(void 0));
-						} catch (error) {
-							resolve(__temporal_contract_boxed.Result.Error(new TypedClientError(`Cancel failed: ${error instanceof Error ? error.message : String(error)}`)));
-						}
-					})();
-				});
+				return _swan_io_boxed.Future.fromPromise(workflowHandle.cancel()).mapError((error) => createRuntimeClientError("cancel", error)).mapOk(() => void 0);
 			},
 			describe: () => {
-				return __temporal_contract_boxed.Future.make((resolve) => {
-					(async () => {
-						try {
-							const description = await handle.describe();
-							resolve(__temporal_contract_boxed.Result.Ok(description));
-						} catch (error) {
-							resolve(__temporal_contract_boxed.Result.Error(new TypedClientError(`Describe failed: ${error instanceof Error ? error.message : String(error)}`)));
-						}
-					})();
-				});
+				return _swan_io_boxed.Future.fromPromise(workflowHandle.describe()).mapError((error) => createRuntimeClientError("describe", error));
 			},
-			fetchHistory: () => handle.fetchHistory()
+			fetchHistory: () => {
+				return _swan_io_boxed.Future.fromPromise(workflowHandle.fetchHistory()).mapError((error) => createRuntimeClientError("fetchHistory", error));
+			}
 		};
 	}
 };
+function createRuntimeClientError(operation, error) {
+	return new RuntimeClientError(operation, error);
+}
+function createWorkflowNotFoundError(workflowName, contract) {
+	return new WorkflowNotFoundError(String(workflowName), Object.keys(contract.workflows));
+}
+function createWorkflowValidationError(workflowName, direction, issues) {
+	return new WorkflowValidationError(String(workflowName), direction, issues);
+}
 
 //#endregion
 exports.QueryValidationError = QueryValidationError;
 exports.SignalValidationError = SignalValidationError;
 exports.TypedClient = TypedClient;
-exports.TypedClientError = TypedClientError;
 exports.UpdateValidationError = UpdateValidationError;
 exports.WorkflowNotFoundError = WorkflowNotFoundError;
 exports.WorkflowValidationError = WorkflowValidationError;

package/dist/index.d.cts

@@ -1,7 +1,7 @@
-import { ClientOptions, WorkflowHandle, WorkflowOptions, WorkflowStartOptions } from "@temporalio/client";
+import { Client, WorkflowHandle, WorkflowStartOptions } from "@temporalio/client";
 import { ActivityDefinition, AnySchema, ContractDefinition, QueryDefinition, SignalDefinition, UpdateDefinition, WorkflowDefinition } from "@temporal-contract/contract";
 import { StandardSchemaV1 } from "@standard-schema/spec";
-import { Future, Result } from "@temporal-contract/boxed";
+import { Future, Result } from "@swan-io/boxed";
 
 //#region src/types.d.ts
 
@@ -85,8 +85,16 @@ type ClientInferWorkflowContextActivities<TContract extends ContractDefinition,
 /**
  * Base class for all typed client errors with boxed pattern
  */
-declare class TypedClientError extends Error {
-  constructor(message: string);
+declare abstract class TypedClientError extends Error {
+  protected constructor(message: string);
+}
+/**
+ * Generic runtime failure wrapper when no specific error type applies
+ */
+declare class RuntimeClientError extends TypedClientError {
+  readonly operation: string;
+  readonly cause?: unknown | undefined;
+  constructor(operation: string, cause?: unknown | undefined);
 }
 /**
  * Thrown when a workflow is not found in the contract
@@ -133,11 +141,9 @@ declare class UpdateValidationError extends TypedClientError {
 }
 //#endregion
 //#region src/client.d.ts
-/**
- * Extended options for starting workflows with Temporal-specific features
- * Combines required workflowId with optional Temporal workflow options
- */
-type TypedWorkflowStartOptions = Pick<WorkflowStartOptions, "workflowId" | "workflowIdReusePolicy" | "workflowExecutionTimeout" | "workflowRunTimeout" | "workflowTaskTimeout" | "retry" | "memo" | "searchAttributes" | "cronSchedule"> & Pick<WorkflowOptions, "workflowId">;
+type TypedWorkflowStartOptions<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = Omit<WorkflowStartOptions, "taskQueue" | "args"> & {
+  args: ClientInferInput<TContract["workflows"][TWorkflowName]>;
+};
 /**
  * Typed workflow handle with validated results using Result/Future pattern
  */
@@ -147,37 +153,37 @@ interface TypedWorkflowHandle<TWorkflow extends WorkflowDefinition> {
    * Type-safe queries based on workflow definition with Result pattern
    * Each query returns Future<Result<T, Error>> instead of Promise<T>
    */
-  queries: { [K in keyof ClientInferWorkflowQueries<TWorkflow>]: ClientInferWorkflowQueries<TWorkflow>[K] extends ((...args: infer Args) => Future<Result<infer R, Error>>) ? (...args: Args) => Future<Result<R, TypedClientError>> : never };
+  queries: { [K in keyof ClientInferWorkflowQueries<TWorkflow>]: ClientInferWorkflowQueries<TWorkflow>[K] extends ((...args: infer Args) => Future<Result<infer R, Error>>) ? (...args: Args) => Future<Result<R, QueryValidationError | RuntimeClientError>> : never };
   /**
    * Type-safe signals based on workflow definition with Result pattern
    * Each signal returns Future<Result<void, Error>> instead of Promise<void>
    */
-  signals: { [K in keyof ClientInferWorkflowSignals<TWorkflow>]: ClientInferWorkflowSignals<TWorkflow>[K] extends ((...args: infer Args) => Future<Result<void, Error>>) ? (...args: Args) => Future<Result<void, TypedClientError>> : never };
+  signals: { [K in keyof ClientInferWorkflowSignals<TWorkflow>]: ClientInferWorkflowSignals<TWorkflow>[K] extends ((...args: infer Args) => Future<Result<void, Error>>) ? (...args: Args) => Future<Result<void, SignalValidationError | RuntimeClientError>> : never };
   /**
    * Type-safe updates based on workflow definition with Result pattern
    * Each update returns Future<Result<T, Error>> instead of Promise<T>
    */
-  updates: { [K in keyof ClientInferWorkflowUpdates<TWorkflow>]: ClientInferWorkflowUpdates<TWorkflow>[K] extends ((...args: infer Args) => Future<Result<infer R, Error>>) ? (...args: Args) => Future<Result<R, TypedClientError>> : never };
+  updates: { [K in keyof ClientInferWorkflowUpdates<TWorkflow>]: ClientInferWorkflowUpdates<TWorkflow>[K] extends ((...args: infer Args) => Future<Result<infer R, Error>>) ? (...args: Args) => Future<Result<R, UpdateValidationError | RuntimeClientError>> : never };
   /**
    * Get workflow result with Result pattern
    */
-  result: () => Future<Result<ClientInferOutput<TWorkflow>, TypedClientError>>;
+  result: () => Future<Result<ClientInferOutput<TWorkflow>, WorkflowValidationError | RuntimeClientError>>;
   /**
    * Terminate workflow with Result pattern
    */
-  terminate: (reason?: string) => Future<Result<void, TypedClientError>>;
+  terminate: (reason?: string) => Future<Result<void, RuntimeClientError>>;
   /**
    * Cancel workflow with Result pattern
    */
-  cancel: () => Future<Result<void, TypedClientError>>;
+  cancel: () => Future<Result<void, RuntimeClientError>>;
   /**
    * Get workflow execution description including status and metadata
    */
-  describe: () => Future<Result<Awaited<ReturnType<WorkflowHandle["describe"]>>, TypedClientError>>;
+  describe: () => Future<Result<Awaited<ReturnType<WorkflowHandle["describe"]>>, RuntimeClientError>>;
   /**
    * Fetch the workflow execution history
    */
-  fetchHistory: () => ReturnType<WorkflowHandle["fetchHistory"]>;
+  fetchHistory: () => Future<Result<Awaited<ReturnType<WorkflowHandle["fetchHistory"]>>, RuntimeClientError>>;
 }
 /**
  * Typed Temporal client with Result/Future pattern based on a contract
@@ -211,7 +217,7 @@ declare class TypedClient<TContract extends ContractDefinition> {
    * });
    * ```
    */
-  static create<TContract extends ContractDefinition>(contract: TContract, options: ClientOptions): TypedClient<TContract>;
+  static create<TContract extends ContractDefinition>(contract: TContract, client: Client): TypedClient<TContract>;
   /**
    * Start a workflow and return a typed handle with Future pattern
    *
@@ -236,9 +242,7 @@ declare class TypedClient<TContract extends ContractDefinition> {
   startWorkflow<TWorkflowName extends keyof TContract["workflows"]>(workflowName: TWorkflowName, {
     args,
     ...temporalOptions
-  }: TypedWorkflowStartOptions & {
-    args: ClientInferInput<TContract["workflows"][TWorkflowName]>;
-  }): Future<Result<TypedWorkflowHandle<TContract["workflows"][TWorkflowName]>, TypedClientError>>;
+  }: TypedWorkflowStartOptions<TContract, TWorkflowName>): Future<Result<TypedWorkflowHandle<TContract["workflows"][TWorkflowName]>, WorkflowNotFoundError | WorkflowValidationError | RuntimeClientError>>;
   /**
    * Execute a workflow (start and wait for result) with Future/Result pattern
    *
@@ -260,9 +264,7 @@ declare class TypedClient<TContract extends ContractDefinition> {
   executeWorkflow<TWorkflowName extends keyof TContract["workflows"]>(workflowName: TWorkflowName, {
     args,
     ...temporalOptions
-  }: TypedWorkflowStartOptions & {
-    args: ClientInferInput<TContract["workflows"][TWorkflowName]>;
-  }): Future<Result<ClientInferOutput<TContract["workflows"][TWorkflowName]>, TypedClientError>>;
+  }: TypedWorkflowStartOptions<TContract, TWorkflowName>): Future<Result<ClientInferOutput<TContract["workflows"][TWorkflowName]>, WorkflowNotFoundError | WorkflowValidationError | RuntimeClientError>>;
   /**
    * Get a handle to an existing workflow with Future/Result pattern
    *
@@ -278,8 +280,8 @@ declare class TypedClient<TContract extends ContractDefinition> {
    * });
    * ```
    */
-  getHandle<TWorkflowName extends keyof TContract["workflows"]>(workflowName: TWorkflowName, workflowId: string): Future<Result<TypedWorkflowHandle<TContract["workflows"][TWorkflowName]>, TypedClientError>>;
+  getHandle<TWorkflowName extends keyof TContract["workflows"]>(workflowName: TWorkflowName, workflowId: string): Future<Result<TypedWorkflowHandle<TContract["workflows"][TWorkflowName]>, WorkflowNotFoundError | RuntimeClientError>>;
   private createTypedHandle;
 }
 //#endregion
-export { type ClientInferActivities, type ClientInferActivity, type ClientInferInput, type ClientInferOutput, type ClientInferQuery, type ClientInferSignal, type ClientInferUpdate, type ClientInferWorkflow, type ClientInferWorkflowActivities, type ClientInferWorkflowContextActivities, type ClientInferWorkflowQueries, type ClientInferWorkflowSignals, type ClientInferWorkflowUpdates, type ClientInferWorkflows, QueryValidationError, SignalValidationError, TypedClient, TypedClientError, type TypedWorkflowHandle, type TypedWorkflowStartOptions, UpdateValidationError, WorkflowNotFoundError, WorkflowValidationError };
+export { type ClientInferActivities, type ClientInferActivity, type ClientInferInput, type ClientInferOutput, type ClientInferQuery, type ClientInferSignal, type ClientInferUpdate, type ClientInferWorkflow, type ClientInferWorkflowActivities, type ClientInferWorkflowContextActivities, type ClientInferWorkflowQueries, type ClientInferWorkflowSignals, type ClientInferWorkflowUpdates, type ClientInferWorkflows, QueryValidationError, SignalValidationError, TypedClient, type TypedWorkflowHandle, type TypedWorkflowStartOptions, UpdateValidationError, WorkflowNotFoundError, WorkflowValidationError };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { ClientOptions, WorkflowHandle, WorkflowOptions, WorkflowStartOptions } from "@temporalio/client";
-import { Future, Result } from "@temporal-contract/boxed";
+import { Future, Result } from "@swan-io/boxed";
+import { Client, WorkflowHandle, WorkflowStartOptions } from "@temporalio/client";
 import { ActivityDefinition, AnySchema, ContractDefinition, QueryDefinition, SignalDefinition, UpdateDefinition, WorkflowDefinition } from "@temporal-contract/contract";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
@@ -85,8 +85,16 @@ type ClientInferWorkflowContextActivities<TContract extends ContractDefinition,
 /**
  * Base class for all typed client errors with boxed pattern
  */
-declare class TypedClientError extends Error {
-  constructor(message: string);
+declare abstract class TypedClientError extends Error {
+  protected constructor(message: string);
+}
+/**
+ * Generic runtime failure wrapper when no specific error type applies
+ */
+declare class RuntimeClientError extends TypedClientError {
+  readonly operation: string;
+  readonly cause?: unknown | undefined;
+  constructor(operation: string, cause?: unknown | undefined);
 }
 /**
  * Thrown when a workflow is not found in the contract
@@ -133,11 +141,9 @@ declare class UpdateValidationError extends TypedClientError {
 }
 //#endregion
 //#region src/client.d.ts
-/**
- * Extended options for starting workflows with Temporal-specific features
- * Combines required workflowId with optional Temporal workflow options
- */
-type TypedWorkflowStartOptions = Pick<WorkflowStartOptions, "workflowId" | "workflowIdReusePolicy" | "workflowExecutionTimeout" | "workflowRunTimeout" | "workflowTaskTimeout" | "retry" | "memo" | "searchAttributes" | "cronSchedule"> & Pick<WorkflowOptions, "workflowId">;
+type TypedWorkflowStartOptions<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = Omit<WorkflowStartOptions, "taskQueue" | "args"> & {
+  args: ClientInferInput<TContract["workflows"][TWorkflowName]>;
+};
 /**
  * Typed workflow handle with validated results using Result/Future pattern
  */
@@ -147,37 +153,37 @@ interface TypedWorkflowHandle<TWorkflow extends WorkflowDefinition> {
    * Type-safe queries based on workflow definition with Result pattern
    * Each query returns Future<Result<T, Error>> instead of Promise<T>
    */
-  queries: { [K in keyof ClientInferWorkflowQueries<TWorkflow>]: ClientInferWorkflowQueries<TWorkflow>[K] extends ((...args: infer Args) => Future<Result<infer R, Error>>) ? (...args: Args) => Future<Result<R, TypedClientError>> : never };
+  queries: { [K in keyof ClientInferWorkflowQueries<TWorkflow>]: ClientInferWorkflowQueries<TWorkflow>[K] extends ((...args: infer Args) => Future<Result<infer R, Error>>) ? (...args: Args) => Future<Result<R, QueryValidationError | RuntimeClientError>> : never };
   /**
    * Type-safe signals based on workflow definition with Result pattern
    * Each signal returns Future<Result<void, Error>> instead of Promise<void>
    */
-  signals: { [K in keyof ClientInferWorkflowSignals<TWorkflow>]: ClientInferWorkflowSignals<TWorkflow>[K] extends ((...args: infer Args) => Future<Result<void, Error>>) ? (...args: Args) => Future<Result<void, TypedClientError>> : never };
+  signals: { [K in keyof ClientInferWorkflowSignals<TWorkflow>]: ClientInferWorkflowSignals<TWorkflow>[K] extends ((...args: infer Args) => Future<Result<void, Error>>) ? (...args: Args) => Future<Result<void, SignalValidationError | RuntimeClientError>> : never };
   /**
    * Type-safe updates based on workflow definition with Result pattern
    * Each update returns Future<Result<T, Error>> instead of Promise<T>
    */
-  updates: { [K in keyof ClientInferWorkflowUpdates<TWorkflow>]: ClientInferWorkflowUpdates<TWorkflow>[K] extends ((...args: infer Args) => Future<Result<infer R, Error>>) ? (...args: Args) => Future<Result<R, TypedClientError>> : never };
+  updates: { [K in keyof ClientInferWorkflowUpdates<TWorkflow>]: ClientInferWorkflowUpdates<TWorkflow>[K] extends ((...args: infer Args) => Future<Result<infer R, Error>>) ? (...args: Args) => Future<Result<R, UpdateValidationError | RuntimeClientError>> : never };
   /**
    * Get workflow result with Result pattern
    */
-  result: () => Future<Result<ClientInferOutput<TWorkflow>, TypedClientError>>;
+  result: () => Future<Result<ClientInferOutput<TWorkflow>, WorkflowValidationError | RuntimeClientError>>;
   /**
    * Terminate workflow with Result pattern
    */
-  terminate: (reason?: string) => Future<Result<void, TypedClientError>>;
+  terminate: (reason?: string) => Future<Result<void, RuntimeClientError>>;
   /**
    * Cancel workflow with Result pattern
    */
-  cancel: () => Future<Result<void, TypedClientError>>;
+  cancel: () => Future<Result<void, RuntimeClientError>>;
   /**
    * Get workflow execution description including status and metadata
    */
-  describe: () => Future<Result<Awaited<ReturnType<WorkflowHandle["describe"]>>, TypedClientError>>;
+  describe: () => Future<Result<Awaited<ReturnType<WorkflowHandle["describe"]>>, RuntimeClientError>>;
   /**
    * Fetch the workflow execution history
    */
-  fetchHistory: () => ReturnType<WorkflowHandle["fetchHistory"]>;
+  fetchHistory: () => Future<Result<Awaited<ReturnType<WorkflowHandle["fetchHistory"]>>, RuntimeClientError>>;
 }
 /**
  * Typed Temporal client with Result/Future pattern based on a contract
@@ -211,7 +217,7 @@ declare class TypedClient<TContract extends ContractDefinition> {
    * });
    * ```
    */
-  static create<TContract extends ContractDefinition>(contract: TContract, options: ClientOptions): TypedClient<TContract>;
+  static create<TContract extends ContractDefinition>(contract: TContract, client: Client): TypedClient<TContract>;
   /**
    * Start a workflow and return a typed handle with Future pattern
    *
@@ -236,9 +242,7 @@ declare class TypedClient<TContract extends ContractDefinition> {
   startWorkflow<TWorkflowName extends keyof TContract["workflows"]>(workflowName: TWorkflowName, {
     args,
     ...temporalOptions
-  }: TypedWorkflowStartOptions & {
-    args: ClientInferInput<TContract["workflows"][TWorkflowName]>;
-  }): Future<Result<TypedWorkflowHandle<TContract["workflows"][TWorkflowName]>, TypedClientError>>;
+  }: TypedWorkflowStartOptions<TContract, TWorkflowName>): Future<Result<TypedWorkflowHandle<TContract["workflows"][TWorkflowName]>, WorkflowNotFoundError | WorkflowValidationError | RuntimeClientError>>;
   /**
    * Execute a workflow (start and wait for result) with Future/Result pattern
    *
@@ -260,9 +264,7 @@ declare class TypedClient<TContract extends ContractDefinition> {
   executeWorkflow<TWorkflowName extends keyof TContract["workflows"]>(workflowName: TWorkflowName, {
     args,
     ...temporalOptions
-  }: TypedWorkflowStartOptions & {
-    args: ClientInferInput<TContract["workflows"][TWorkflowName]>;
-  }): Future<Result<ClientInferOutput<TContract["workflows"][TWorkflowName]>, TypedClientError>>;
+  }: TypedWorkflowStartOptions<TContract, TWorkflowName>): Future<Result<ClientInferOutput<TContract["workflows"][TWorkflowName]>, WorkflowNotFoundError | WorkflowValidationError | RuntimeClientError>>;
   /**
    * Get a handle to an existing workflow with Future/Result pattern
    *
@@ -278,8 +280,8 @@ declare class TypedClient<TContract extends ContractDefinition> {
    * });
    * ```
    */
-  getHandle<TWorkflowName extends keyof TContract["workflows"]>(workflowName: TWorkflowName, workflowId: string): Future<Result<TypedWorkflowHandle<TContract["workflows"][TWorkflowName]>, TypedClientError>>;
+  getHandle<TWorkflowName extends keyof TContract["workflows"]>(workflowName: TWorkflowName, workflowId: string): Future<Result<TypedWorkflowHandle<TContract["workflows"][TWorkflowName]>, WorkflowNotFoundError | RuntimeClientError>>;
   private createTypedHandle;
 }
 //#endregion
-export { type ClientInferActivities, type ClientInferActivity, type ClientInferInput, type ClientInferOutput, type ClientInferQuery, type ClientInferSignal, type ClientInferUpdate, type ClientInferWorkflow, type ClientInferWorkflowActivities, type ClientInferWorkflowContextActivities, type ClientInferWorkflowQueries, type ClientInferWorkflowSignals, type ClientInferWorkflowUpdates, type ClientInferWorkflows, QueryValidationError, SignalValidationError, TypedClient, TypedClientError, type TypedWorkflowHandle, type TypedWorkflowStartOptions, UpdateValidationError, WorkflowNotFoundError, WorkflowValidationError };
+export { type ClientInferActivities, type ClientInferActivity, type ClientInferInput, type ClientInferOutput, type ClientInferQuery, type ClientInferSignal, type ClientInferUpdate, type ClientInferWorkflow, type ClientInferWorkflowActivities, type ClientInferWorkflowContextActivities, type ClientInferWorkflowQueries, type ClientInferWorkflowSignals, type ClientInferWorkflowUpdates, type ClientInferWorkflows, QueryValidationError, SignalValidationError, TypedClient, type TypedWorkflowHandle, type TypedWorkflowStartOptions, UpdateValidationError, WorkflowNotFoundError, WorkflowValidationError };

package/dist/index.mjs

@@ -1,5 +1,4 @@
-import { Client } from "@temporalio/client";
-import { Future, Result } from "@temporal-contract/boxed";
+import { Future, Result } from "@swan-io/boxed";
 
 //#region src/errors.ts
 /**
@@ -13,6 +12,16 @@ var TypedClientError = class extends Error {
 	}
 };
 /**
+* Generic runtime failure wrapper when no specific error type applies
+*/
+var RuntimeClientError = class extends TypedClientError {
+	constructor(operation, cause) {
+		super(`Operation "${operation}" failed: ${cause instanceof Error ? cause.message : String(cause ?? "unknown error")}`);
+		this.operation = operation;
+		this.cause = cause;
+	}
+};
+/**
 * Thrown when a workflow is not found in the contract
 */
 var WorkflowNotFoundError = class extends TypedClientError {
@@ -101,8 +110,8 @@ var TypedClient = class TypedClient {
 	* });
 	* ```
 	*/
-	static create(contract, options) {
-		return new TypedClient(contract, new Client(options));
+	static create(contract, client) {
+		return new TypedClient(contract, client);
 	}
 	/**
 	* Start a workflow and return a typed handle with Future pattern
@@ -127,15 +136,15 @@ var TypedClient = class TypedClient {
 	*/
 	startWorkflow(workflowName, { args, ...temporalOptions }) {
 		return Future.make((resolve) => {
-			const definition = this.contract.workflows[workflowName];
-			if (!definition) {
-				resolve(Result.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
-				return;
-			}
 			(async () => {
+				const definition = this.contract.workflows[workflowName];
+				if (!definition) {
+					resolve(Result.Error(createWorkflowNotFoundError(workflowName, this.contract)));
+					return;
+				}
 				const inputResult = await definition.input["~standard"].validate(args);
 				if (inputResult.issues) {
-					resolve(Result.Error(new WorkflowValidationError(String(workflowName), "input", inputResult.issues)));
+					resolve(Result.Error(createWorkflowValidationError(workflowName, "input", inputResult.issues)));
 					return;
 				}
 				const validatedInput = inputResult.value;
@@ -148,7 +157,7 @@ var TypedClient = class TypedClient {
 					const typedHandle = this.createTypedHandle(handle, definition);
 					resolve(Result.Ok(typedHandle));
 				} catch (error) {
-					resolve(Result.Error(new TypedClientError(`Failed to start workflow: ${error instanceof Error ? error.message : String(error)}`)));
+					resolve(Result.Error(createRuntimeClientError("startWorkflow", error)));
 				}
 			})();
 		});
@@ -173,15 +182,15 @@ var TypedClient = class TypedClient {
 	*/
 	executeWorkflow(workflowName, { args, ...temporalOptions }) {
 		return Future.make((resolve) => {
-			const definition = this.contract.workflows[workflowName];
-			if (!definition) {
-				resolve(Result.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
-				return;
-			}
 			(async () => {
+				const definition = this.contract.workflows[workflowName];
+				if (!definition) {
+					resolve(Result.Error(createWorkflowNotFoundError(workflowName, this.contract)));
+					return;
+				}
 				const inputResult = await definition.input["~standard"].validate(args);
 				if (inputResult.issues) {
-					resolve(Result.Error(new WorkflowValidationError(String(workflowName), "input", inputResult.issues)));
+					resolve(Result.Error(createWorkflowValidationError(workflowName, "input", inputResult.issues)));
 					return;
 				}
 				const validatedInput = inputResult.value;
@@ -193,12 +202,12 @@ var TypedClient = class TypedClient {
 					});
 					const outputResult = await definition.output["~standard"].validate(result);
 					if (outputResult.issues) {
-						resolve(Result.Error(new WorkflowValidationError(String(workflowName), "output", outputResult.issues)));
+						resolve(Result.Error(createWorkflowValidationError(workflowName, "output", outputResult.issues)));
 						return;
 					}
 					resolve(Result.Ok(outputResult.value));
 				} catch (error) {
-					resolve(Result.Error(new TypedClientError(`Failed to execute workflow: ${error instanceof Error ? error.message : String(error)}`)));
+					resolve(Result.Error(createRuntimeClientError("executeWorkflow", error)));
 				}
 			})();
 		});
@@ -222,7 +231,7 @@ var TypedClient = class TypedClient {
 		return Future.make((resolve) => {
 			const definition = this.contract.workflows[workflowName];
 			if (!definition) {
-				resolve(Result.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
+				resolve(Result.Error(createWorkflowNotFoundError(workflowName, this.contract)));
 				return;
 			}
 			try {
@@ -230,11 +239,11 @@ var TypedClient = class TypedClient {
 				const typedHandle = this.createTypedHandle(handle, definition);
 				resolve(Result.Ok(typedHandle));
 			} catch (error) {
-				resolve(Result.Error(new TypedClientError(`Failed to get workflow handle: ${error instanceof Error ? error.message : String(error)}`)));
+				resolve(Result.Error(createRuntimeClientError("getHandle", error)));
 			}
 		});
 	}
-	createTypedHandle(handle, definition) {
+	createTypedHandle(workflowHandle, definition) {
 		const queries = {};
 		for (const [queryName, queryDef] of Object.entries(definition.queries ?? {})) queries[queryName] = (args) => {
 			return Future.make((resolve) => {
@@ -245,7 +254,7 @@ var TypedClient = class TypedClient {
 						return;
 					}
 					try {
-						const result = await handle.query(queryName, inputResult.value);
+						const result = await workflowHandle.query(queryName, inputResult.value);
 						const outputResult = await queryDef.output["~standard"].validate(result);
 						if (outputResult.issues) {
 							resolve(Result.Error(new QueryValidationError(queryName, "output", outputResult.issues)));
@@ -253,7 +262,7 @@ var TypedClient = class TypedClient {
 						}
 						resolve(Result.Ok(outputResult.value));
 					} catch (error) {
-						resolve(Result.Error(new TypedClientError(`Query failed: ${error instanceof Error ? error.message : String(error)}`)));
+						resolve(Result.Error(createRuntimeClientError("query", error)));
 					}
 				})();
 			});
@@ -268,10 +277,10 @@ var TypedClient = class TypedClient {
 						return;
 					}
 					try {
-						await handle.signal(signalName, inputResult.value);
+						await workflowHandle.signal(signalName, inputResult.value);
 						resolve(Result.Ok(void 0));
 					} catch (error) {
-						resolve(Result.Error(new TypedClientError(`Signal failed: ${error instanceof Error ? error.message : String(error)}`)));
+						resolve(Result.Error(createRuntimeClientError("signal", error)));
 					}
 				})();
 			});
@@ -286,7 +295,7 @@ var TypedClient = class TypedClient {
 						return;
 					}
 					try {
-						const result = await handle.executeUpdate(updateName, { args: [inputResult.value] });
+						const result = await workflowHandle.executeUpdate(updateName, { args: [inputResult.value] });
 						const outputResult = await updateDef.output["~standard"].validate(result);
 						if (outputResult.issues) {
 							resolve(Result.Error(new UpdateValidationError(updateName, "output", outputResult.issues)));
@@ -294,13 +303,13 @@ var TypedClient = class TypedClient {
 						}
 						resolve(Result.Ok(outputResult.value));
 					} catch (error) {
-						resolve(Result.Error(new TypedClientError(`Update failed: ${error instanceof Error ? error.message : String(error)}`)));
+						resolve(Result.Error(createRuntimeClientError("update", error)));
 					}
 				})();
 			});
 		};
 		return {
-			workflowId: handle.workflowId,
+			workflowId: workflowHandle.workflowId,
 			queries,
 			signals,
 			updates,
@@ -308,59 +317,43 @@ var TypedClient = class TypedClient {
 				return Future.make((resolve) => {
 					(async () => {
 						try {
-							const result = await handle.result();
+							const result = await workflowHandle.result();
 							const outputResult = await definition.output["~standard"].validate(result);
 							if (outputResult.issues) {
-								resolve(Result.Error(new WorkflowValidationError(handle.workflowId, "output", outputResult.issues)));
+								resolve(Result.Error(new WorkflowValidationError(workflowHandle.workflowId, "output", outputResult.issues)));
 								return;
 							}
 							resolve(Result.Ok(outputResult.value));
 						} catch (error) {
-							resolve(Result.Error(new TypedClientError(`Workflow execution failed: ${error instanceof Error ? error.message : String(error)}`)));
+							resolve(Result.Error(createRuntimeClientError("result", error)));
 						}
 					})();
 				});
 			},
 			terminate: (reason) => {
-				return Future.make((resolve) => {
-					(async () => {
-						try {
-							await handle.terminate(reason);
-							resolve(Result.Ok(void 0));
-						} catch (error) {
-							resolve(Result.Error(new TypedClientError(`Terminate failed: ${error instanceof Error ? error.message : String(error)}`)));
-						}
-					})();
-				});
+				return Future.fromPromise(workflowHandle.terminate(reason)).mapError((error) => createRuntimeClientError("terminate", error)).mapOk(() => void 0);
 			},
 			cancel: () => {
-				return Future.make((resolve) => {
-					(async () => {
-						try {
-							await handle.cancel();
-							resolve(Result.Ok(void 0));
-						} catch (error) {
-							resolve(Result.Error(new TypedClientError(`Cancel failed: ${error instanceof Error ? error.message : String(error)}`)));
-						}
-					})();
-				});
+				return Future.fromPromise(workflowHandle.cancel()).mapError((error) => createRuntimeClientError("cancel", error)).mapOk(() => void 0);
 			},
 			describe: () => {
-				return Future.make((resolve) => {
-					(async () => {
-						try {
-							const description = await handle.describe();
-							resolve(Result.Ok(description));
-						} catch (error) {
-							resolve(Result.Error(new TypedClientError(`Describe failed: ${error instanceof Error ? error.message : String(error)}`)));
-						}
-					})();
-				});
+				return Future.fromPromise(workflowHandle.describe()).mapError((error) => createRuntimeClientError("describe", error));
 			},
-			fetchHistory: () => handle.fetchHistory()
+			fetchHistory: () => {
+				return Future.fromPromise(workflowHandle.fetchHistory()).mapError((error) => createRuntimeClientError("fetchHistory", error));
+			}
 		};
 	}
 };
+function createRuntimeClientError(operation, error) {
+	return new RuntimeClientError(operation, error);
+}
+function createWorkflowNotFoundError(workflowName, contract) {
+	return new WorkflowNotFoundError(String(workflowName), Object.keys(contract.workflows));
+}
+function createWorkflowValidationError(workflowName, direction, issues) {
+	return new WorkflowValidationError(String(workflowName), direction, issues);
+}
 
 //#endregion
-export { QueryValidationError, SignalValidationError, TypedClient, TypedClientError, UpdateValidationError, WorkflowNotFoundError, WorkflowValidationError };
+export { QueryValidationError, SignalValidationError, TypedClient, UpdateValidationError, WorkflowNotFoundError, WorkflowValidationError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporal-contract/client",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Client utilities with Result/Future pattern for consuming temporal-contract workflows",
   "keywords": [
     "client",
@@ -20,7 +20,7 @@
     "directory": "packages/client"
   },
   "license": "MIT",
-  "author": "Benoit TRAVERS <benoit.travers.frgmail.com>",
+  "author": "Benoit TRAVERS <benoit.travers.fr@gmail.com>",
   "type": "module",
   "exports": {
     ".": {
@@ -43,18 +43,21 @@
   ],
   "dependencies": {
     "@standard-schema/spec": "1.1.0",
-    "@temporal-contract/boxed": "0.0.5",
-    "@temporal-contract/contract": "0.0.5"
+    "@swan-io/boxed": "3.2.1",
+    "@temporal-contract/contract": "0.0.7"
   },
   "devDependencies": {
-    "@temporalio/client": "1.13.2",
-    "@types/node": "25.0.2",
+    "@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.0",
+    "tsdown": "0.18.1",
     "typescript": "5.9.3",
     "vitest": "4.0.16",
     "zod": "4.2.1",
-    "@temporal-contract/tsconfig": "0.0.5"
+    "@temporal-contract/testing": "0.0.7",
+    "@temporal-contract/tsconfig": "0.0.7"
   },
   "peerDependencies": {
     "@temporalio/client": "^1"
@@ -62,8 +65,9 @@
   "scripts": {
     "build": "tsdown src/index.ts --format cjs,esm --dts --clean",
     "dev": "tsdown src/index.ts --format cjs,esm --dts --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
+    "test": "vitest run --project unit",
+    "test:integration": "vitest run --project integration",
+    "test:watch": "vitest --project unit",
     "typecheck": "tsc --noEmit"
   }
 }