@temporal-contract/client 0.0.4 → 0.0.6

package/dist/index.cjs

@@ -1,5 +1,4 @@
-let __temporalio_client = require("@temporalio/client");
-let __swan_io_boxed = require("@swan-io/boxed");
+let _temporal_contract_boxed = require("@temporal-contract/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 {
@@ -93,7 +102,7 @@ var TypedClient = class TypedClient {
 	* const result = await client.executeWorkflow('processOrder', {
 	*   workflowId: 'order-123',
 	*   args: { ... },
-	* }).toPromise();
+	* });
 	*
 	* result.match({
 	*   Ok: (output) => console.log('Success:', output),
@@ -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
@@ -114,11 +123,11 @@ var TypedClient = class TypedClient {
 	*   args: { orderId: 'ORD-123' },
 	*   workflowExecutionTimeout: '1 day',
 	*   retry: { maximumAttempts: 3 },
-	* }).toPromise();
+	* });
 	*
 	* handleResult.match({
 	*   Ok: async (handle) => {
-	*     const result = await handle.result().toPromise();
+	*     const result = await handle.result();
 	*     // ... handle result
 	*   },
 	*   Error: (error) => console.error('Failed to start:', error),
@@ -126,16 +135,16 @@ var TypedClient = class TypedClient {
 	* ```
 	*/
 	startWorkflow(workflowName, { args, ...temporalOptions }) {
-		return __swan_io_boxed.Future.make((resolve) => {
-			const definition = this.contract.workflows[workflowName];
-			if (!definition) {
-				resolve(__swan_io_boxed.Result.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
-				return;
-			}
+		return _temporal_contract_boxed.Future.make((resolve) => {
 			(async () => {
+				const definition = this.contract.workflows[workflowName];
+				if (!definition) {
+					resolve(_temporal_contract_boxed.Result.Error(createWorkflowNotFoundError(workflowName, this.contract)));
+					return;
+				}
 				const inputResult = await definition.input["~standard"].validate(args);
 				if (inputResult.issues) {
-					resolve(__swan_io_boxed.Result.Error(new WorkflowValidationError(String(workflowName), "input", inputResult.issues)));
+					resolve(_temporal_contract_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(__swan_io_boxed.Result.Ok(typedHandle));
+					resolve(_temporal_contract_boxed.Result.Ok(typedHandle));
 				} catch (error) {
-					resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Failed to start workflow: ${error instanceof Error ? error.message : String(error)}`)));
+					resolve(_temporal_contract_boxed.Result.Error(createRuntimeClientError("startWorkflow", error)));
 				}
 			})();
 		});
@@ -163,7 +172,7 @@ var TypedClient = class TypedClient {
 	*   args: { orderId: 'ORD-123' },
 	*   workflowExecutionTimeout: '1 day',
 	*   retry: { maximumAttempts: 3 },
-	* }).toPromise();
+	* });
 	*
 	* result.match({
 	*   Ok: (output) => console.log('Order processed:', output.status),
@@ -172,16 +181,16 @@ var TypedClient = class TypedClient {
 	* ```
 	*/
 	executeWorkflow(workflowName, { args, ...temporalOptions }) {
-		return __swan_io_boxed.Future.make((resolve) => {
-			const definition = this.contract.workflows[workflowName];
-			if (!definition) {
-				resolve(__swan_io_boxed.Result.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
-				return;
-			}
+		return _temporal_contract_boxed.Future.make((resolve) => {
 			(async () => {
+				const definition = this.contract.workflows[workflowName];
+				if (!definition) {
+					resolve(_temporal_contract_boxed.Result.Error(createWorkflowNotFoundError(workflowName, this.contract)));
+					return;
+				}
 				const inputResult = await definition.input["~standard"].validate(args);
 				if (inputResult.issues) {
-					resolve(__swan_io_boxed.Result.Error(new WorkflowValidationError(String(workflowName), "input", inputResult.issues)));
+					resolve(_temporal_contract_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(__swan_io_boxed.Result.Error(new WorkflowValidationError(String(workflowName), "output", outputResult.issues)));
+						resolve(_temporal_contract_boxed.Result.Error(createWorkflowValidationError(workflowName, "output", outputResult.issues)));
 						return;
 					}
-					resolve(__swan_io_boxed.Result.Ok(outputResult.value));
+					resolve(_temporal_contract_boxed.Result.Ok(outputResult.value));
 				} catch (error) {
-					resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Failed to execute workflow: ${error instanceof Error ? error.message : String(error)}`)));
+					resolve(_temporal_contract_boxed.Result.Error(createRuntimeClientError("executeWorkflow", error)));
 				}
 			})();
 		});
@@ -208,10 +217,10 @@ var TypedClient = class TypedClient {
 	*
 	* @example
 	* ```ts
-	* const handleResult = await client.getHandle('processOrder', 'order-123').toPromise();
+	* const handleResult = await client.getHandle('processOrder', 'order-123');
 	* handleResult.match({
 	*   Ok: async (handle) => {
-	*     const result = await handle.result().toPromise();
+	*     const result = await handle.result();
 	*     // ... handle result
 	*   },
 	*   Error: (error) => console.error('Failed to get handle:', error),
@@ -219,178 +228,137 @@ var TypedClient = class TypedClient {
 	* ```
 	*/
 	getHandle(workflowName, workflowId) {
-		return __swan_io_boxed.Future.make((resolve) => {
+		return _temporal_contract_boxed.Future.make((resolve) => {
 			const definition = this.contract.workflows[workflowName];
 			if (!definition) {
-				resolve(__swan_io_boxed.Result.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
+				resolve(_temporal_contract_boxed.Result.Error(createWorkflowNotFoundError(workflowName, this.contract)));
 				return;
 			}
 			try {
 				const handle = this.client.workflow.getHandle(workflowId);
 				const typedHandle = this.createTypedHandle(handle, definition);
-				resolve(__swan_io_boxed.Result.Ok(typedHandle));
+				resolve(_temporal_contract_boxed.Result.Ok(typedHandle));
 			} catch (error) {
-				resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Failed to get workflow handle: ${error instanceof Error ? error.message : String(error)}`)));
+				resolve(_temporal_contract_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 __swan_io_boxed.Future.make((resolve) => {
+			return _temporal_contract_boxed.Future.make((resolve) => {
 				(async () => {
 					const inputResult = await queryDef.input["~standard"].validate(args);
 					if (inputResult.issues) {
-						resolve(__swan_io_boxed.Result.Error(new QueryValidationError(queryName, "input", inputResult.issues)));
+						resolve(_temporal_contract_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(__swan_io_boxed.Result.Error(new QueryValidationError(queryName, "output", outputResult.issues)));
+							resolve(_temporal_contract_boxed.Result.Error(new QueryValidationError(queryName, "output", outputResult.issues)));
 							return;
 						}
-						resolve(__swan_io_boxed.Result.Ok(outputResult.value));
+						resolve(_temporal_contract_boxed.Result.Ok(outputResult.value));
 					} catch (error) {
-						resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Query failed: ${error instanceof Error ? error.message : String(error)}`)));
+						resolve(_temporal_contract_boxed.Result.Error(createRuntimeClientError("query", error)));
 					}
 				})();
 			});
 		};
 		const signals = {};
 		for (const [signalName, signalDef] of Object.entries(definition.signals ?? {})) signals[signalName] = (args) => {
-			return __swan_io_boxed.Future.make((resolve) => {
+			return _temporal_contract_boxed.Future.make((resolve) => {
 				(async () => {
 					const inputResult = await signalDef.input["~standard"].validate(args);
 					if (inputResult.issues) {
-						resolve(__swan_io_boxed.Result.Error(new SignalValidationError(signalName, inputResult.issues)));
+						resolve(_temporal_contract_boxed.Result.Error(new SignalValidationError(signalName, inputResult.issues)));
 						return;
 					}
 					try {
-						await handle.signal(signalName, inputResult.value);
-						resolve(__swan_io_boxed.Result.Ok(void 0));
+						await workflowHandle.signal(signalName, inputResult.value);
+						resolve(_temporal_contract_boxed.Result.Ok(void 0));
 					} catch (error) {
-						resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Signal failed: ${error instanceof Error ? error.message : String(error)}`)));
+						resolve(_temporal_contract_boxed.Result.Error(createRuntimeClientError("signal", error)));
 					}
 				})();
 			});
 		};
 		const updates = {};
 		for (const [updateName, updateDef] of Object.entries(definition.updates ?? {})) updates[updateName] = (args) => {
-			return __swan_io_boxed.Future.make((resolve) => {
+			return _temporal_contract_boxed.Future.make((resolve) => {
 				(async () => {
 					const inputResult = await updateDef.input["~standard"].validate(args);
 					if (inputResult.issues) {
-						resolve(__swan_io_boxed.Result.Error(new UpdateValidationError(updateName, "input", inputResult.issues)));
+						resolve(_temporal_contract_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(__swan_io_boxed.Result.Error(new UpdateValidationError(updateName, "output", outputResult.issues)));
+							resolve(_temporal_contract_boxed.Result.Error(new UpdateValidationError(updateName, "output", outputResult.issues)));
 							return;
 						}
-						resolve(__swan_io_boxed.Result.Ok(outputResult.value));
+						resolve(_temporal_contract_boxed.Result.Ok(outputResult.value));
 					} catch (error) {
-						resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Update failed: ${error instanceof Error ? error.message : String(error)}`)));
+						resolve(_temporal_contract_boxed.Result.Error(createRuntimeClientError("update", error)));
 					}
 				})();
 			});
 		};
 		return {
-			workflowId: handle.workflowId,
+			workflowId: workflowHandle.workflowId,
 			queries,
 			signals,
 			updates,
 			result: () => {
-				return __swan_io_boxed.Future.make((resolve) => {
+				return _temporal_contract_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(__swan_io_boxed.Result.Error(new WorkflowValidationError(handle.workflowId, "output", outputResult.issues)));
+								resolve(_temporal_contract_boxed.Result.Error(new WorkflowValidationError(workflowHandle.workflowId, "output", outputResult.issues)));
 								return;
 							}
-							resolve(__swan_io_boxed.Result.Ok(outputResult.value));
+							resolve(_temporal_contract_boxed.Result.Ok(outputResult.value));
 						} catch (error) {
-							resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Workflow execution failed: ${error instanceof Error ? error.message : String(error)}`)));
+							resolve(_temporal_contract_boxed.Result.Error(createRuntimeClientError("result", error)));
 						}
 					})();
 				});
 			},
 			terminate: (reason) => {
-				return __swan_io_boxed.Future.make((resolve) => {
-					(async () => {
-						try {
-							await handle.terminate(reason);
-							resolve(__swan_io_boxed.Result.Ok(void 0));
-						} catch (error) {
-							resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Terminate failed: ${error instanceof Error ? error.message : String(error)}`)));
-						}
-					})();
-				});
+				return _temporal_contract_boxed.Future.fromPromise(workflowHandle.terminate(reason)).mapError((error) => createRuntimeClientError("terminate", error)).mapOk(() => void 0);
 			},
 			cancel: () => {
-				return __swan_io_boxed.Future.make((resolve) => {
-					(async () => {
-						try {
-							await handle.cancel();
-							resolve(__swan_io_boxed.Result.Ok(void 0));
-						} catch (error) {
-							resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Cancel failed: ${error instanceof Error ? error.message : String(error)}`)));
-						}
-					})();
-				});
+				return _temporal_contract_boxed.Future.fromPromise(workflowHandle.cancel()).mapError((error) => createRuntimeClientError("cancel", error)).mapOk(() => void 0);
 			},
 			describe: () => {
-				return __swan_io_boxed.Future.make((resolve) => {
-					(async () => {
-						try {
-							const description = await handle.describe();
-							resolve(__swan_io_boxed.Result.Ok(description));
-						} catch (error) {
-							resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Describe failed: ${error instanceof Error ? error.message : String(error)}`)));
-						}
-					})();
-				});
+				return _temporal_contract_boxed.Future.fromPromise(workflowHandle.describe()).mapError((error) => createRuntimeClientError("describe", error));
 			},
-			fetchHistory: () => handle.fetchHistory()
+			fetchHistory: () => {
+				return _temporal_contract_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
-Object.defineProperty(exports, 'AsyncData', {
-  enumerable: true,
-  get: function () {
-    return __swan_io_boxed.AsyncData;
-  }
-});
-Object.defineProperty(exports, 'Future', {
-  enumerable: true,
-  get: function () {
-    return __swan_io_boxed.Future;
-  }
-});
-Object.defineProperty(exports, 'Option', {
-  enumerable: true,
-  get: function () {
-    return __swan_io_boxed.Option;
-  }
-});
 exports.QueryValidationError = QueryValidationError;
-Object.defineProperty(exports, 'Result', {
-  enumerable: true,
-  get: function () {
-    return __swan_io_boxed.Result;
-  }
-});
 exports.SignalValidationError = SignalValidationError;
 exports.TypedClient = TypedClient;
-exports.TypedClientError = TypedClientError;
 exports.UpdateValidationError = UpdateValidationError;
 exports.WorkflowNotFoundError = WorkflowNotFoundError;
 exports.WorkflowValidationError = WorkflowValidationError;

package/dist/index.d.cts

@@ -1,14 +1,100 @@
-import { ClientOptions, WorkflowHandle, WorkflowOptions, WorkflowStartOptions } from "@temporalio/client";
-import { ClientInferInput, ClientInferOutput, ClientInferWorkflowQueries, ClientInferWorkflowSignals, ClientInferWorkflowUpdates, ContractDefinition, WorkflowDefinition } from "@temporal-contract/contract";
-import { AsyncData, Future, Future as Future$1, Option, Result, Result as Result$1 } 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";
+import { Future, Result } from "@temporal-contract/boxed";
 
+//#region src/types.d.ts
+
+/**
+ * Infer input type from a definition (client perspective)
+ * Client sends the input type (before input schema parsing/transformation)
+ */
+type ClientInferInput<T extends {
+  input: AnySchema;
+}> = StandardSchemaV1.InferInput<T["input"]>;
+/**
+ * Infer output type from a definition (client perspective)
+ * Client receives the output type (after output schema parsing/transformation)
+ */
+type ClientInferOutput<T extends {
+  output: AnySchema;
+}> = StandardSchemaV1.InferOutput<T["output"]>;
+/**
+ * CLIENT PERSPECTIVE
+ * Client sends z.output and receives z.input
+ */
+/**
+ * Infer workflow function signature from client perspective
+ * Client sends z.output and receives z.input
+ */
+type ClientInferWorkflow<TWorkflow extends WorkflowDefinition> = (args: ClientInferInput<TWorkflow>) => Promise<ClientInferOutput<TWorkflow>>;
+/**
+ * Infer activity function signature from client perspective
+ * Client sends z.output and receives z.input
+ */
+type ClientInferActivity<TActivity extends ActivityDefinition> = (args: ClientInferInput<TActivity>) => Promise<ClientInferOutput<TActivity>>;
+/**
+ * Infer signal handler signature from client perspective
+ * Client sends z.output and returns Future<Result<void, Error>>
+ */
+type ClientInferSignal<TSignal extends SignalDefinition> = (args: ClientInferInput<TSignal>) => Future<Result<void, Error>>;
+/**
+ * Infer query handler signature from client perspective
+ * Client sends z.output and receives z.input wrapped in Future<Result<T, Error>>
+ */
+type ClientInferQuery<TQuery extends QueryDefinition> = (args: ClientInferInput<TQuery>) => Future<Result<ClientInferOutput<TQuery>, Error>>;
+/**
+ * Infer update handler signature from client perspective
+ * Client sends z.output and receives z.input wrapped in Future<Result<T, Error>>
+ */
+type ClientInferUpdate<TUpdate extends UpdateDefinition> = (args: ClientInferInput<TUpdate>) => Future<Result<ClientInferOutput<TUpdate>, Error>>;
+/**
+ * CLIENT PERSPECTIVE - Contract-level types
+ */
+/**
+ * Infer all workflows from a contract (client perspective)
+ */
+type ClientInferWorkflows<TContract extends ContractDefinition> = { [K in keyof TContract["workflows"]]: ClientInferWorkflow<TContract["workflows"][K]> };
+/**
+ * Infer all activities from a contract (client perspective)
+ */
+type ClientInferActivities<TContract extends ContractDefinition> = TContract["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof TContract["activities"]]: ClientInferActivity<TContract["activities"][K]> } : {};
+/**
+ * Infer activities from a workflow definition (client perspective)
+ */
+type ClientInferWorkflowActivities<T extends WorkflowDefinition> = T["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof T["activities"]]: ClientInferActivity<T["activities"][K]> } : {};
+/**
+ * Infer signals from a workflow definition (client perspective)
+ */
+type ClientInferWorkflowSignals<T extends WorkflowDefinition> = T["signals"] extends Record<string, SignalDefinition> ? { [K in keyof T["signals"]]: ClientInferSignal<T["signals"][K]> } : {};
+/**
+ * Infer queries from a workflow definition (client perspective)
+ */
+type ClientInferWorkflowQueries<T extends WorkflowDefinition> = T["queries"] extends Record<string, QueryDefinition> ? { [K in keyof T["queries"]]: ClientInferQuery<T["queries"][K]> } : {};
+/**
+ * Infer updates from a workflow definition (client perspective)
+ */
+type ClientInferWorkflowUpdates<T extends WorkflowDefinition> = T["updates"] extends Record<string, UpdateDefinition> ? { [K in keyof T["updates"]]: ClientInferUpdate<T["updates"][K]> } : {};
+/**
+ * Infer all activities available in a workflow context (client perspective)
+ * Combines workflow-specific activities with global activities
+ */
+type ClientInferWorkflowContextActivities<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = ClientInferWorkflowActivities<TContract["workflows"][TWorkflowName]> & ClientInferActivities<TContract>;
+//#endregion
 //#region src/errors.d.ts
 /**
  * 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
@@ -55,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
  */
@@ -69,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) => Promise<infer R>) ? (...args: Args) => Future$1<Result$1<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) => Promise<void>) ? (...args: Args) => Future$1<Result$1<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) => Promise<infer R>) ? (...args: Args) => Future$1<Result$1<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$1<Result$1<ClientInferOutput<TWorkflow>, TypedClientError>>;
+  result: () => Future<Result<ClientInferOutput<TWorkflow>, WorkflowValidationError | RuntimeClientError>>;
   /**
    * Terminate workflow with Result pattern
    */
-  terminate: (reason?: string) => Future$1<Result$1<void, TypedClientError>>;
+  terminate: (reason?: string) => Future<Result<void, RuntimeClientError>>;
   /**
    * Cancel workflow with Result pattern
    */
-  cancel: () => Future$1<Result$1<void, TypedClientError>>;
+  cancel: () => Future<Result<void, RuntimeClientError>>;
   /**
    * Get workflow execution description including status and metadata
    */
-  describe: () => Future$1<Result$1<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
@@ -125,7 +209,7 @@ declare class TypedClient<TContract extends ContractDefinition> {
    * const result = await client.executeWorkflow('processOrder', {
    *   workflowId: 'order-123',
    *   args: { ... },
-   * }).toPromise();
+   * });
    *
    * result.match({
    *   Ok: (output) => console.log('Success:', output),
@@ -133,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
    *
@@ -144,11 +228,11 @@ declare class TypedClient<TContract extends ContractDefinition> {
    *   args: { orderId: 'ORD-123' },
    *   workflowExecutionTimeout: '1 day',
    *   retry: { maximumAttempts: 3 },
-   * }).toPromise();
+   * });
    *
    * handleResult.match({
    *   Ok: async (handle) => {
-   *     const result = await handle.result().toPromise();
+   *     const result = await handle.result();
    *     // ... handle result
    *   },
    *   Error: (error) => console.error('Failed to start:', error),
@@ -158,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$1<Result$1<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
    *
@@ -171,7 +253,7 @@ declare class TypedClient<TContract extends ContractDefinition> {
    *   args: { orderId: 'ORD-123' },
    *   workflowExecutionTimeout: '1 day',
    *   retry: { maximumAttempts: 3 },
-   * }).toPromise();
+   * });
    *
    * result.match({
    *   Ok: (output) => console.log('Order processed:', output.status),
@@ -182,26 +264,24 @@ declare class TypedClient<TContract extends ContractDefinition> {
   executeWorkflow<TWorkflowName extends keyof TContract["workflows"]>(workflowName: TWorkflowName, {
     args,
     ...temporalOptions
-  }: TypedWorkflowStartOptions & {
-    args: ClientInferInput<TContract["workflows"][TWorkflowName]>;
-  }): Future$1<Result$1<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
    *
    * @example
    * ```ts
-   * const handleResult = await client.getHandle('processOrder', 'order-123').toPromise();
+   * const handleResult = await client.getHandle('processOrder', 'order-123');
    * handleResult.match({
    *   Ok: async (handle) => {
-   *     const result = await handle.result().toPromise();
+   *     const result = await handle.result();
    *     // ... handle result
    *   },
    *   Error: (error) => console.error('Failed to get handle:', error),
    * });
    * ```
    */
-  getHandle<TWorkflowName extends keyof TContract["workflows"]>(workflowName: TWorkflowName, workflowId: string): Future$1<Result$1<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 { AsyncData, Future, Option, QueryValidationError, Result, 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,14 +1,100 @@
-import { ClientOptions, WorkflowHandle, WorkflowOptions, WorkflowStartOptions } from "@temporalio/client";
-import { AsyncData, Future, Future as Future$1, Option, Result, Result as Result$1 } from "@swan-io/boxed";
-import { ClientInferInput, ClientInferOutput, ClientInferWorkflowQueries, ClientInferWorkflowSignals, ClientInferWorkflowUpdates, ContractDefinition, WorkflowDefinition } from "@temporal-contract/contract";
+import { Future, Result } from "@temporal-contract/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";
 
+//#region src/types.d.ts
+
+/**
+ * Infer input type from a definition (client perspective)
+ * Client sends the input type (before input schema parsing/transformation)
+ */
+type ClientInferInput<T extends {
+  input: AnySchema;
+}> = StandardSchemaV1.InferInput<T["input"]>;
+/**
+ * Infer output type from a definition (client perspective)
+ * Client receives the output type (after output schema parsing/transformation)
+ */
+type ClientInferOutput<T extends {
+  output: AnySchema;
+}> = StandardSchemaV1.InferOutput<T["output"]>;
+/**
+ * CLIENT PERSPECTIVE
+ * Client sends z.output and receives z.input
+ */
+/**
+ * Infer workflow function signature from client perspective
+ * Client sends z.output and receives z.input
+ */
+type ClientInferWorkflow<TWorkflow extends WorkflowDefinition> = (args: ClientInferInput<TWorkflow>) => Promise<ClientInferOutput<TWorkflow>>;
+/**
+ * Infer activity function signature from client perspective
+ * Client sends z.output and receives z.input
+ */
+type ClientInferActivity<TActivity extends ActivityDefinition> = (args: ClientInferInput<TActivity>) => Promise<ClientInferOutput<TActivity>>;
+/**
+ * Infer signal handler signature from client perspective
+ * Client sends z.output and returns Future<Result<void, Error>>
+ */
+type ClientInferSignal<TSignal extends SignalDefinition> = (args: ClientInferInput<TSignal>) => Future<Result<void, Error>>;
+/**
+ * Infer query handler signature from client perspective
+ * Client sends z.output and receives z.input wrapped in Future<Result<T, Error>>
+ */
+type ClientInferQuery<TQuery extends QueryDefinition> = (args: ClientInferInput<TQuery>) => Future<Result<ClientInferOutput<TQuery>, Error>>;
+/**
+ * Infer update handler signature from client perspective
+ * Client sends z.output and receives z.input wrapped in Future<Result<T, Error>>
+ */
+type ClientInferUpdate<TUpdate extends UpdateDefinition> = (args: ClientInferInput<TUpdate>) => Future<Result<ClientInferOutput<TUpdate>, Error>>;
+/**
+ * CLIENT PERSPECTIVE - Contract-level types
+ */
+/**
+ * Infer all workflows from a contract (client perspective)
+ */
+type ClientInferWorkflows<TContract extends ContractDefinition> = { [K in keyof TContract["workflows"]]: ClientInferWorkflow<TContract["workflows"][K]> };
+/**
+ * Infer all activities from a contract (client perspective)
+ */
+type ClientInferActivities<TContract extends ContractDefinition> = TContract["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof TContract["activities"]]: ClientInferActivity<TContract["activities"][K]> } : {};
+/**
+ * Infer activities from a workflow definition (client perspective)
+ */
+type ClientInferWorkflowActivities<T extends WorkflowDefinition> = T["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof T["activities"]]: ClientInferActivity<T["activities"][K]> } : {};
+/**
+ * Infer signals from a workflow definition (client perspective)
+ */
+type ClientInferWorkflowSignals<T extends WorkflowDefinition> = T["signals"] extends Record<string, SignalDefinition> ? { [K in keyof T["signals"]]: ClientInferSignal<T["signals"][K]> } : {};
+/**
+ * Infer queries from a workflow definition (client perspective)
+ */
+type ClientInferWorkflowQueries<T extends WorkflowDefinition> = T["queries"] extends Record<string, QueryDefinition> ? { [K in keyof T["queries"]]: ClientInferQuery<T["queries"][K]> } : {};
+/**
+ * Infer updates from a workflow definition (client perspective)
+ */
+type ClientInferWorkflowUpdates<T extends WorkflowDefinition> = T["updates"] extends Record<string, UpdateDefinition> ? { [K in keyof T["updates"]]: ClientInferUpdate<T["updates"][K]> } : {};
+/**
+ * Infer all activities available in a workflow context (client perspective)
+ * Combines workflow-specific activities with global activities
+ */
+type ClientInferWorkflowContextActivities<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = ClientInferWorkflowActivities<TContract["workflows"][TWorkflowName]> & ClientInferActivities<TContract>;
+//#endregion
 //#region src/errors.d.ts
 /**
  * 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
@@ -55,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
  */
@@ -69,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) => Promise<infer R>) ? (...args: Args) => Future$1<Result$1<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) => Promise<void>) ? (...args: Args) => Future$1<Result$1<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) => Promise<infer R>) ? (...args: Args) => Future$1<Result$1<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$1<Result$1<ClientInferOutput<TWorkflow>, TypedClientError>>;
+  result: () => Future<Result<ClientInferOutput<TWorkflow>, WorkflowValidationError | RuntimeClientError>>;
   /**
    * Terminate workflow with Result pattern
    */
-  terminate: (reason?: string) => Future$1<Result$1<void, TypedClientError>>;
+  terminate: (reason?: string) => Future<Result<void, RuntimeClientError>>;
   /**
    * Cancel workflow with Result pattern
    */
-  cancel: () => Future$1<Result$1<void, TypedClientError>>;
+  cancel: () => Future<Result<void, RuntimeClientError>>;
   /**
    * Get workflow execution description including status and metadata
    */
-  describe: () => Future$1<Result$1<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
@@ -125,7 +209,7 @@ declare class TypedClient<TContract extends ContractDefinition> {
    * const result = await client.executeWorkflow('processOrder', {
    *   workflowId: 'order-123',
    *   args: { ... },
-   * }).toPromise();
+   * });
    *
    * result.match({
    *   Ok: (output) => console.log('Success:', output),
@@ -133,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
    *
@@ -144,11 +228,11 @@ declare class TypedClient<TContract extends ContractDefinition> {
    *   args: { orderId: 'ORD-123' },
    *   workflowExecutionTimeout: '1 day',
    *   retry: { maximumAttempts: 3 },
-   * }).toPromise();
+   * });
    *
    * handleResult.match({
    *   Ok: async (handle) => {
-   *     const result = await handle.result().toPromise();
+   *     const result = await handle.result();
    *     // ... handle result
    *   },
    *   Error: (error) => console.error('Failed to start:', error),
@@ -158,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$1<Result$1<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
    *
@@ -171,7 +253,7 @@ declare class TypedClient<TContract extends ContractDefinition> {
    *   args: { orderId: 'ORD-123' },
    *   workflowExecutionTimeout: '1 day',
    *   retry: { maximumAttempts: 3 },
-   * }).toPromise();
+   * });
    *
    * result.match({
    *   Ok: (output) => console.log('Order processed:', output.status),
@@ -182,26 +264,24 @@ declare class TypedClient<TContract extends ContractDefinition> {
   executeWorkflow<TWorkflowName extends keyof TContract["workflows"]>(workflowName: TWorkflowName, {
     args,
     ...temporalOptions
-  }: TypedWorkflowStartOptions & {
-    args: ClientInferInput<TContract["workflows"][TWorkflowName]>;
-  }): Future$1<Result$1<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
    *
    * @example
    * ```ts
-   * const handleResult = await client.getHandle('processOrder', 'order-123').toPromise();
+   * const handleResult = await client.getHandle('processOrder', 'order-123');
    * handleResult.match({
    *   Ok: async (handle) => {
-   *     const result = await handle.result().toPromise();
+   *     const result = await handle.result();
    *     // ... handle result
    *   },
    *   Error: (error) => console.error('Failed to get handle:', error),
    * });
    * ```
    */
-  getHandle<TWorkflowName extends keyof TContract["workflows"]>(workflowName: TWorkflowName, workflowId: string): Future$1<Result$1<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 { AsyncData, Future, Option, QueryValidationError, Result, 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 { AsyncData, Future, Future as Future$1, Option, Result, Result as Result$1 } from "@swan-io/boxed";
+import { Future, Result } from "@temporal-contract/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 {
@@ -93,7 +102,7 @@ var TypedClient = class TypedClient {
 	* const result = await client.executeWorkflow('processOrder', {
 	*   workflowId: 'order-123',
 	*   args: { ... },
-	* }).toPromise();
+	* });
 	*
 	* result.match({
 	*   Ok: (output) => console.log('Success:', output),
@@ -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
@@ -114,11 +123,11 @@ var TypedClient = class TypedClient {
 	*   args: { orderId: 'ORD-123' },
 	*   workflowExecutionTimeout: '1 day',
 	*   retry: { maximumAttempts: 3 },
-	* }).toPromise();
+	* });
 	*
 	* handleResult.match({
 	*   Ok: async (handle) => {
-	*     const result = await handle.result().toPromise();
+	*     const result = await handle.result();
 	*     // ... handle result
 	*   },
 	*   Error: (error) => console.error('Failed to start:', error),
@@ -126,16 +135,16 @@ var TypedClient = class TypedClient {
 	* ```
 	*/
 	startWorkflow(workflowName, { args, ...temporalOptions }) {
-		return Future$1.make((resolve) => {
-			const definition = this.contract.workflows[workflowName];
-			if (!definition) {
-				resolve(Result$1.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
-				return;
-			}
+		return Future.make((resolve) => {
 			(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$1.Error(new WorkflowValidationError(String(workflowName), "input", inputResult.issues)));
+					resolve(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(Result$1.Ok(typedHandle));
+					resolve(Result.Ok(typedHandle));
 				} catch (error) {
-					resolve(Result$1.Error(new TypedClientError(`Failed to start workflow: ${error instanceof Error ? error.message : String(error)}`)));
+					resolve(Result.Error(createRuntimeClientError("startWorkflow", error)));
 				}
 			})();
 		});
@@ -163,7 +172,7 @@ var TypedClient = class TypedClient {
 	*   args: { orderId: 'ORD-123' },
 	*   workflowExecutionTimeout: '1 day',
 	*   retry: { maximumAttempts: 3 },
-	* }).toPromise();
+	* });
 	*
 	* result.match({
 	*   Ok: (output) => console.log('Order processed:', output.status),
@@ -172,16 +181,16 @@ var TypedClient = class TypedClient {
 	* ```
 	*/
 	executeWorkflow(workflowName, { args, ...temporalOptions }) {
-		return Future$1.make((resolve) => {
-			const definition = this.contract.workflows[workflowName];
-			if (!definition) {
-				resolve(Result$1.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
-				return;
-			}
+		return Future.make((resolve) => {
 			(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$1.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$1.Error(new WorkflowValidationError(String(workflowName), "output", outputResult.issues)));
+						resolve(Result.Error(createWorkflowValidationError(workflowName, "output", outputResult.issues)));
 						return;
 					}
-					resolve(Result$1.Ok(outputResult.value));
+					resolve(Result.Ok(outputResult.value));
 				} catch (error) {
-					resolve(Result$1.Error(new TypedClientError(`Failed to execute workflow: ${error instanceof Error ? error.message : String(error)}`)));
+					resolve(Result.Error(createRuntimeClientError("executeWorkflow", error)));
 				}
 			})();
 		});
@@ -208,10 +217,10 @@ var TypedClient = class TypedClient {
 	*
 	* @example
 	* ```ts
-	* const handleResult = await client.getHandle('processOrder', 'order-123').toPromise();
+	* const handleResult = await client.getHandle('processOrder', 'order-123');
 	* handleResult.match({
 	*   Ok: async (handle) => {
-	*     const result = await handle.result().toPromise();
+	*     const result = await handle.result();
 	*     // ... handle result
 	*   },
 	*   Error: (error) => console.error('Failed to get handle:', error),
@@ -219,148 +228,132 @@ var TypedClient = class TypedClient {
 	* ```
 	*/
 	getHandle(workflowName, workflowId) {
-		return Future$1.make((resolve) => {
+		return Future.make((resolve) => {
 			const definition = this.contract.workflows[workflowName];
 			if (!definition) {
-				resolve(Result$1.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
+				resolve(Result.Error(createWorkflowNotFoundError(workflowName, this.contract)));
 				return;
 			}
 			try {
 				const handle = this.client.workflow.getHandle(workflowId);
 				const typedHandle = this.createTypedHandle(handle, definition);
-				resolve(Result$1.Ok(typedHandle));
+				resolve(Result.Ok(typedHandle));
 			} catch (error) {
-				resolve(Result$1.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$1.make((resolve) => {
+			return Future.make((resolve) => {
 				(async () => {
 					const inputResult = await queryDef.input["~standard"].validate(args);
 					if (inputResult.issues) {
-						resolve(Result$1.Error(new QueryValidationError(queryName, "input", inputResult.issues)));
+						resolve(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(Result$1.Error(new QueryValidationError(queryName, "output", outputResult.issues)));
+							resolve(Result.Error(new QueryValidationError(queryName, "output", outputResult.issues)));
 							return;
 						}
-						resolve(Result$1.Ok(outputResult.value));
+						resolve(Result.Ok(outputResult.value));
 					} catch (error) {
-						resolve(Result$1.Error(new TypedClientError(`Query failed: ${error instanceof Error ? error.message : String(error)}`)));
+						resolve(Result.Error(createRuntimeClientError("query", error)));
 					}
 				})();
 			});
 		};
 		const signals = {};
 		for (const [signalName, signalDef] of Object.entries(definition.signals ?? {})) signals[signalName] = (args) => {
-			return Future$1.make((resolve) => {
+			return Future.make((resolve) => {
 				(async () => {
 					const inputResult = await signalDef.input["~standard"].validate(args);
 					if (inputResult.issues) {
-						resolve(Result$1.Error(new SignalValidationError(signalName, inputResult.issues)));
+						resolve(Result.Error(new SignalValidationError(signalName, inputResult.issues)));
 						return;
 					}
 					try {
-						await handle.signal(signalName, inputResult.value);
-						resolve(Result$1.Ok(void 0));
+						await workflowHandle.signal(signalName, inputResult.value);
+						resolve(Result.Ok(void 0));
 					} catch (error) {
-						resolve(Result$1.Error(new TypedClientError(`Signal failed: ${error instanceof Error ? error.message : String(error)}`)));
+						resolve(Result.Error(createRuntimeClientError("signal", error)));
 					}
 				})();
 			});
 		};
 		const updates = {};
 		for (const [updateName, updateDef] of Object.entries(definition.updates ?? {})) updates[updateName] = (args) => {
-			return Future$1.make((resolve) => {
+			return Future.make((resolve) => {
 				(async () => {
 					const inputResult = await updateDef.input["~standard"].validate(args);
 					if (inputResult.issues) {
-						resolve(Result$1.Error(new UpdateValidationError(updateName, "input", inputResult.issues)));
+						resolve(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(Result$1.Error(new UpdateValidationError(updateName, "output", outputResult.issues)));
+							resolve(Result.Error(new UpdateValidationError(updateName, "output", outputResult.issues)));
 							return;
 						}
-						resolve(Result$1.Ok(outputResult.value));
+						resolve(Result.Ok(outputResult.value));
 					} catch (error) {
-						resolve(Result$1.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,
 			result: () => {
-				return Future$1.make((resolve) => {
+				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$1.Error(new WorkflowValidationError(handle.workflowId, "output", outputResult.issues)));
+								resolve(Result.Error(new WorkflowValidationError(workflowHandle.workflowId, "output", outputResult.issues)));
 								return;
 							}
-							resolve(Result$1.Ok(outputResult.value));
+							resolve(Result.Ok(outputResult.value));
 						} catch (error) {
-							resolve(Result$1.Error(new TypedClientError(`Workflow execution failed: ${error instanceof Error ? error.message : String(error)}`)));
+							resolve(Result.Error(createRuntimeClientError("result", error)));
 						}
 					})();
 				});
 			},
 			terminate: (reason) => {
-				return Future$1.make((resolve) => {
-					(async () => {
-						try {
-							await handle.terminate(reason);
-							resolve(Result$1.Ok(void 0));
-						} catch (error) {
-							resolve(Result$1.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$1.make((resolve) => {
-					(async () => {
-						try {
-							await handle.cancel();
-							resolve(Result$1.Ok(void 0));
-						} catch (error) {
-							resolve(Result$1.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$1.make((resolve) => {
-					(async () => {
-						try {
-							const description = await handle.describe();
-							resolve(Result$1.Ok(description));
-						} catch (error) {
-							resolve(Result$1.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 { AsyncData, Future, Option, QueryValidationError, Result, SignalValidationError, TypedClient, TypedClientError, UpdateValidationError, WorkflowNotFoundError, WorkflowValidationError };
+export { QueryValidationError, SignalValidationError, TypedClient, UpdateValidationError, WorkflowNotFoundError, WorkflowValidationError };

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@temporal-contract/client",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Client utilities with Result/Future pattern for consuming temporal-contract workflows",
   "keywords": [
-    "temporal",
-    "typescript",
-    "contract",
     "client",
+    "contract",
+    "future",
     "result",
-    "future"
+    "temporal",
+    "typescript"
   ],
   "homepage": "https://github.com/btravers/temporal-contract#readme",
   "bugs": {
@@ -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": {
     ".": {
@@ -42,28 +42,32 @@
     "dist"
   ],
   "dependencies": {
-    "@standard-schema/spec": "1.0.0",
-    "@swan-io/boxed": "3.2.1",
-    "@temporal-contract/contract": "0.0.4"
+    "@standard-schema/spec": "1.1.0",
+    "@temporal-contract/boxed": "0.0.6",
+    "@temporal-contract/contract": "0.0.6"
   },
   "devDependencies": {
-    "@temporalio/client": "1.13.2",
-    "@types/node": "25.0.1",
-    "@vitest/coverage-v8": "4.0.15",
-    "tsdown": "0.17.3",
+    "@temporalio/client": "1.14.0",
+    "@temporalio/worker": "1.14.0",
+    "@temporalio/workflow": "1.14.0",
+    "@types/node": "25.0.3",
+    "@vitest/coverage-v8": "4.0.16",
+    "tsdown": "0.18.1",
     "typescript": "5.9.3",
-    "vitest": "4.0.15",
-    "zod": "4.1.13",
-    "@temporal-contract/tsconfig": "0.0.4"
+    "vitest": "4.0.16",
+    "zod": "4.2.1",
+    "@temporal-contract/testing": "0.0.6",
+    "@temporal-contract/tsconfig": "0.0.6"
   },
   "peerDependencies": {
-    "@temporalio/client": ">=1.13.0 <2.0.0"
+    "@temporalio/client": "^1"
   },
   "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"
   }
 }