@temporal-contract/client 0.2.0 → 2.0.0

package/dist/index.cjs

@@ -1,6 +1,7 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-let _swan_io_boxed = require("@swan-io/boxed");
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _temporalio_common = require("@temporalio/common");
+let neverthrow = require("neverthrow");
+let _temporalio_client = require("@temporalio/client");
 //#region src/errors.ts
 /**
 * Base class for all typed client errors with boxed pattern
@@ -33,11 +34,117 @@ var WorkflowNotFoundError = class extends TypedClientError {
 	}
 };
 /**
+* Discriminated variant of {@link RuntimeClientError} surfaced when starting
+* a workflow collides with an existing execution — Temporal's
+* `WorkflowExecutionAlreadyStartedError`. The most common cause is a
+* workflowId reuse policy that rejects duplicates while a previous run is
+* still in retention.
+*
+* Distinguishing this from `RuntimeClientError` lets idempotent callers
+* branch on it explicitly (e.g. fetch the existing handle and continue)
+* without inspecting `error.cause` against a Temporal SDK class.
+*/
+var WorkflowAlreadyStartedError = class extends TypedClientError {
+	constructor(workflowType, workflowId, cause) {
+		super(`Workflow "${workflowType}" with ID "${workflowId}" is already started or in retention.`);
+		this.workflowType = workflowType;
+		this.workflowId = workflowId;
+		this.cause = cause;
+	}
+};
+/**
+* Discriminated variant of {@link RuntimeClientError} surfaced when an
+* operation targets a workflow execution that doesn't exist in the
+* namespace — Temporal's `WorkflowNotFoundError` (distinct from this
+* package's contract-level {@link WorkflowNotFoundError}).
+*
+* Returned from:
+* - handle methods: `signal`, `query`, `executeUpdate`, `result`,
+*   `terminate`, `cancel`, `describe`, `fetchHistory`
+* - `executeWorkflow` (when the underlying execute call hits a missing
+*   execution mid-flight)
+*/
+var WorkflowExecutionNotFoundError = class extends TypedClientError {
+	constructor(workflowId, runId, cause) {
+		super(`Workflow execution "${workflowId}"${runId ? ` (run "${runId}")` : ""} not found in namespace.`);
+		this.workflowId = workflowId;
+		this.runId = runId;
+		this.cause = cause;
+	}
+};
+/**
+* Discriminated variant of {@link RuntimeClientError} surfaced when waiting
+* on a workflow's result and the workflow completes with a failure —
+* Temporal's `WorkflowFailedError`.
+*
+* `cause` is the *unwrapped* underlying failure (typically an
+* `ApplicationFailure`, `CancelledFailure`, `TerminatedFailure`, or
+* `TimeoutFailure`) lifted from Temporal's wrapper, so callers can branch
+* on the failure category in one step (`err.cause instanceof
+* ApplicationFailure`) instead of unwrapping twice via the SDK wrapper.
+*
+* Returned from `executeWorkflow` and `handle.result()`.
+*/
+var WorkflowFailedError = class extends TypedClientError {
+	constructor(workflowId, cause) {
+		const causeMessage = cause instanceof Error ? cause.message : String(cause ?? "unknown failure");
+		super(`Workflow "${workflowId}" completed with failure: ${causeMessage}`);
+		this.workflowId = workflowId;
+		this.cause = cause;
+	}
+};
+/**
+* Pattern for string keys safe to render with dot notation. A "safe" key is a
+* JavaScript identifier (letters/digits/underscore/$, not starting with a
+* digit). Anything else — keys containing dots, spaces, leading digits, the
+* empty string, the literal string `"0"` etc. — gets bracket-quoted so the
+* path is unambiguous.
+*
+* This helper is intentionally duplicated with the worker package so each
+* entry point is self-contained; keep the two copies in sync.
+*/
+const SAFE_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/**
+* Render a Standard Schema {@link StandardSchemaV1.Issue} into a human-readable
+* string that includes the failing field's path.
+*
+* Example output:
+* - `at items[0].quantity: Expected number, received undefined`
+* - `at customerId: Expected string, received undefined`
+* - `at user["first name"]: Expected string, received undefined`
+* - `Validation error` *(no path)*
+*
+* Path segments come either as bare `PropertyKey` values or as
+* `{ key: PropertyKey }` objects (per the spec); both are normalized.
+* - Numeric keys → `[N]`
+* - String keys that are valid JS identifiers → bare (first) or `.key`
+* - String keys that aren't valid identifiers → `["..."]` with JSON-style
+*   escaping (handles dots, spaces, leading digits, the empty string, the
+*   literal string `"0"`, embedded quotes, etc.)
+* - Symbol / other `PropertyKey` → `[Symbol(name)]`
+*/
+function formatIssue(issue) {
+	if (issue.path === void 0 || issue.path.length === 0) return issue.message;
+	let path = "";
+	for (let i = 0; i < issue.path.length; i++) {
+		const segment = issue.path[i];
+		const key = segment !== null && typeof segment === "object" && "key" in segment ? segment.key : segment;
+		if (typeof key === "number") path += `[${key}]`;
+		else if (typeof key === "string" && SAFE_IDENTIFIER.test(key)) path += i === 0 ? key : `.${key}`;
+		else if (typeof key === "string") path += `[${JSON.stringify(key)}]`;
+		else path += `[${String(key)}]`;
+	}
+	return `at ${path}: ${issue.message}`;
+}
+function summarizeIssues(issues) {
+	return issues.map(formatIssue).join("; ");
+}
+/**
 * Thrown when workflow input or output validation fails
 */
 var WorkflowValidationError = class extends TypedClientError {
 	constructor(workflowName, direction, issues) {
-		super(`Validation failed for workflow "${workflowName}" ${direction}: ${JSON.stringify(issues)}`);
+		super(`Validation failed for workflow "${workflowName}" ${direction}: ${summarizeIssues(issues)}`);
 		this.workflowName = workflowName;
 		this.direction = direction;
 		this.issues = issues;
@@ -48,7 +155,7 @@ var WorkflowValidationError = class extends TypedClientError {
 */
 var QueryValidationError = class extends TypedClientError {
 	constructor(queryName, direction, issues) {
-		super(`Validation failed for query "${queryName}" ${direction}: ${JSON.stringify(issues)}`);
+		super(`Validation failed for query "${queryName}" ${direction}: ${summarizeIssues(issues)}`);
 		this.queryName = queryName;
 		this.direction = direction;
 		this.issues = issues;
@@ -59,7 +166,7 @@ var QueryValidationError = class extends TypedClientError {
 */
 var SignalValidationError = class extends TypedClientError {
 	constructor(signalName, issues) {
-		super(`Validation failed for signal "${signalName}": ${JSON.stringify(issues)}`);
+		super(`Validation failed for signal "${signalName}": ${summarizeIssues(issues)}`);
 		this.signalName = signalName;
 		this.issues = issues;
 	}
@@ -69,28 +176,221 @@ var SignalValidationError = class extends TypedClientError {
 */
 var UpdateValidationError = class extends TypedClientError {
 	constructor(updateName, direction, issues) {
-		super(`Validation failed for update "${updateName}" ${direction}: ${JSON.stringify(issues)}`);
+		super(`Validation failed for update "${updateName}" ${direction}: ${summarizeIssues(issues)}`);
 		this.updateName = updateName;
 		this.direction = direction;
 		this.issues = issues;
 	}
 };
-
+//#endregion
+//#region src/internal.ts
+/**
+* Internal helpers shared across the client package's modules.
+*
+* Not part of the public API — this module is not listed in the package's
+* `exports` map, so consumers can't import from `@temporal-contract/client/internal`.
+* In-package modules and tests import it directly via relative path.
+*/
+/**
+* Wrap an async result-producing function in a `ResultAsync`, catching any
+* unhandled rejection as a `RuntimeClientError("unexpected", error)`.
+*
+* The work function is expected to handle its own domain errors and return
+* an `err(...)` for them; the catch here is a safety net for thrown
+* exceptions the work didn't anticipate.
+*
+* Used by `client.ts` (workflow operations) and `schedule.ts` (schedule
+* operations) so the unexpected-rejection shape is identical across the
+* typed client surface.
+*/
+function makeResultAsync(work) {
+	return new neverthrow.ResultAsync(work().catch((e) => (0, neverthrow.err)(new RuntimeClientError("unexpected", e))));
+}
+/**
+* Map a thrown error from `client.workflow.start` / `signalWithStart` into
+* the discriminated union surfaced by the typed client. Specifically
+* recognizes Temporal's `WorkflowExecutionAlreadyStartedError`; everything
+* else falls through to {@link RuntimeClientError}.
+*/
+function classifyStartError(operation, error) {
+	if (error instanceof _temporalio_client.WorkflowExecutionAlreadyStartedError) return new WorkflowAlreadyStartedError(error.workflowType, error.workflowId, error);
+	return new RuntimeClientError(operation, error);
+}
+/**
+* Map a thrown error from a workflow handle method (signal, query,
+* executeUpdate, terminate, cancel, describe, fetchHistory) into the
+* discriminated union surfaced by the typed client. Recognizes Temporal's
+* `WorkflowNotFoundError`; everything else falls through to
+* {@link RuntimeClientError}.
+*
+* `fallbackWorkflowId` is used when Temporal's error carries an empty
+* `workflowId` (it normalizes missing IDs to the empty string), so the
+* surfaced error always identifies the targeted execution.
+*/
+function classifyHandleError(operation, error, fallbackWorkflowId) {
+	if (error instanceof _temporalio_common.WorkflowNotFoundError) return new WorkflowExecutionNotFoundError(error.workflowId || fallbackWorkflowId, error.runId, error);
+	return new RuntimeClientError(operation, error);
+}
+/**
+* Map a thrown error from `handle.result()` / `client.workflow.execute()`
+* (the latter when waiting on the result phase). Recognizes Temporal's
+* `WorkflowFailedError` and `WorkflowNotFoundError`; everything else falls
+* through to {@link RuntimeClientError}.
+*
+* Temporal's `WorkflowFailedError` is itself a wrapper — the actionable
+* failure (ApplicationFailure, CancelledFailure, TerminatedFailure, etc.)
+* lives on its `cause` field. We forward that inner cause directly so
+* consumers can match `err.cause` against the underlying failure class
+* without an extra unwrap step. (If Temporal's cause is `undefined`, our
+* `cause` is too — same shape as before.)
+*/
+function classifyResultError(operation, error, workflowId) {
+	if (error instanceof _temporalio_client.WorkflowFailedError) return new WorkflowFailedError(workflowId, error.cause);
+	if (error instanceof _temporalio_common.WorkflowNotFoundError) return new WorkflowExecutionNotFoundError(error.workflowId || workflowId, error.runId, error);
+	return new RuntimeClientError(operation, error);
+}
+//#endregion
+//#region src/schedule.ts
+/**
+* Typed wrapper around Temporal's `ScheduleClient`. Exposed as
+* `typedClient.schedule` — keeps the typed-client surface organized the
+* same way Temporal's own `Client.schedule` does.
+*/
+var TypedScheduleClient = class {
+	constructor(contract, scheduleClient) {
+		this.contract = contract;
+		this.scheduleClient = scheduleClient;
+	}
+	/**
+	* Create a new schedule that, on each fire, starts the named contract
+	* workflow with validated args.
+	*
+	* Validates `args` against the workflow's input schema before dispatching
+	* the create request to Temporal. The workflow's `taskQueue` and
+	* `workflowType` are pulled from the contract automatically; the typed
+	* options shape omits them so call sites don't have to repeat themselves.
+	*/
+	create(workflowName, options) {
+		const work = async () => {
+			const definition = this.contract.workflows[workflowName];
+			if (!definition) return (0, neverthrow.err)(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows)));
+			const inputResult = await definition.input["~standard"].validate(options.args);
+			if (inputResult.issues) return (0, neverthrow.err)(new WorkflowValidationError(String(workflowName), "input", inputResult.issues));
+			try {
+				const overrides = options.action ?? {};
+				const action = {
+					type: "startWorkflow",
+					workflowType: workflowName,
+					taskQueue: this.contract.taskQueue,
+					args: [inputResult.value],
+					...overrides.workflowId !== void 0 ? { workflowId: overrides.workflowId } : {},
+					...overrides.workflowExecutionTimeout !== void 0 ? { workflowExecutionTimeout: overrides.workflowExecutionTimeout } : {},
+					...overrides.workflowRunTimeout !== void 0 ? { workflowRunTimeout: overrides.workflowRunTimeout } : {},
+					...overrides.workflowTaskTimeout !== void 0 ? { workflowTaskTimeout: overrides.workflowTaskTimeout } : {},
+					...overrides.retry !== void 0 ? { retry: overrides.retry } : {},
+					...overrides.memo !== void 0 ? { memo: overrides.memo } : {},
+					...overrides.staticDetails !== void 0 ? { staticDetails: overrides.staticDetails } : {},
+					...overrides.staticSummary !== void 0 ? { staticSummary: overrides.staticSummary } : {}
+				};
+				return (0, neverthrow.ok)(wrapScheduleHandle(await this.scheduleClient.create({
+					scheduleId: options.scheduleId,
+					spec: options.spec,
+					action,
+					...options.policies !== void 0 ? { policies: options.policies } : {},
+					...options.state !== void 0 ? { state: options.state } : {},
+					...options.memo !== void 0 ? { memo: options.memo } : {}
+				})));
+			} catch (error) {
+				return (0, neverthrow.err)(new RuntimeClientError("schedule.create", error));
+			}
+		};
+		return makeResultAsync(work);
+	}
+	/**
+	* Get a typed handle to an existing schedule. Does not validate that the
+	* schedule exists — handle methods (`describe`, `pause`, etc.) will
+	* surface a `RuntimeClientError` if the underlying ID is unknown.
+	*/
+	getHandle(scheduleId) {
+		return wrapScheduleHandle(this.scheduleClient.getHandle(scheduleId));
+	}
+};
+function wrapScheduleHandle(handle) {
+	return {
+		scheduleId: handle.scheduleId,
+		pause: (note) => neverthrow.ResultAsync.fromPromise(handle.pause(note), (error) => new RuntimeClientError("schedule.pause", error)).map(() => void 0),
+		unpause: (note) => neverthrow.ResultAsync.fromPromise(handle.unpause(note), (error) => new RuntimeClientError("schedule.unpause", error)).map(() => void 0),
+		trigger: (overlap) => neverthrow.ResultAsync.fromPromise(handle.trigger(overlap), (error) => new RuntimeClientError("schedule.trigger", error)).map(() => void 0),
+		delete: () => neverthrow.ResultAsync.fromPromise(handle.delete(), (error) => new RuntimeClientError("schedule.delete", error)).map(() => void 0),
+		describe: () => neverthrow.ResultAsync.fromPromise(handle.describe(), (error) => new RuntimeClientError("schedule.describe", error))
+	};
+}
 //#endregion
 //#region src/client.ts
 /**
-* Typed Temporal client with Result/Future pattern based on a contract
+* Translate the contract's typed `searchAttributes` map (declared
+* name → value) into a Temporal `TypedSearchAttributes` instance, so the
+* Temporal client honours indexing when starting the workflow.
+*
+* Workflows without a `searchAttributes` block (or callers passing no
+* values) skip the conversion entirely and return `undefined`, matching
+* the Temporal SDK's "absent ≠ empty" semantics.
+*/
+function toTypedSearchAttributes(workflowDef, values) {
+	if (!values || !workflowDef.searchAttributes) return void 0;
+	const pairs = [];
+	for (const [name, value] of Object.entries(values)) {
+		if (value === void 0) continue;
+		const def = workflowDef.searchAttributes[name];
+		if (!def) continue;
+		const key = (0, _temporalio_common.defineSearchAttributeKey)(name, def.kind);
+		pairs.push({
+			key,
+			value
+		});
+	}
+	return pairs.length > 0 ? new _temporalio_common.TypedSearchAttributes(pairs) : void 0;
+}
+/**
+* Typed Temporal client with neverthrow Result/ResultAsync pattern based on a contract
 *
 * Provides type-safe methods to start and execute workflows
 * defined in the contract, with explicit error handling using Result pattern.
 */
 var TypedClient = class TypedClient {
+	/**
+	* Typed wrapper around Temporal's `client.schedule.create(...)` and
+	* related lifecycle methods. Fires the underlying `startWorkflow` action
+	* with args validated against the contract's input schema.
+	*
+	* **Requires `@temporalio/client` 1.16+.** The Schedule API was added in
+	* 1.16; on older versions this property is unset and any access throws.
+	* The package's peer dep is pinned to `^1.16.0` so the standard install
+	* paths surface a peer-dependency warning rather than a runtime crash.
+	*
+	* @example
+	* ```ts
+	* const result = await client.schedule.create("processOrder", {
+	*   scheduleId: "daily-sweep",
+	*   spec: { cronExpressions: ["0 2 * * *"] },
+	*   args: { orderId: "sweep" },
+	* });
+	*
+	* result.match(
+	*   async (handle) => { await handle.pause("maintenance"); },
+	*   (error) => console.error("schedule create failed", error),
+	* );
+	* ```
+	*/
+	schedule;
 	constructor(contract, client) {
 		this.contract = contract;
 		this.client = client;
+		if (!client.schedule) throw new Error("TypedClient requires @temporalio/client >= 1.16 (the Schedule API was added in 1.16). Found a Client instance without a `schedule` property — please upgrade.");
+		this.schedule = new TypedScheduleClient(contract, client.schedule);
 	}
 	/**
-	* Create a typed Temporal client with boxed pattern from a contract
+	* Create a typed Temporal client with neverthrow pattern from a contract
 	*
 	* @example
 	* ```ts
@@ -103,17 +403,17 @@ var TypedClient = class TypedClient {
 	*   args: { ... },
 	* });
 	*
-	* result.match({
-	*   Ok: (output) => console.log('Success:', output),
-	*   Error: (error) => console.error('Failed:', error),
-	* });
+	* result.match(
+	*   (output) => console.log('Success:', output),
+	*   (error) => console.error('Failed:', error),
+	* );
 	* ```
 	*/
 	static create(contract, client) {
 		return new TypedClient(contract, client);
 	}
 	/**
-	* Start a workflow and return a typed handle with Future pattern
+	* Start a workflow and return a typed handle with ResultAsync pattern
 	*
 	* @example
 	* ```ts
@@ -124,39 +424,94 @@ var TypedClient = class TypedClient {
 	*   retry: { maximumAttempts: 3 },
 	* });
 	*
-	* handleResult.match({
-	*   Ok: async (handle) => {
+	* handleResult.match(
+	*   async (handle) => {
 	*     const result = await handle.result();
 	*     // ... handle result
 	*   },
-	*   Error: (error) => console.error('Failed to start:', error),
+	*   (error) => console.error('Failed to start:', error),
+	* );
+	* ```
+	*/
+	startWorkflow(workflowName, { args, searchAttributes, ...temporalOptions }) {
+		const work = async () => {
+			const definition = this.contract.workflows[workflowName];
+			if (!definition) return (0, neverthrow.err)(createWorkflowNotFoundError(workflowName, this.contract));
+			const inputResult = await definition.input["~standard"].validate(args);
+			if (inputResult.issues) return (0, neverthrow.err)(createWorkflowValidationError(workflowName, "input", inputResult.issues));
+			const typedSearchAttributes = toTypedSearchAttributes(definition, searchAttributes);
+			try {
+				const handle = await this.client.workflow.start(workflowName, {
+					...temporalOptions,
+					taskQueue: this.contract.taskQueue,
+					args: [inputResult.value],
+					...typedSearchAttributes ? { typedSearchAttributes } : {}
+				});
+				return (0, neverthrow.ok)(this.createTypedHandle(handle, definition));
+			} catch (error) {
+				return (0, neverthrow.err)(classifyStartError("startWorkflow", error));
+			}
+		};
+		return makeResultAsync(work);
+	}
+	/**
+	* Send a signal to a workflow, starting it first if it doesn't already exist.
+	*
+	* Validates both halves of the call against the contract:
+	* - `args` against the workflow's input schema
+	* - `signalArgs` against the named signal's input schema
+	*
+	* Returns a `TypedWorkflowHandleWithSignaledRunId` — the same shape as
+	* `startWorkflow`'s handle, plus a `signaledRunId` field for correlating
+	* the signal with the (possibly pre-existing) workflow execution chain.
+	*
+	* @example
+	* ```ts
+	* const result = await client.signalWithStart('processOrder', {
+	*   workflowId: 'order-123',
+	*   args: { orderId: 'ORD-123', customerId: 'CUST-1' },
+	*   signalName: 'cancel',
+	*   signalArgs: { reason: 'duplicate' },
 	* });
+	*
+	* result.match(
+	*   (handle) => console.log('signaled run', handle.signaledRunId),
+	*   (error) => console.error('signalWithStart failed', error),
+	* );
 	* ```
 	*/
-	startWorkflow(workflowName, { args, ...temporalOptions }) {
-		return _swan_io_boxed.Future.make((resolve) => {
-			(async () => {
-				const definition = this.contract.workflows[workflowName];
-				if (!definition) return _swan_io_boxed.Result.Error(createWorkflowNotFoundError(workflowName, this.contract));
-				const inputResult = await definition.input["~standard"].validate(args);
-				if (inputResult.issues) return _swan_io_boxed.Result.Error(createWorkflowValidationError(workflowName, "input", inputResult.issues));
-				const validatedInput = inputResult.value;
-				try {
-					const handle = await this.client.workflow.start(workflowName, {
-						...temporalOptions,
-						taskQueue: this.contract.taskQueue,
-						args: [validatedInput]
-					});
-					const typedHandle = this.createTypedHandle(handle, definition);
-					return _swan_io_boxed.Result.Ok(typedHandle);
-				} catch (error) {
-					return _swan_io_boxed.Result.Error(createRuntimeClientError("startWorkflow", error));
-				}
-			})().then(resolve).catch((e) => resolve(_swan_io_boxed.Result.Error(createRuntimeClientError("unexpected", e))));
-		});
+	signalWithStart(workflowName, { args, signalName, signalArgs, searchAttributes, ...temporalOptions }) {
+		const work = async () => {
+			const definition = this.contract.workflows[workflowName];
+			if (!definition) return (0, neverthrow.err)(createWorkflowNotFoundError(workflowName, this.contract));
+			const inputResult = await definition.input["~standard"].validate(args);
+			if (inputResult.issues) return (0, neverthrow.err)(createWorkflowValidationError(workflowName, "input", inputResult.issues));
+			const signalDef = definition.signals?.[signalName];
+			if (!signalDef) return (0, neverthrow.err)(new SignalValidationError(signalName, [{ message: `Signal "${signalName}" is not declared on workflow "${String(workflowName)}".` }]));
+			const signalInputResult = await signalDef.input["~standard"].validate(signalArgs);
+			if (signalInputResult.issues) return (0, neverthrow.err)(new SignalValidationError(signalName, signalInputResult.issues));
+			const typedSearchAttributes = toTypedSearchAttributes(definition, searchAttributes);
+			try {
+				const handle = await this.client.workflow.signalWithStart(workflowName, {
+					...temporalOptions,
+					taskQueue: this.contract.taskQueue,
+					args: [inputResult.value],
+					signal: signalName,
+					signalArgs: [signalInputResult.value],
+					...typedSearchAttributes ? { typedSearchAttributes } : {}
+				});
+				return (0, neverthrow.ok)({
+					...this.createTypedHandle(handle, definition),
+					signaledRunId: handle.signaledRunId
+				});
+			} catch (error) {
+				return (0, neverthrow.err)(classifyStartError("signalWithStart", error));
+			}
+		};
+		return makeResultAsync(work);
 	}
 	/**
-	* Execute a workflow (start and wait for result) with Future/Result pattern
+	* Execute a workflow (start and wait for result) with ResultAsync pattern
 	*
 	* @example
 	* ```ts
@@ -167,146 +522,115 @@ var TypedClient = class TypedClient {
 	*   retry: { maximumAttempts: 3 },
 	* });
 	*
-	* result.match({
-	*   Ok: (output) => console.log('Order processed:', output.status),
-	*   Error: (error) => console.error('Processing failed:', error),
-	* });
+	* result.match(
+	*   (output) => console.log('Order processed:', output.status),
+	*   (error) => console.error('Processing failed:', error),
+	* );
 	* ```
 	*/
-	executeWorkflow(workflowName, { args, ...temporalOptions }) {
-		return _swan_io_boxed.Future.make((resolve) => {
-			(async () => {
-				const definition = this.contract.workflows[workflowName];
-				if (!definition) return _swan_io_boxed.Result.Error(createWorkflowNotFoundError(workflowName, this.contract));
-				const inputResult = await definition.input["~standard"].validate(args);
-				if (inputResult.issues) return _swan_io_boxed.Result.Error(createWorkflowValidationError(workflowName, "input", inputResult.issues));
-				const validatedInput = inputResult.value;
-				try {
-					const result = await this.client.workflow.execute(workflowName, {
-						...temporalOptions,
-						taskQueue: this.contract.taskQueue,
-						args: [validatedInput]
-					});
-					const outputResult = await definition.output["~standard"].validate(result);
-					if (outputResult.issues) return _swan_io_boxed.Result.Error(createWorkflowValidationError(workflowName, "output", outputResult.issues));
-					return _swan_io_boxed.Result.Ok(outputResult.value);
-				} catch (error) {
-					return _swan_io_boxed.Result.Error(createRuntimeClientError("executeWorkflow", error));
-				}
-			})().then(resolve).catch((e) => resolve(_swan_io_boxed.Result.Error(createRuntimeClientError("unexpected", e))));
-		});
+	executeWorkflow(workflowName, { args, searchAttributes, ...temporalOptions }) {
+		const work = async () => {
+			const definition = this.contract.workflows[workflowName];
+			if (!definition) return (0, neverthrow.err)(createWorkflowNotFoundError(workflowName, this.contract));
+			const inputResult = await definition.input["~standard"].validate(args);
+			if (inputResult.issues) return (0, neverthrow.err)(createWorkflowValidationError(workflowName, "input", inputResult.issues));
+			const typedSearchAttributes = toTypedSearchAttributes(definition, searchAttributes);
+			try {
+				const result = await this.client.workflow.execute(workflowName, {
+					...temporalOptions,
+					taskQueue: this.contract.taskQueue,
+					args: [inputResult.value],
+					...typedSearchAttributes ? { typedSearchAttributes } : {}
+				});
+				const outputResult = await definition.output["~standard"].validate(result);
+				if (outputResult.issues) return (0, neverthrow.err)(createWorkflowValidationError(workflowName, "output", outputResult.issues));
+				return (0, neverthrow.ok)(outputResult.value);
+			} catch (error) {
+				if (error instanceof _temporalio_client.WorkflowExecutionAlreadyStartedError) return (0, neverthrow.err)(new WorkflowAlreadyStartedError(error.workflowType, error.workflowId, error));
+				if (error instanceof _temporalio_client.WorkflowFailedError) return (0, neverthrow.err)(new WorkflowFailedError(temporalOptions.workflowId, error.cause));
+				if (error instanceof _temporalio_common.WorkflowNotFoundError) return (0, neverthrow.err)(new WorkflowExecutionNotFoundError(error.workflowId || temporalOptions.workflowId, error.runId, error));
+				return (0, neverthrow.err)(createRuntimeClientError("executeWorkflow", error));
+			}
+		};
+		return makeResultAsync(work);
 	}
 	/**
-	* Get a handle to an existing workflow with Future/Result pattern
+	* Get a handle to an existing workflow with ResultAsync pattern
 	*
 	* @example
 	* ```ts
 	* const handleResult = await client.getHandle('processOrder', 'order-123');
-	* handleResult.match({
-	*   Ok: async (handle) => {
+	* handleResult.match(
+	*   async (handle) => {
 	*     const result = await handle.result();
 	*     // ... handle result
 	*   },
-	*   Error: (error) => console.error('Failed to get handle:', error),
-	* });
+	*   (error) => console.error('Failed to get handle:', error),
+	* );
 	* ```
 	*/
 	getHandle(workflowName, workflowId) {
-		return _swan_io_boxed.Future.make((resolve) => {
-			(async () => {
-				const definition = this.contract.workflows[workflowName];
-				if (!definition) return _swan_io_boxed.Result.Error(createWorkflowNotFoundError(workflowName, this.contract));
-				try {
-					const handle = this.client.workflow.getHandle(workflowId);
-					const typedHandle = this.createTypedHandle(handle, definition);
-					return _swan_io_boxed.Result.Ok(typedHandle);
-				} catch (error) {
-					return _swan_io_boxed.Result.Error(createRuntimeClientError("getHandle", error));
-				}
-			})().then(resolve).catch((e) => resolve(_swan_io_boxed.Result.Error(createRuntimeClientError("unexpected", e))));
-		});
+		const work = async () => {
+			const definition = this.contract.workflows[workflowName];
+			if (!definition) return (0, neverthrow.err)(createWorkflowNotFoundError(workflowName, this.contract));
+			try {
+				const handle = this.client.workflow.getHandle(workflowId);
+				return (0, neverthrow.ok)(this.createTypedHandle(handle, definition));
+			} catch (error) {
+				return (0, neverthrow.err)(createRuntimeClientError("getHandle", error));
+			}
+		};
+		return makeResultAsync(work);
 	}
 	createTypedHandle(workflowHandle, definition) {
-		const queries = {};
-		for (const [queryName, queryDef] of Object.entries(definition.queries ?? {})) queries[queryName] = (args) => {
-			return _swan_io_boxed.Future.make((resolve) => {
-				(async () => {
-					const inputResult = await queryDef.input["~standard"].validate(args);
-					if (inputResult.issues) return _swan_io_boxed.Result.Error(new QueryValidationError(queryName, "input", inputResult.issues));
-					try {
-						const result = await workflowHandle.query(queryName, inputResult.value);
-						const outputResult = await queryDef.output["~standard"].validate(result);
-						if (outputResult.issues) return _swan_io_boxed.Result.Error(new QueryValidationError(queryName, "output", outputResult.issues));
-						return _swan_io_boxed.Result.Ok(outputResult.value);
-					} catch (error) {
-						return _swan_io_boxed.Result.Error(createRuntimeClientError("query", error));
-					}
-				})().then(resolve).catch((e) => resolve(_swan_io_boxed.Result.Error(createRuntimeClientError("unexpected", e))));
-			});
-		};
-		const signals = {};
-		for (const [signalName, signalDef] of Object.entries(definition.signals ?? {})) signals[signalName] = (args) => {
-			return _swan_io_boxed.Future.make((resolve) => {
-				(async () => {
-					const inputResult = await signalDef.input["~standard"].validate(args);
-					if (inputResult.issues) return _swan_io_boxed.Result.Error(new SignalValidationError(signalName, inputResult.issues));
-					try {
-						await workflowHandle.signal(signalName, inputResult.value);
-						return _swan_io_boxed.Result.Ok(void 0);
-					} catch (error) {
-						return _swan_io_boxed.Result.Error(createRuntimeClientError("signal", error));
-					}
-				})().then(resolve).catch((e) => resolve(_swan_io_boxed.Result.Error(createRuntimeClientError("unexpected", e))));
-			});
-		};
-		const updates = {};
-		for (const [updateName, updateDef] of Object.entries(definition.updates ?? {})) updates[updateName] = (args) => {
-			return _swan_io_boxed.Future.make((resolve) => {
-				(async () => {
-					const inputResult = await updateDef.input["~standard"].validate(args);
-					if (inputResult.issues) return _swan_io_boxed.Result.Error(new UpdateValidationError(updateName, "input", inputResult.issues));
-					try {
-						const result = await workflowHandle.executeUpdate(updateName, { args: [inputResult.value] });
-						const outputResult = await updateDef.output["~standard"].validate(result);
-						if (outputResult.issues) return _swan_io_boxed.Result.Error(new UpdateValidationError(updateName, "output", outputResult.issues));
-						return _swan_io_boxed.Result.Ok(outputResult.value);
-					} catch (error) {
-						return _swan_io_boxed.Result.Error(createRuntimeClientError("update", error));
-					}
-				})().then(resolve).catch((e) => resolve(_swan_io_boxed.Result.Error(createRuntimeClientError("unexpected", e))));
-			});
-		};
+		const queries = buildValidatedProxy({
+			defs: definition.queries,
+			operation: "query",
+			workflowId: workflowHandle.workflowId,
+			makeValidationError: (name, direction, issues) => new QueryValidationError(name, direction, issues),
+			invoke: (name, validated) => workflowHandle.query(name, validated),
+			validateOutput: (def) => def.output
+		});
+		const signals = buildValidatedProxy({
+			defs: definition.signals,
+			operation: "signal",
+			workflowId: workflowHandle.workflowId,
+			makeValidationError: (name, _direction, issues) => new SignalValidationError(name, issues),
+			invoke: async (name, validated) => {
+				await workflowHandle.signal(name, validated);
+			},
+			validateOutput: () => null
+		});
+		const updates = buildValidatedProxy({
+			defs: definition.updates,
+			operation: "update",
+			workflowId: workflowHandle.workflowId,
+			makeValidationError: (name, direction, issues) => new UpdateValidationError(name, direction, issues),
+			invoke: (name, validated) => workflowHandle.executeUpdate(name, { args: [validated] }),
+			validateOutput: (def) => def.output
+		});
 		return {
 			workflowId: workflowHandle.workflowId,
 			queries,
 			signals,
 			updates,
 			result: () => {
-				return _swan_io_boxed.Future.make((resolve) => {
-					(async () => {
-						try {
-							const result = await workflowHandle.result();
-							const outputResult = await definition.output["~standard"].validate(result);
-							if (outputResult.issues) return _swan_io_boxed.Result.Error(new WorkflowValidationError(workflowHandle.workflowId, "output", outputResult.issues));
-							return _swan_io_boxed.Result.Ok(outputResult.value);
-						} catch (error) {
-							return _swan_io_boxed.Result.Error(createRuntimeClientError("result", error));
-						}
-					})().then(resolve).catch((e) => resolve(_swan_io_boxed.Result.Error(createRuntimeClientError("unexpected", e))));
-				});
-			},
-			terminate: (reason) => {
-				return _swan_io_boxed.Future.fromPromise(workflowHandle.terminate(reason)).mapError((error) => createRuntimeClientError("terminate", error)).mapOk(() => void 0);
-			},
-			cancel: () => {
-				return _swan_io_boxed.Future.fromPromise(workflowHandle.cancel()).mapError((error) => createRuntimeClientError("cancel", error)).mapOk(() => void 0);
-			},
-			describe: () => {
-				return _swan_io_boxed.Future.fromPromise(workflowHandle.describe()).mapError((error) => createRuntimeClientError("describe", error));
+				const work = async () => {
+					try {
+						const result = await workflowHandle.result();
+						const outputResult = await definition.output["~standard"].validate(result);
+						if (outputResult.issues) return (0, neverthrow.err)(new WorkflowValidationError(workflowHandle.workflowId, "output", outputResult.issues));
+						return (0, neverthrow.ok)(outputResult.value);
+					} catch (error) {
+						return (0, neverthrow.err)(classifyResultError("result", error, workflowHandle.workflowId));
+					}
+				};
+				return makeResultAsync(work);
 			},
-			fetchHistory: () => {
-				return _swan_io_boxed.Future.fromPromise(workflowHandle.fetchHistory()).mapError((error) => createRuntimeClientError("fetchHistory", error));
-			}
+			terminate: (reason) => neverthrow.ResultAsync.fromPromise(workflowHandle.terminate(reason), (error) => classifyHandleError("terminate", error, workflowHandle.workflowId)).map(() => void 0),
+			cancel: () => neverthrow.ResultAsync.fromPromise(workflowHandle.cancel(), (error) => classifyHandleError("cancel", error, workflowHandle.workflowId)).map(() => void 0),
+			describe: () => neverthrow.ResultAsync.fromPromise(workflowHandle.describe(), (error) => classifyHandleError("describe", error, workflowHandle.workflowId)),
+			fetchHistory: () => neverthrow.ResultAsync.fromPromise(workflowHandle.fetchHistory(), (error) => classifyHandleError("fetchHistory", error, workflowHandle.workflowId))
 		};
 	}
 };
@@ -319,11 +643,44 @@ function createWorkflowNotFoundError(workflowName, contract) {
 function createWorkflowValidationError(workflowName, direction, issues) {
 	return new WorkflowValidationError(String(workflowName), direction, issues);
 }
-
+/**
+* Build a `{ name: (args) => ResultAsync<...> }` proxy for a contract's
+* queries/signals/updates. The three call sites differ only in how they
+* invoke Temporal and whether they validate output, so the shared
+* input-validate → invoke → output-validate → wrap-Result pipeline lives
+* here once.
+*/
+function buildValidatedProxy({ defs, operation, workflowId, makeValidationError, invoke, validateOutput }) {
+	const proxy = {};
+	if (!defs) return proxy;
+	for (const [name, def] of Object.entries(defs)) proxy[name] = (args) => {
+		const work = async () => {
+			const inputResult = await def.input["~standard"].validate(args);
+			if (inputResult.issues) return (0, neverthrow.err)(makeValidationError(name, "input", inputResult.issues));
+			try {
+				const result = await invoke(name, inputResult.value);
+				const outputSchema = validateOutput(def);
+				if (!outputSchema) return (0, neverthrow.ok)(result);
+				const outputResult = await outputSchema["~standard"].validate(result);
+				if (outputResult.issues) return (0, neverthrow.err)(makeValidationError(name, "output", outputResult.issues));
+				return (0, neverthrow.ok)(outputResult.value);
+			} catch (error) {
+				return (0, neverthrow.err)(classifyHandleError(operation, error, workflowId));
+			}
+		};
+		return makeResultAsync(work);
+	};
+	return proxy;
+}
 //#endregion
 exports.QueryValidationError = QueryValidationError;
+exports.RuntimeClientError = RuntimeClientError;
 exports.SignalValidationError = SignalValidationError;
 exports.TypedClient = TypedClient;
+exports.TypedScheduleClient = TypedScheduleClient;
 exports.UpdateValidationError = UpdateValidationError;
+exports.WorkflowAlreadyStartedError = WorkflowAlreadyStartedError;
+exports.WorkflowExecutionNotFoundError = WorkflowExecutionNotFoundError;
+exports.WorkflowFailedError = WorkflowFailedError;
 exports.WorkflowNotFoundError = WorkflowNotFoundError;
-exports.WorkflowValidationError = WorkflowValidationError;
+exports.WorkflowValidationError = WorkflowValidationError;