@temporal-contract/client 2.3.1 → 3.0.0

package/README.md

@@ -29,11 +29,11 @@ const result = await client.executeWorkflow("processOrder", {
 
 ## Documentation
 
-📖 **[Read the full documentation →](https://btravers.github.io/temporal-contract)**
+📖 **[Read the full documentation →](https://btravstack.github.io/temporal-contract)**
 
-- [API Reference](https://btravers.github.io/temporal-contract/api/client)
-- [Getting Started](https://btravers.github.io/temporal-contract/guide/getting-started)
-- [Examples](https://btravers.github.io/temporal-contract/examples/)
+- [API Reference](https://btravstack.github.io/temporal-contract/api/client)
+- [Getting Started](https://btravstack.github.io/temporal-contract/guide/getting-started)
+- [Examples](https://btravstack.github.io/temporal-contract/examples/)
 
 ## License
 

package/dist/index.cjs

@@ -1,42 +1,32 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let _temporalio_common = require("@temporalio/common");
-let neverthrow = require("neverthrow");
+let unthrown = require("unthrown");
 let _temporal_contract_contract = require("@temporal-contract/contract");
 let _temporalio_client = require("@temporalio/client");
 let _temporal_contract_contract_result_async = require("@temporal-contract/contract/result-async");
 //#region src/errors.ts
 /**
-* Base class for all typed client errors.
-*/
-var TypedClientError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = this.constructor.name;
-		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-	}
-};
-/**
 * Generic runtime failure wrapper when no specific error type applies
 */
-var RuntimeClientError = class extends TypedClientError {
-	operation;
-	cause;
+var RuntimeClientError = class extends (0, unthrown.TaggedError)("@temporal-contract/RuntimeClientError", { name: "RuntimeClientError" }) {
 	constructor(operation, cause) {
-		super(`Operation "${operation}" failed: ${cause instanceof Error ? cause.message : String(cause ?? "unknown error")}`);
-		this.operation = operation;
-		this.cause = cause;
+		super({
+			operation,
+			cause,
+			message: `Operation "${operation}" failed: ${cause instanceof Error ? cause.message : String(cause ?? "unknown error")}`
+		});
 	}
 };
 /**
 * Thrown when a workflow is not found in the contract
 */
-var WorkflowNotFoundError = class extends TypedClientError {
-	workflowName;
-	availableWorkflows;
+var WorkflowNotFoundError = class extends (0, unthrown.TaggedError)("@temporal-contract/WorkflowNotFoundError", { name: "WorkflowNotFoundError" }) {
 	constructor(workflowName, availableWorkflows) {
-		super(`Workflow "${workflowName}" not found in contract. Available workflows: ${availableWorkflows.join(", ")}`);
-		this.workflowName = workflowName;
-		this.availableWorkflows = availableWorkflows;
+		super({
+			workflowName,
+			availableWorkflows,
+			message: `Workflow "${workflowName}" not found in contract. Available workflows: ${availableWorkflows.join(", ")}`
+		});
 	}
 };
 /**
@@ -50,15 +40,14 @@ var WorkflowNotFoundError = class extends TypedClientError {
 * 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 {
-	workflowType;
-	workflowId;
-	cause;
+var WorkflowAlreadyStartedError = class extends (0, unthrown.TaggedError)("@temporal-contract/WorkflowAlreadyStartedError", { name: "WorkflowAlreadyStartedError" }) {
 	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;
+		super({
+			workflowType,
+			workflowId,
+			cause,
+			message: `Workflow "${workflowType}" with ID "${workflowId}" is already started or in retention.`
+		});
 	}
 };
 /**
@@ -73,15 +62,14 @@ var WorkflowAlreadyStartedError = class extends TypedClientError {
 * - `executeWorkflow` (when the underlying execute call hits a missing
 *   execution mid-flight)
 */
-var WorkflowExecutionNotFoundError = class extends TypedClientError {
-	workflowId;
-	runId;
-	cause;
+var WorkflowExecutionNotFoundError = class extends (0, unthrown.TaggedError)("@temporal-contract/WorkflowExecutionNotFoundError", { name: "WorkflowExecutionNotFoundError" }) {
 	constructor(workflowId, runId, cause) {
-		super(`Workflow execution "${workflowId}"${runId ? ` (run "${runId}")` : ""} not found in namespace.`);
-		this.workflowId = workflowId;
-		this.runId = runId;
-		this.cause = cause;
+		super({
+			workflowId,
+			runId,
+			cause,
+			message: `Workflow execution "${workflowId}"${runId ? ` (run "${runId}")` : ""} not found in namespace.`
+		});
 	}
 };
 /**
@@ -103,68 +91,65 @@ var WorkflowExecutionNotFoundError = class extends TypedClientError {
 *
 * Returned from `executeWorkflow` and `handle.result()`.
 */
-var WorkflowFailedError = class extends TypedClientError {
-	workflowId;
-	cause;
+var WorkflowFailedError = class extends (0, unthrown.TaggedError)("@temporal-contract/WorkflowFailedError", { name: "WorkflowFailedError" }) {
 	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;
+		super({
+			workflowId,
+			cause,
+			message: `Workflow "${workflowId}" completed with failure: ${causeMessage}`
+		});
 	}
 };
 /**
 * Thrown when workflow input or output validation fails
 */
-var WorkflowValidationError = class extends TypedClientError {
-	workflowName;
-	direction;
-	issues;
+var WorkflowValidationError = class extends (0, unthrown.TaggedError)("@temporal-contract/WorkflowValidationError", { name: "WorkflowValidationError" }) {
 	constructor(workflowName, direction, issues) {
-		super(`Validation failed for workflow "${workflowName}" ${direction}: ${(0, _temporal_contract_contract.summarizeIssues)(issues)}`);
-		this.workflowName = workflowName;
-		this.direction = direction;
-		this.issues = issues;
+		super({
+			workflowName,
+			direction,
+			issues,
+			message: `Validation failed for workflow "${workflowName}" ${direction}: ${(0, _temporal_contract_contract.summarizeIssues)(issues)}`
+		});
 	}
 };
 /**
 * Thrown when query input or output validation fails
 */
-var QueryValidationError = class extends TypedClientError {
-	queryName;
-	direction;
-	issues;
+var QueryValidationError = class extends (0, unthrown.TaggedError)("@temporal-contract/QueryValidationError", { name: "QueryValidationError" }) {
 	constructor(queryName, direction, issues) {
-		super(`Validation failed for query "${queryName}" ${direction}: ${(0, _temporal_contract_contract.summarizeIssues)(issues)}`);
-		this.queryName = queryName;
-		this.direction = direction;
-		this.issues = issues;
+		super({
+			queryName,
+			direction,
+			issues,
+			message: `Validation failed for query "${queryName}" ${direction}: ${(0, _temporal_contract_contract.summarizeIssues)(issues)}`
+		});
 	}
 };
 /**
 * Thrown when signal input validation fails
 */
-var SignalValidationError = class extends TypedClientError {
-	signalName;
-	issues;
+var SignalValidationError = class extends (0, unthrown.TaggedError)("@temporal-contract/SignalValidationError", { name: "SignalValidationError" }) {
 	constructor(signalName, issues) {
-		super(`Validation failed for signal "${signalName}": ${(0, _temporal_contract_contract.summarizeIssues)(issues)}`);
-		this.signalName = signalName;
-		this.issues = issues;
+		super({
+			signalName,
+			issues,
+			message: `Validation failed for signal "${signalName}": ${(0, _temporal_contract_contract.summarizeIssues)(issues)}`
+		});
 	}
 };
 /**
 * Thrown when update input or output validation fails
 */
-var UpdateValidationError = class extends TypedClientError {
-	updateName;
-	direction;
-	issues;
+var UpdateValidationError = class extends (0, unthrown.TaggedError)("@temporal-contract/UpdateValidationError", { name: "UpdateValidationError" }) {
 	constructor(updateName, direction, issues) {
-		super(`Validation failed for update "${updateName}" ${direction}: ${(0, _temporal_contract_contract.summarizeIssues)(issues)}`);
-		this.updateName = updateName;
-		this.direction = direction;
-		this.issues = issues;
+		super({
+			updateName,
+			direction,
+			issues,
+			message: `Validation failed for update "${updateName}" ${direction}: ${(0, _temporal_contract_contract.summarizeIssues)(issues)}`
+		});
 	}
 };
 //#endregion
@@ -192,37 +177,39 @@ var UpdateValidationError = class extends TypedClientError {
 * unindexed without any signal to the caller.
 */
 function toTypedSearchAttributes(workflowDef, workflowName, values) {
-	if (!values) return (0, neverthrow.ok)(void 0);
+	if (!values) return (0, unthrown.ok)(void 0);
 	const declared = workflowDef.searchAttributes ?? {};
 	const pairs = [];
 	for (const [name, value] of Object.entries(values)) {
 		if (value === void 0) continue;
 		const def = declared[name];
-		if (!def) return (0, neverthrow.err)(new RuntimeClientError("searchAttributes", /* @__PURE__ */ new Error(`Search attribute "${name}" is not declared on workflow "${workflowName}". Declared attributes: ${Object.keys(declared).join(", ") || "none"}.`)));
+		if (!def) return (0, unthrown.err)(new RuntimeClientError("searchAttributes", /* @__PURE__ */ new Error(`Search attribute "${name}" is not declared on workflow "${workflowName}". Declared attributes: ${Object.keys(declared).join(", ") || "none"}.`)));
 		const key = (0, _temporalio_common.defineSearchAttributeKey)(name, def.kind);
 		pairs.push({
 			key,
 			value
 		});
 	}
-	return (0, neverthrow.ok)(pairs.length > 0 ? new _temporalio_common.TypedSearchAttributes(pairs) : void 0);
+	return (0, unthrown.ok)(pairs.length > 0 ? new _temporalio_common.TypedSearchAttributes(pairs) : void 0);
 }
 /**
-* Wrap an async result-producing function in a `ResultAsync`, catching any
-* unhandled rejection as a `RuntimeClientError("unexpected", error)`.
+* Wrap an async result-producing function in an `AsyncResult`, routing any
+* unanticipated rejection through unthrown's `defect` channel.
 *
 * 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.
+* an `err(...)` for them; a thrown exception the work didn't anticipate is an
+* *unmodeled* failure and surfaces as a defect (inspectable via
+* `result.isDefect()` / `result.cause`, re-thrown at the edge) rather than a
+* manufactured `RuntimeClientError`.
 *
 * Used by `client.ts` (workflow operations) and `schedule.ts` (schedule
 * operations) so the unexpected-rejection shape is identical across the
-* typed client surface. Delegates to `_internal_makeResultAsync` from
+* typed client surface. Delegates to `_internal_makeAsyncResult` from
 * `@temporal-contract/contract` so the same wrapper is shared between the
 * client and worker packages.
 */
-function makeResultAsync(work) {
-	return (0, _temporal_contract_contract_result_async._internal_makeResultAsync)(work, (e) => new RuntimeClientError("unexpected", e));
+function makeAsyncResult(work) {
+	return (0, _temporal_contract_contract_result_async._internal_makeAsyncResult)(work);
 }
 /**
 * Map a thrown error from `client.workflow.start` / `signalWithStart` into
@@ -293,11 +280,12 @@ var TypedScheduleClient = class {
 	create(workflowName, options) {
 		const work = async () => {
 			const definition = this.contract.workflows[workflowName];
-			if (!definition) return (0, neverthrow.err)(new WorkflowNotFoundError(workflowName, Object.keys(this.contract.workflows)));
+			if (!definition) return (0, unthrown.err)(new WorkflowNotFoundError(workflowName, Object.keys(this.contract.workflows)));
 			const inputResult = await definition.input["~standard"].validate(options.args);
-			if (inputResult.issues) return (0, neverthrow.err)(new WorkflowValidationError(workflowName, "input", inputResult.issues));
+			if (inputResult.issues) return (0, unthrown.err)(new WorkflowValidationError(workflowName, "input", inputResult.issues));
 			const searchAttributesResult = toTypedSearchAttributes(definition, workflowName, options.searchAttributes);
-			if (searchAttributesResult.isErr()) return (0, neverthrow.err)(searchAttributesResult.error);
+			(0, _temporal_contract_contract_result_async._internal_assertNoDefect)(searchAttributesResult);
+			if (searchAttributesResult.isErr()) return (0, unthrown.err)(searchAttributesResult.error);
 			const typedSearchAttributes = searchAttributesResult.value;
 			try {
 				const overrides = options.action ?? {};
@@ -316,7 +304,7 @@ var TypedScheduleClient = class {
 					...overrides.staticDetails !== void 0 ? { staticDetails: overrides.staticDetails } : {},
 					...overrides.staticSummary !== void 0 ? { staticSummary: overrides.staticSummary } : {}
 				};
-				return (0, neverthrow.ok)(wrapScheduleHandle(await this.scheduleClient.create({
+				return (0, unthrown.ok)(wrapScheduleHandle(await this.scheduleClient.create({
 					scheduleId: options.scheduleId,
 					spec: options.spec,
 					action,
@@ -325,10 +313,10 @@ var TypedScheduleClient = class {
 					...options.memo !== void 0 ? { memo: options.memo } : {}
 				})));
 			} catch (error) {
-				return (0, neverthrow.err)(new RuntimeClientError("schedule.create", error));
+				return (0, unthrown.err)(new RuntimeClientError("schedule.create", error));
 			}
 		};
-		return makeResultAsync(work);
+		return makeAsyncResult(work);
 	}
 	/**
 	* Get a typed handle to an existing schedule. Does not validate that the
@@ -342,11 +330,11 @@ var TypedScheduleClient = class {
 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))
+		pause: (note) => (0, unthrown.fromPromise)(handle.pause(note), (error) => new RuntimeClientError("schedule.pause", error)).map(() => void 0),
+		unpause: (note) => (0, unthrown.fromPromise)(handle.unpause(note), (error) => new RuntimeClientError("schedule.unpause", error)).map(() => void 0),
+		trigger: (overlap) => (0, unthrown.fromPromise)(handle.trigger(overlap), (error) => new RuntimeClientError("schedule.trigger", error)).map(() => void 0),
+		delete: () => (0, unthrown.fromPromise)(handle.delete(), (error) => new RuntimeClientError("schedule.delete", error)).map(() => void 0),
+		describe: () => (0, unthrown.fromPromise)(handle.describe(), (error) => new RuntimeClientError("schedule.describe", error))
 	};
 }
 //#endregion
@@ -411,20 +399,21 @@ function readTypedSearchAttributes(workflowDef, instance) {
 */
 async function resolveDefinitionAndValidateInput(contract, workflowName, args, searchAttributes) {
 	const definition = contract.workflows[workflowName];
-	if (!definition) return (0, neverthrow.err)(createWorkflowNotFoundError(workflowName, contract));
+	if (!definition) return (0, unthrown.err)(createWorkflowNotFoundError(workflowName, contract));
 	const inputResult = await definition.input["~standard"].validate(args);
-	if (inputResult.issues) return (0, neverthrow.err)(createWorkflowValidationError(workflowName, "input", inputResult.issues));
+	if (inputResult.issues) return (0, unthrown.err)(createWorkflowValidationError(workflowName, "input", inputResult.issues));
 	const searchAttributesResult = toTypedSearchAttributes(definition, workflowName, searchAttributes);
-	if (searchAttributesResult.isErr()) return (0, neverthrow.err)(searchAttributesResult.error);
+	(0, _temporal_contract_contract_result_async._internal_assertNoDefect)(searchAttributesResult);
+	if (searchAttributesResult.isErr()) return (0, unthrown.err)(searchAttributesResult.error);
 	const typedSearchAttributes = searchAttributesResult.value;
-	return (0, neverthrow.ok)({
+	return (0, unthrown.ok)({
 		definition,
 		validatedInput: inputResult.value,
 		typedSearchAttributes
 	});
 }
 /**
-* Typed Temporal client with neverthrow Result/ResultAsync pattern based on a contract
+* Typed Temporal client with unthrown Result/AsyncResult 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.
@@ -452,10 +441,11 @@ var TypedClient = class TypedClient {
 	*   args: { orderId: "sweep" },
 	* });
 	*
-	* result.match(
-	*   async (handle) => { await handle.pause("maintenance"); },
-	*   (error) => console.error("schedule create failed", error),
-	* );
+	* await result.match({
+	*   ok: async (handle) => { await handle.pause("maintenance"); },
+	*   err: (error) => console.error("schedule create failed", error),
+	*   defect: (cause) => console.error("unexpected failure", cause),
+	* });
 	* ```
 	*/
 	schedule;
@@ -466,7 +456,7 @@ var TypedClient = class TypedClient {
 		this.schedule = new TypedScheduleClient(contract, client.schedule);
 	}
 	/**
-	* Create a typed Temporal client with neverthrow pattern from a contract
+	* Create a typed Temporal client with unthrown pattern from a contract
 	*
 	* @example
 	* ```ts
@@ -479,17 +469,18 @@ var TypedClient = class TypedClient {
 	*   args: { ... },
 	* });
 	*
-	* result.match(
-	*   (output) => console.log('Success:', output),
-	*   (error) => console.error('Failed:', error),
-	* );
+	* await result.match({
+	*   ok: (output) => console.log('Success:', output),
+	*   err: (error) => console.error('Failed:', error),
+	*   defect: (cause) => console.error('Unexpected failure:', cause),
+	* });
 	* ```
 	*/
 	static create(contract, client) {
 		return new TypedClient(contract, client);
 	}
 	/**
-	* Start a workflow and return a typed handle with ResultAsync pattern
+	* Start a workflow and return a typed handle with AsyncResult pattern
 	*
 	* @example
 	* ```ts
@@ -500,19 +491,21 @@ var TypedClient = class TypedClient {
 	*   retry: { maximumAttempts: 3 },
 	* });
 	*
-	* handleResult.match(
-	*   async (handle) => {
+	* await handleResult.match({
+	*   ok: async (handle) => {
 	*     const result = await handle.result();
 	*     // ... handle result
 	*   },
-	*   (error) => console.error('Failed to start:', error),
-	* );
+	*   err: (error) => console.error('Failed to start:', error),
+	*   defect: (cause) => console.error('Unexpected failure:', cause),
+	* });
 	* ```
 	*/
 	startWorkflow(workflowName, { args, searchAttributes, ...temporalOptions }) {
 		const work = async () => {
 			const resolved = await resolveDefinitionAndValidateInput(this.contract, workflowName, args, searchAttributes);
-			if (resolved.isErr()) return (0, neverthrow.err)(resolved.error);
+			(0, _temporal_contract_contract_result_async._internal_assertNoDefect)(resolved);
+			if (resolved.isErr()) return (0, unthrown.err)(resolved.error);
 			const { definition, validatedInput, typedSearchAttributes } = resolved.value;
 			try {
 				const handle = await this.client.workflow.start(workflowName, {
@@ -521,12 +514,12 @@ var TypedClient = class TypedClient {
 					args: [validatedInput],
 					...typedSearchAttributes ? { typedSearchAttributes } : {}
 				});
-				return (0, neverthrow.ok)(this.createTypedHandle(handle, definition));
+				return (0, unthrown.ok)(this.createTypedHandle(handle, definition));
 			} catch (error) {
-				return (0, neverthrow.err)(classifyStartError("startWorkflow", error));
+				return (0, unthrown.err)(classifyStartError("startWorkflow", error));
 			}
 		};
-		return makeResultAsync(work);
+		return makeAsyncResult(work);
 	}
 	/**
 	* Send a signal to a workflow, starting it first if it doesn't already exist.
@@ -548,21 +541,23 @@ var TypedClient = class TypedClient {
 	*   signalArgs: { reason: 'duplicate' },
 	* });
 	*
-	* result.match(
-	*   (handle) => console.log('signaled run', handle.signaledRunId),
-	*   (error) => console.error('signalWithStart failed', error),
-	* );
+	* await result.match({
+	*   ok: (handle) => console.log('signaled run', handle.signaledRunId),
+	*   err: (error) => console.error('signalWithStart failed', error),
+	*   defect: (cause) => console.error('unexpected failure', cause),
+	* });
 	* ```
 	*/
 	signalWithStart(workflowName, { args, signalName, signalArgs, searchAttributes, ...temporalOptions }) {
 		const work = async () => {
 			const resolved = await resolveDefinitionAndValidateInput(this.contract, workflowName, args, searchAttributes);
-			if (resolved.isErr()) return (0, neverthrow.err)(resolved.error);
+			(0, _temporal_contract_contract_result_async._internal_assertNoDefect)(resolved);
+			if (resolved.isErr()) return (0, unthrown.err)(resolved.error);
 			const { definition, validatedInput, typedSearchAttributes } = resolved.value;
 			const signalDef = definition.signals?.[signalName];
-			if (!signalDef) return (0, neverthrow.err)(new SignalValidationError(signalName, [{ message: `Signal "${signalName}" is not declared on workflow "${workflowName}".` }]));
+			if (!signalDef) return (0, unthrown.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 (0, neverthrow.err)(new SignalValidationError(signalName, signalInputResult.issues));
+			if (signalInputResult.issues) return (0, unthrown.err)(new SignalValidationError(signalName, signalInputResult.issues));
 			try {
 				const handle = await this.client.workflow.signalWithStart(workflowName, {
 					...temporalOptions,
@@ -572,18 +567,18 @@ var TypedClient = class TypedClient {
 					signalArgs: [signalInputResult.value],
 					...typedSearchAttributes ? { typedSearchAttributes } : {}
 				});
-				return (0, neverthrow.ok)({
+				return (0, unthrown.ok)({
 					...this.createTypedHandle(handle, definition),
 					signaledRunId: handle.signaledRunId
 				});
 			} catch (error) {
-				return (0, neverthrow.err)(classifyStartError("signalWithStart", error));
+				return (0, unthrown.err)(classifyStartError("signalWithStart", error));
 			}
 		};
-		return makeResultAsync(work);
+		return makeAsyncResult(work);
 	}
 	/**
-	* Execute a workflow (start and wait for result) with ResultAsync pattern
+	* Execute a workflow (start and wait for result) with AsyncResult pattern
 	*
 	* @example
 	* ```ts
@@ -594,16 +589,18 @@ var TypedClient = class TypedClient {
 	*   retry: { maximumAttempts: 3 },
 	* });
 	*
-	* result.match(
-	*   (output) => console.log('Order processed:', output.status),
-	*   (error) => console.error('Processing failed:', error),
-	* );
+	* await result.match({
+	*   ok: (output) => console.log('Order processed:', output.status),
+	*   err: (error) => console.error('Processing failed:', error),
+	*   defect: (cause) => console.error('Unexpected failure:', cause),
+	* });
 	* ```
 	*/
 	executeWorkflow(workflowName, { args, searchAttributes, ...temporalOptions }) {
 		const work = async () => {
 			const resolved = await resolveDefinitionAndValidateInput(this.contract, workflowName, args, searchAttributes);
-			if (resolved.isErr()) return (0, neverthrow.err)(resolved.error);
+			(0, _temporal_contract_contract_result_async._internal_assertNoDefect)(resolved);
+			if (resolved.isErr()) return (0, unthrown.err)(resolved.error);
 			const { definition, validatedInput, typedSearchAttributes } = resolved.value;
 			try {
 				const result = await this.client.workflow.execute(workflowName, {
@@ -613,19 +610,19 @@ var TypedClient = class TypedClient {
 					...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);
+				if (outputResult.issues) return (0, unthrown.err)(createWorkflowValidationError(workflowName, "output", outputResult.issues));
+				return (0, unthrown.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));
+				if (error instanceof _temporalio_client.WorkflowExecutionAlreadyStartedError) return (0, unthrown.err)(new WorkflowAlreadyStartedError(error.workflowType, error.workflowId, error));
+				if (error instanceof _temporalio_client.WorkflowFailedError) return (0, unthrown.err)(new WorkflowFailedError(temporalOptions.workflowId, error.cause));
+				if (error instanceof _temporalio_common.WorkflowNotFoundError) return (0, unthrown.err)(new WorkflowExecutionNotFoundError(error.workflowId || temporalOptions.workflowId, error.runId, error));
+				return (0, unthrown.err)(createRuntimeClientError("executeWorkflow", error));
 			}
 		};
-		return makeResultAsync(work);
+		return makeAsyncResult(work);
 	}
 	/**
-	* Get a handle to an existing workflow with ResultAsync pattern
+	* Get a handle to an existing workflow with AsyncResult pattern
 	*
 	* @example
 	* ```ts
@@ -642,15 +639,15 @@ var TypedClient = class TypedClient {
 	getHandle(workflowName, workflowId) {
 		const work = async () => {
 			const definition = this.contract.workflows[workflowName];
-			if (!definition) return (0, neverthrow.err)(createWorkflowNotFoundError(workflowName, this.contract));
+			if (!definition) return (0, unthrown.err)(createWorkflowNotFoundError(workflowName, this.contract));
 			try {
 				const handle = this.client.workflow.getHandle(workflowId);
-				return (0, neverthrow.ok)(this.createTypedHandle(handle, definition));
+				return (0, unthrown.ok)(this.createTypedHandle(handle, definition));
 			} catch (error) {
-				return (0, neverthrow.err)(createRuntimeClientError("getHandle", error));
+				return (0, unthrown.err)(createRuntimeClientError("getHandle", error));
 			}
 		};
-		return makeResultAsync(work);
+		return makeAsyncResult(work);
 	}
 	createTypedHandle(workflowHandle, definition) {
 		const queries = buildValidatedProxy({
@@ -689,18 +686,18 @@ var TypedClient = class TypedClient {
 					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);
+						if (outputResult.issues) return (0, unthrown.err)(new WorkflowValidationError(workflowHandle.workflowId, "output", outputResult.issues));
+						return (0, unthrown.ok)(outputResult.value);
 					} catch (error) {
-						return (0, neverthrow.err)(classifyResultError("result", error, workflowHandle.workflowId));
+						return (0, unthrown.err)(classifyResultError("result", error, workflowHandle.workflowId));
 					}
 				};
-				return makeResultAsync(work);
+				return makeAsyncResult(work);
 			},
-			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))
+			terminate: (reason) => (0, unthrown.fromPromise)(workflowHandle.terminate(reason), (error) => classifyHandleError("terminate", error, workflowHandle.workflowId)).map(() => void 0),
+			cancel: () => (0, unthrown.fromPromise)(workflowHandle.cancel(), (error) => classifyHandleError("cancel", error, workflowHandle.workflowId)).map(() => void 0),
+			describe: () => (0, unthrown.fromPromise)(workflowHandle.describe(), (error) => classifyHandleError("describe", error, workflowHandle.workflowId)),
+			fetchHistory: () => (0, unthrown.fromPromise)(workflowHandle.fetchHistory(), (error) => classifyHandleError("fetchHistory", error, workflowHandle.workflowId))
 		};
 	}
 };
@@ -714,7 +711,7 @@ function createWorkflowValidationError(workflowName, direction, issues) {
 	return new WorkflowValidationError(String(workflowName), direction, issues);
 }
 /**
-* Build a `{ name: (args) => ResultAsync<...> }` proxy for a contract's
+* Build a `{ name: (args) => AsyncResult<...> }` 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
@@ -726,19 +723,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 (0, neverthrow.err)(makeValidationError(name, "input", inputResult.issues));
+			if (inputResult.issues) return (0, unthrown.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);
+				if (!outputSchema) return (0, unthrown.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);
+				if (outputResult.issues) return (0, unthrown.err)(makeValidationError(name, "output", outputResult.issues));
+				return (0, unthrown.ok)(outputResult.value);
 			} catch (error) {
-				return (0, neverthrow.err)(classifyHandleError(operation, error, workflowId));
+				return (0, unthrown.err)(classifyHandleError(operation, error, workflowId));
 			}
 		};
-		return makeResultAsync(work);
+		return makeAsyncResult(work);
 	};
 	return proxy;
 }