@temporal-contract/client 1.0.0 → 2.1.0

package/dist/index.mjs

@@ -1,6 +1,8 @@
 import { TypedSearchAttributes, WorkflowNotFoundError as WorkflowNotFoundError$1, defineSearchAttributeKey } from "@temporalio/common";
-import { Future, Result } from "@swan-io/boxed";
+import { ResultAsync, err, ok } from "neverthrow";
+import { summarizeIssues } from "@temporal-contract/contract";
 import { WorkflowExecutionAlreadyStartedError, WorkflowFailedError as WorkflowFailedError$1 } from "@temporalio/client";
+import { _internal_makeResultAsync } from "@temporal-contract/contract/result-async";
 //#region src/errors.ts
 /**
 * Base class for all typed client errors with boxed pattern
@@ -76,11 +78,17 @@ var WorkflowExecutionNotFoundError = class extends TypedClientError {
 * on a workflow's result and the workflow completes with a failure —
 * Temporal's `WorkflowFailedError`.
 *
-* `cause` is the *unwrapped* underlying failure (typically an
+* `cause` is the *unwrapped* underlying {@link TemporalFailure} (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.
+* ApplicationFailure`) instead of unwrapping twice via the SDK wrapper. The
+* SDK declares `WorkflowFailedError.cause` as the wider `Error | undefined`
+* (since `cause` lives on `Error`), but the runtime guarantee — driven by
+* Temporal's wire format — is that it is always a `TemporalFailure` subclass
+* when the wrapper is surfaced. `classifyResultError` narrows that wider
+* static type to the public {@link TemporalFailure} union with a cast, so
+* consumers see the precise leaf-failure typing instead of a bare `Error`.
 *
 * Returned from `executeWorkflow` and `handle.result()`.
 */
@@ -93,52 +101,6 @@ var WorkflowFailedError = class extends TypedClientError {
 	}
 };
 /**
-* 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 {
@@ -191,21 +153,21 @@ var UpdateValidationError = class extends TypedClientError {
 * In-package modules and tests import it directly via relative path.
 */
 /**
-* Wrap an async result-producing function in a `Future`, catching any
+* 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
-* a `Result.Error(...)` for them; the catch here is a safety net for
-* thrown exceptions the work didn't anticipate.
+* 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.
+* typed client surface. Delegates to `_internal_makeResultAsync` from
+* `@temporal-contract/contract` so the same wrapper is shared between the
+* client and worker packages.
 */
-function makeFuture(work) {
-	return Future.make((resolve) => {
-		work().then(resolve).catch((e) => resolve(Result.Error(new RuntimeClientError("unexpected", e))));
-	});
+function makeResultAsync(work) {
+	return _internal_makeResultAsync(work, (e) => new RuntimeClientError("unexpected", e));
 }
 /**
 * Map a thrown error from `client.workflow.start` / `signalWithStart` into
@@ -274,9 +236,9 @@ var TypedScheduleClient = class {
 	create(workflowName, options) {
 		const work = async () => {
 			const definition = this.contract.workflows[workflowName];
-			if (!definition) return Result.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows)));
+			if (!definition) return err(new WorkflowNotFoundError(workflowName, Object.keys(this.contract.workflows)));
 			const inputResult = await definition.input["~standard"].validate(options.args);
-			if (inputResult.issues) return Result.Error(new WorkflowValidationError(String(workflowName), "input", inputResult.issues));
+			if (inputResult.issues) return err(new WorkflowValidationError(workflowName, "input", inputResult.issues));
 			try {
 				const overrides = options.action ?? {};
 				const action = {
@@ -293,20 +255,19 @@ var TypedScheduleClient = class {
 					...overrides.staticDetails !== void 0 ? { staticDetails: overrides.staticDetails } : {},
 					...overrides.staticSummary !== void 0 ? { staticSummary: overrides.staticSummary } : {}
 				};
-				const handle = await this.scheduleClient.create({
+				return 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 } : {}
-				});
-				return Result.Ok(wrapScheduleHandle(handle));
+				})));
 			} catch (error) {
-				return Result.Error(new RuntimeClientError("schedule.create", error));
+				return err(new RuntimeClientError("schedule.create", error));
 			}
 		};
-		return makeFuture(work);
+		return makeResultAsync(work);
 	}
 	/**
 	* Get a typed handle to an existing schedule. Does not validate that the
@@ -320,11 +281,11 @@ var TypedScheduleClient = class {
 function wrapScheduleHandle(handle) {
 	return {
 		scheduleId: handle.scheduleId,
-		pause: (note) => Future.fromPromise(handle.pause(note)).mapError((error) => new RuntimeClientError("schedule.pause", error)).mapOk(() => void 0),
-		unpause: (note) => Future.fromPromise(handle.unpause(note)).mapError((error) => new RuntimeClientError("schedule.unpause", error)).mapOk(() => void 0),
-		trigger: (overlap) => Future.fromPromise(handle.trigger(overlap)).mapError((error) => new RuntimeClientError("schedule.trigger", error)).mapOk(() => void 0),
-		delete: () => Future.fromPromise(handle.delete()).mapError((error) => new RuntimeClientError("schedule.delete", error)).mapOk(() => void 0),
-		describe: () => Future.fromPromise(handle.describe()).mapError((error) => new RuntimeClientError("schedule.describe", error))
+		pause: (note) => ResultAsync.fromPromise(handle.pause(note), (error) => new RuntimeClientError("schedule.pause", error)).map(() => void 0),
+		unpause: (note) => ResultAsync.fromPromise(handle.unpause(note), (error) => new RuntimeClientError("schedule.unpause", error)).map(() => void 0),
+		trigger: (overlap) => ResultAsync.fromPromise(handle.trigger(overlap), (error) => new RuntimeClientError("schedule.trigger", error)).map(() => void 0),
+		delete: () => ResultAsync.fromPromise(handle.delete(), (error) => new RuntimeClientError("schedule.delete", error)).map(() => void 0),
+		describe: () => ResultAsync.fromPromise(handle.describe(), (error) => new RuntimeClientError("schedule.describe", error))
 	};
 }
 //#endregion
@@ -354,7 +315,37 @@ function toTypedSearchAttributes(workflowDef, values) {
 	return pairs.length > 0 ? new TypedSearchAttributes(pairs) : void 0;
 }
 /**
-* Typed Temporal client with Result/Future pattern based on a contract
+* Shared pre-call ritual for the three contract-driven entry points that
+* actually start a workflow (`startWorkflow`, `signalWithStart`,
+* `executeWorkflow`):
+*
+*   1. Look up the workflow definition on the contract.
+*   2. Surface a `WorkflowNotFoundError` if absent.
+*   3. Validate `args` against the workflow's input schema.
+*   4. Surface a `WorkflowValidationError` if validation fails.
+*   5. Translate any caller-supplied `searchAttributes` into Temporal's
+*      `TypedSearchAttributes` shape (or `undefined`).
+*
+* `getHandle` deliberately keeps its own three-line lookup — it doesn't
+* accept `args` or `searchAttributes`, so it can't share this helper. The
+* call-specific extras (signal validation, post-call output validation,
+* extended error classification) stay at the call site — those are the
+* differentiators that make each method distinct.
+*/
+async function resolveDefinitionAndValidateInput(contract, workflowName, args, searchAttributes) {
+	const definition = contract.workflows[workflowName];
+	if (!definition) return err(createWorkflowNotFoundError(workflowName, contract));
+	const inputResult = await definition.input["~standard"].validate(args);
+	if (inputResult.issues) return err(createWorkflowValidationError(workflowName, "input", inputResult.issues));
+	const typedSearchAttributes = toTypedSearchAttributes(definition, searchAttributes);
+	return ok({
+		definition,
+		validatedInput: inputResult.value,
+		typedSearchAttributes
+	});
+}
+/**
+* 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.
@@ -378,10 +369,10 @@ var TypedClient = class TypedClient {
 	*   args: { orderId: "sweep" },
 	* });
 	*
-	* result.match({
-	*   Ok: async (handle) => { await handle.pause("maintenance"); },
-	*   Error: (error) => console.error("schedule create failed", error),
-	* });
+	* result.match(
+	*   async (handle) => { await handle.pause("maintenance"); },
+	*   (error) => console.error("schedule create failed", error),
+	* );
 	* ```
 	*/
 	schedule;
@@ -392,7 +383,7 @@ var TypedClient = class TypedClient {
 		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
@@ -405,17 +396,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
@@ -426,35 +417,33 @@ 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 Result.Error(createWorkflowNotFoundError(workflowName, this.contract));
-			const inputResult = await definition.input["~standard"].validate(args);
-			if (inputResult.issues) return Result.Error(createWorkflowValidationError(workflowName, "input", inputResult.issues));
-			const typedSearchAttributes = toTypedSearchAttributes(definition, searchAttributes);
+			const resolved = await resolveDefinitionAndValidateInput(this.contract, workflowName, args, searchAttributes);
+			if (resolved.isErr()) return err(resolved.error);
+			const { definition, validatedInput, typedSearchAttributes } = resolved.value;
 			try {
 				const handle = await this.client.workflow.start(workflowName, {
 					...temporalOptions,
 					taskQueue: this.contract.taskQueue,
-					args: [inputResult.value],
+					args: [validatedInput],
 					...typedSearchAttributes ? { typedSearchAttributes } : {}
 				});
-				return Result.Ok(this.createTypedHandle(handle, definition));
+				return ok(this.createTypedHandle(handle, definition));
 			} catch (error) {
-				return Result.Error(classifyStartError("startWorkflow", error));
+				return err(classifyStartError("startWorkflow", error));
 			}
 		};
-		return makeFuture(work);
+		return makeResultAsync(work);
 	}
 	/**
 	* Send a signal to a workflow, starting it first if it doesn't already exist.
@@ -476,45 +465,42 @@ var TypedClient = class TypedClient {
 	*   signalArgs: { reason: 'duplicate' },
 	* });
 	*
-	* result.match({
-	*   Ok: (handle) => console.log('signaled run', handle.signaledRunId),
-	*   Error: (error) => console.error('signalWithStart failed', error),
-	* });
+	* result.match(
+	*   (handle) => console.log('signaled run', handle.signaledRunId),
+	*   (error) => console.error('signalWithStart failed', error),
+	* );
 	* ```
 	*/
 	signalWithStart(workflowName, { args, signalName, signalArgs, searchAttributes, ...temporalOptions }) {
 		const work = async () => {
-			const definition = this.contract.workflows[workflowName];
-			if (!definition) return Result.Error(createWorkflowNotFoundError(workflowName, this.contract));
-			const inputResult = await definition.input["~standard"].validate(args);
-			if (inputResult.issues) return Result.Error(createWorkflowValidationError(workflowName, "input", inputResult.issues));
+			const resolved = await resolveDefinitionAndValidateInput(this.contract, workflowName, args, searchAttributes);
+			if (resolved.isErr()) return err(resolved.error);
+			const { definition, validatedInput, typedSearchAttributes } = resolved.value;
 			const signalDef = definition.signals?.[signalName];
-			if (!signalDef) return Result.Error(new SignalValidationError(signalName, [{ message: `Signal "${signalName}" is not declared on workflow "${String(workflowName)}".` }]));
+			if (!signalDef) return err(new SignalValidationError(signalName, [{ message: `Signal "${signalName}" is not declared on workflow "${workflowName}".` }]));
 			const signalInputResult = await signalDef.input["~standard"].validate(signalArgs);
-			if (signalInputResult.issues) return Result.Error(new SignalValidationError(signalName, signalInputResult.issues));
-			const typedSearchAttributes = toTypedSearchAttributes(definition, searchAttributes);
+			if (signalInputResult.issues) return err(new SignalValidationError(signalName, signalInputResult.issues));
 			try {
 				const handle = await this.client.workflow.signalWithStart(workflowName, {
 					...temporalOptions,
 					taskQueue: this.contract.taskQueue,
-					args: [inputResult.value],
+					args: [validatedInput],
 					signal: signalName,
 					signalArgs: [signalInputResult.value],
 					...typedSearchAttributes ? { typedSearchAttributes } : {}
 				});
-				const typed = this.createTypedHandle(handle, definition);
-				return Result.Ok({
-					...typed,
+				return ok({
+					...this.createTypedHandle(handle, definition),
 					signaledRunId: handle.signaledRunId
 				});
 			} catch (error) {
-				return Result.Error(classifyStartError("signalWithStart", error));
+				return err(classifyStartError("signalWithStart", error));
 			}
 		};
-		return makeFuture(work);
+		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
@@ -525,65 +511,63 @@ 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, searchAttributes, ...temporalOptions }) {
 		const work = async () => {
-			const definition = this.contract.workflows[workflowName];
-			if (!definition) return Result.Error(createWorkflowNotFoundError(workflowName, this.contract));
-			const inputResult = await definition.input["~standard"].validate(args);
-			if (inputResult.issues) return Result.Error(createWorkflowValidationError(workflowName, "input", inputResult.issues));
-			const typedSearchAttributes = toTypedSearchAttributes(definition, searchAttributes);
+			const resolved = await resolveDefinitionAndValidateInput(this.contract, workflowName, args, searchAttributes);
+			if (resolved.isErr()) return err(resolved.error);
+			const { definition, validatedInput, typedSearchAttributes } = resolved.value;
 			try {
 				const result = await this.client.workflow.execute(workflowName, {
 					...temporalOptions,
 					taskQueue: this.contract.taskQueue,
-					args: [inputResult.value],
+					args: [validatedInput],
 					...typedSearchAttributes ? { typedSearchAttributes } : {}
 				});
 				const outputResult = await definition.output["~standard"].validate(result);
-				if (outputResult.issues) return Result.Error(createWorkflowValidationError(workflowName, "output", outputResult.issues));
-				return Result.Ok(outputResult.value);
+				if (outputResult.issues) return err(createWorkflowValidationError(workflowName, "output", outputResult.issues));
+				return ok(outputResult.value);
 			} catch (error) {
-				if (error instanceof WorkflowExecutionAlreadyStartedError) return Result.Error(new WorkflowAlreadyStartedError(error.workflowType, error.workflowId, error));
-				if (error instanceof WorkflowFailedError$1) return Result.Error(new WorkflowFailedError(temporalOptions.workflowId, error.cause));
-				if (error instanceof WorkflowNotFoundError$1) return Result.Error(new WorkflowExecutionNotFoundError(error.workflowId || temporalOptions.workflowId, error.runId, error));
-				return Result.Error(createRuntimeClientError("executeWorkflow", error));
+				if (error instanceof WorkflowExecutionAlreadyStartedError) return err(new WorkflowAlreadyStartedError(error.workflowType, error.workflowId, error));
+				if (error instanceof WorkflowFailedError$1) return err(new WorkflowFailedError(temporalOptions.workflowId, error.cause));
+				if (error instanceof WorkflowNotFoundError$1) return err(new WorkflowExecutionNotFoundError(error.workflowId || temporalOptions.workflowId, error.runId, error));
+				return err(createRuntimeClientError("executeWorkflow", error));
 			}
 		};
-		return makeFuture(work);
+		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) {
 		const work = async () => {
 			const definition = this.contract.workflows[workflowName];
-			if (!definition) return Result.Error(createWorkflowNotFoundError(workflowName, this.contract));
+			if (!definition) return err(createWorkflowNotFoundError(workflowName, this.contract));
 			try {
 				const handle = this.client.workflow.getHandle(workflowId);
-				return Result.Ok(this.createTypedHandle(handle, definition));
+				return ok(this.createTypedHandle(handle, definition));
 			} catch (error) {
-				return Result.Error(createRuntimeClientError("getHandle", error));
+				return err(createRuntimeClientError("getHandle", error));
 			}
 		};
-		return makeFuture(work);
+		return makeResultAsync(work);
 	}
 	createTypedHandle(workflowHandle, definition) {
 		const queries = buildValidatedProxy({
@@ -622,18 +606,18 @@ var TypedClient = class TypedClient {
 					try {
 						const result = await workflowHandle.result();
 						const outputResult = await definition.output["~standard"].validate(result);
-						if (outputResult.issues) return Result.Error(new WorkflowValidationError(workflowHandle.workflowId, "output", outputResult.issues));
-						return Result.Ok(outputResult.value);
+						if (outputResult.issues) return err(new WorkflowValidationError(workflowHandle.workflowId, "output", outputResult.issues));
+						return ok(outputResult.value);
 					} catch (error) {
-						return Result.Error(classifyResultError("result", error, workflowHandle.workflowId));
+						return err(classifyResultError("result", error, workflowHandle.workflowId));
 					}
 				};
-				return makeFuture(work);
+				return makeResultAsync(work);
 			},
-			terminate: (reason) => Future.fromPromise(workflowHandle.terminate(reason)).mapError((error) => classifyHandleError("terminate", error, workflowHandle.workflowId)).mapOk(() => void 0),
-			cancel: () => Future.fromPromise(workflowHandle.cancel()).mapError((error) => classifyHandleError("cancel", error, workflowHandle.workflowId)).mapOk(() => void 0),
-			describe: () => Future.fromPromise(workflowHandle.describe()).mapError((error) => classifyHandleError("describe", error, workflowHandle.workflowId)),
-			fetchHistory: () => Future.fromPromise(workflowHandle.fetchHistory()).mapError((error) => classifyHandleError("fetchHistory", error, workflowHandle.workflowId))
+			terminate: (reason) => ResultAsync.fromPromise(workflowHandle.terminate(reason), (error) => classifyHandleError("terminate", error, workflowHandle.workflowId)).map(() => void 0),
+			cancel: () => ResultAsync.fromPromise(workflowHandle.cancel(), (error) => classifyHandleError("cancel", error, workflowHandle.workflowId)).map(() => void 0),
+			describe: () => ResultAsync.fromPromise(workflowHandle.describe(), (error) => classifyHandleError("describe", error, workflowHandle.workflowId)),
+			fetchHistory: () => ResultAsync.fromPromise(workflowHandle.fetchHistory(), (error) => classifyHandleError("fetchHistory", error, workflowHandle.workflowId))
 		};
 	}
 };
@@ -647,7 +631,7 @@ function createWorkflowValidationError(workflowName, direction, issues) {
 	return new WorkflowValidationError(String(workflowName), direction, issues);
 }
 /**
-* Build a `{ name: (args) => Future<Result<...>> }` proxy for a contract's
+* 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
@@ -659,19 +643,19 @@ function buildValidatedProxy({ defs, operation, workflowId, makeValidationError,
 	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 Result.Error(makeValidationError(name, "input", inputResult.issues));
+			if (inputResult.issues) return err(makeValidationError(name, "input", inputResult.issues));
 			try {
 				const result = await invoke(name, inputResult.value);
 				const outputSchema = validateOutput(def);
-				if (!outputSchema) return Result.Ok(result);
+				if (!outputSchema) return ok(result);
 				const outputResult = await outputSchema["~standard"].validate(result);
-				if (outputResult.issues) return Result.Error(makeValidationError(name, "output", outputResult.issues));
-				return Result.Ok(outputResult.value);
+				if (outputResult.issues) return err(makeValidationError(name, "output", outputResult.issues));
+				return ok(outputResult.value);
 			} catch (error) {
-				return Result.Error(classifyHandleError(operation, error, workflowId));
+				return err(classifyHandleError(operation, error, workflowId));
 			}
 		};
-		return makeFuture(work);
+		return makeResultAsync(work);
 	};
 	return proxy;
 }