@temporal-contract/client 2.3.1 → 3.0.0

package/dist/index.mjs

@@ -1,41 +1,31 @@
 import { TypedSearchAttributes, WorkflowNotFoundError as WorkflowNotFoundError$1, defineSearchAttributeKey } from "@temporalio/common";
-import { ResultAsync, err, ok } from "neverthrow";
+import { TaggedError, err, fromPromise, ok } from "unthrown";
 import { summarizeIssues } from "@temporal-contract/contract";
 import { WorkflowExecutionAlreadyStartedError, WorkflowFailedError as WorkflowFailedError$1 } from "@temporalio/client";
-import { _internal_makeResultAsync } from "@temporal-contract/contract/result-async";
+import { _internal_assertNoDefect as assertNoDefect, _internal_makeAsyncResult } from "@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 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 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(", ")}`
+		});
 	}
 };
 /**
@@ -49,15 +39,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 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.`
+		});
 	}
 };
 /**
@@ -72,15 +61,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 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.`
+		});
 	}
 };
 /**
@@ -102,68 +90,65 @@ var WorkflowExecutionNotFoundError = class extends TypedClientError {
 *
 * Returned from `executeWorkflow` and `handle.result()`.
 */
-var WorkflowFailedError = class extends TypedClientError {
-	workflowId;
-	cause;
+var WorkflowFailedError = class extends 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 TaggedError("@temporal-contract/WorkflowValidationError", { name: "WorkflowValidationError" }) {
 	constructor(workflowName, direction, issues) {
-		super(`Validation failed for workflow "${workflowName}" ${direction}: ${summarizeIssues(issues)}`);
-		this.workflowName = workflowName;
-		this.direction = direction;
-		this.issues = issues;
+		super({
+			workflowName,
+			direction,
+			issues,
+			message: `Validation failed for workflow "${workflowName}" ${direction}: ${summarizeIssues(issues)}`
+		});
 	}
 };
 /**
 * Thrown when query input or output validation fails
 */
-var QueryValidationError = class extends TypedClientError {
-	queryName;
-	direction;
-	issues;
+var QueryValidationError = class extends TaggedError("@temporal-contract/QueryValidationError", { name: "QueryValidationError" }) {
 	constructor(queryName, direction, issues) {
-		super(`Validation failed for query "${queryName}" ${direction}: ${summarizeIssues(issues)}`);
-		this.queryName = queryName;
-		this.direction = direction;
-		this.issues = issues;
+		super({
+			queryName,
+			direction,
+			issues,
+			message: `Validation failed for query "${queryName}" ${direction}: ${summarizeIssues(issues)}`
+		});
 	}
 };
 /**
 * Thrown when signal input validation fails
 */
-var SignalValidationError = class extends TypedClientError {
-	signalName;
-	issues;
+var SignalValidationError = class extends TaggedError("@temporal-contract/SignalValidationError", { name: "SignalValidationError" }) {
 	constructor(signalName, issues) {
-		super(`Validation failed for signal "${signalName}": ${summarizeIssues(issues)}`);
-		this.signalName = signalName;
-		this.issues = issues;
+		super({
+			signalName,
+			issues,
+			message: `Validation failed for signal "${signalName}": ${summarizeIssues(issues)}`
+		});
 	}
 };
 /**
 * Thrown when update input or output validation fails
 */
-var UpdateValidationError = class extends TypedClientError {
-	updateName;
-	direction;
-	issues;
+var UpdateValidationError = class extends TaggedError("@temporal-contract/UpdateValidationError", { name: "UpdateValidationError" }) {
 	constructor(updateName, direction, issues) {
-		super(`Validation failed for update "${updateName}" ${direction}: ${summarizeIssues(issues)}`);
-		this.updateName = updateName;
-		this.direction = direction;
-		this.issues = issues;
+		super({
+			updateName,
+			direction,
+			issues,
+			message: `Validation failed for update "${updateName}" ${direction}: ${summarizeIssues(issues)}`
+		});
 	}
 };
 //#endregion
@@ -207,21 +192,23 @@ function toTypedSearchAttributes(workflowDef, workflowName, values) {
 	return ok(pairs.length > 0 ? new 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 _internal_makeResultAsync(work, (e) => new RuntimeClientError("unexpected", e));
+function makeAsyncResult(work) {
+	return _internal_makeAsyncResult(work);
 }
 /**
 * Map a thrown error from `client.workflow.start` / `signalWithStart` into
@@ -296,6 +283,7 @@ var TypedScheduleClient = class {
 			const inputResult = await definition.input["~standard"].validate(options.args);
 			if (inputResult.issues) return err(new WorkflowValidationError(workflowName, "input", inputResult.issues));
 			const searchAttributesResult = toTypedSearchAttributes(definition, workflowName, options.searchAttributes);
+			assertNoDefect(searchAttributesResult);
 			if (searchAttributesResult.isErr()) return err(searchAttributesResult.error);
 			const typedSearchAttributes = searchAttributesResult.value;
 			try {
@@ -327,7 +315,7 @@ var TypedScheduleClient = class {
 				return 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
@@ -341,11 +329,11 @@ var TypedScheduleClient = class {
 function wrapScheduleHandle(handle) {
 	return {
 		scheduleId: handle.scheduleId,
-		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))
+		pause: (note) => fromPromise(handle.pause(note), (error) => new RuntimeClientError("schedule.pause", error)).map(() => void 0),
+		unpause: (note) => fromPromise(handle.unpause(note), (error) => new RuntimeClientError("schedule.unpause", error)).map(() => void 0),
+		trigger: (overlap) => fromPromise(handle.trigger(overlap), (error) => new RuntimeClientError("schedule.trigger", error)).map(() => void 0),
+		delete: () => fromPromise(handle.delete(), (error) => new RuntimeClientError("schedule.delete", error)).map(() => void 0),
+		describe: () => fromPromise(handle.describe(), (error) => new RuntimeClientError("schedule.describe", error))
 	};
 }
 //#endregion
@@ -414,6 +402,7 @@ async function resolveDefinitionAndValidateInput(contract, workflowName, args, s
 	const inputResult = await definition.input["~standard"].validate(args);
 	if (inputResult.issues) return err(createWorkflowValidationError(workflowName, "input", inputResult.issues));
 	const searchAttributesResult = toTypedSearchAttributes(definition, workflowName, searchAttributes);
+	assertNoDefect(searchAttributesResult);
 	if (searchAttributesResult.isErr()) return err(searchAttributesResult.error);
 	const typedSearchAttributes = searchAttributesResult.value;
 	return ok({
@@ -423,7 +412,7 @@ async function resolveDefinitionAndValidateInput(contract, workflowName, args, s
 	});
 }
 /**
-* 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.
@@ -451,10 +440,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;
@@ -465,7 +455,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
@@ -478,17 +468,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
@@ -499,18 +490,20 @@ 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);
+			assertNoDefect(resolved);
 			if (resolved.isErr()) return err(resolved.error);
 			const { definition, validatedInput, typedSearchAttributes } = resolved.value;
 			try {
@@ -525,7 +518,7 @@ var TypedClient = class TypedClient {
 				return 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.
@@ -547,15 +540,17 @@ 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);
+			assertNoDefect(resolved);
 			if (resolved.isErr()) return err(resolved.error);
 			const { definition, validatedInput, typedSearchAttributes } = resolved.value;
 			const signalDef = definition.signals?.[signalName];
@@ -579,10 +574,10 @@ var TypedClient = class TypedClient {
 				return 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
@@ -593,15 +588,17 @@ 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);
+			assertNoDefect(resolved);
 			if (resolved.isErr()) return err(resolved.error);
 			const { definition, validatedInput, typedSearchAttributes } = resolved.value;
 			try {
@@ -621,10 +618,10 @@ var TypedClient = class TypedClient {
 				return 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
@@ -649,7 +646,7 @@ var TypedClient = class TypedClient {
 				return err(createRuntimeClientError("getHandle", error));
 			}
 		};
-		return makeResultAsync(work);
+		return makeAsyncResult(work);
 	}
 	createTypedHandle(workflowHandle, definition) {
 		const queries = buildValidatedProxy({
@@ -694,12 +691,12 @@ var TypedClient = class TypedClient {
 						return err(classifyResultError("result", error, workflowHandle.workflowId));
 					}
 				};
-				return makeResultAsync(work);
+				return makeAsyncResult(work);
 			},
-			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))
+			terminate: (reason) => fromPromise(workflowHandle.terminate(reason), (error) => classifyHandleError("terminate", error, workflowHandle.workflowId)).map(() => void 0),
+			cancel: () => fromPromise(workflowHandle.cancel(), (error) => classifyHandleError("cancel", error, workflowHandle.workflowId)).map(() => void 0),
+			describe: () => fromPromise(workflowHandle.describe(), (error) => classifyHandleError("describe", error, workflowHandle.workflowId)),
+			fetchHistory: () => fromPromise(workflowHandle.fetchHistory(), (error) => classifyHandleError("fetchHistory", error, workflowHandle.workflowId))
 		};
 	}
 };
@@ -713,7 +710,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
@@ -737,7 +734,7 @@ function buildValidatedProxy({ defs, operation, workflowId, makeValidationError,
 				return err(classifyHandleError(operation, error, workflowId));
 			}
 		};
-		return makeResultAsync(work);
+		return makeAsyncResult(work);
 	};
 	return proxy;
 }