@temporal-contract/worker 2.3.1 → 3.0.0

package/dist/workflow.cjs

@@ -1,34 +1,33 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_internal = require("./internal-DcM-YWYX.cjs");
+const require_internal = require("./internal-Clwokr1z.cjs");
+let unthrown = require("unthrown");
 let _temporalio_workflow = require("@temporalio/workflow");
-let neverthrow = require("neverthrow");
 let _temporal_contract_contract_result_async = require("@temporal-contract/contract/result-async");
 //#region src/cancellation.ts
 /**
 * Typed wrappers around Temporal's `CancellationScope` so workflows can
 * opt into cancellation control without reaching for
 * `@temporalio/workflow` directly. The wrappers fold cancellation into
-* the same `ResultAsync<...>` shape used elsewhere in the worker
+* the same `AsyncResult<...>` shape used elsewhere in the worker
 * context — callers branch on `err(WorkflowCancelledError)` instead of
 * catching `CancelledFailure`.
 *
-* Non-cancellation errors thrown inside the scope are wrapped in a
-* {@link WorkflowScopeError} (with the original error preserved on
-* `cause`) and surfaced on the same `err(...)` channel. Together with
-* `WorkflowCancelledError` this makes the failure modes exhaustive on
-* `result.match(...)` — nothing escapes as an unhandled rejection.
+* Non-cancellation errors thrown inside the scope are *unmodeled* failures:
+* they ride unthrown's `defect` channel (re-thrown at the edge / inspectable
+* via `result.isDefect()` and `result.cause`) rather than a typed `err(...)`,
+* keeping the modeled error channel to the single anticipated outcome —
+* cancellation.
 */
 /**
 * Run `fn` inside a cancellable Temporal scope. If the workflow (or an
 * ancestor scope) is cancelled while the function is in flight, the
-* resulting ResultAsync resolves to `err(WorkflowCancelledError)`,
+* resulting AsyncResult resolves to `err(WorkflowCancelledError)`,
 * letting callers handle cancellation explicitly — typically to perform
 * a graceful exit from the current step.
 *
-* Non-cancellation errors thrown by `fn` resolve to
-* `err(WorkflowScopeError)` (with the original error on `cause`) so
-* domain failures surface on the same typed error channel rather than
-* leaking as unhandled rejections.
+* Non-cancellation errors thrown by `fn` are unmodeled failures: they surface
+* on the `defect` channel rather than as a typed `err(...)`, so a genuine bug
+* is not silently treated as an anticipated domain outcome.
 *
 * @example
 * ```ts
@@ -36,28 +35,27 @@ let _temporal_contract_contract_result_async = require("@temporal-contract/contr
 *   return await context.activities.processStep(...);
 * });
 *
-* result.match(
-*   (output) => { ... },
-*   (error) => {
-*     if (error instanceof WorkflowCancelledError) {
-*       // graceful exit
-*     } else {
-*       // error instanceof WorkflowScopeError — domain failure on `cause`
-*     }
+* result.match({
+*   ok: (output) => { ... },
+*   err: (error) => {
+*     // error instanceof WorkflowCancelledError — graceful exit
+*   },
+*   defect: (cause) => {
+*     // a non-cancellation failure thrown inside the scope (a bug)
 *   },
-* );
+* });
 * ```
 */
 function cancellableScope(fn) {
 	const work = async () => {
 		try {
-			return (0, neverthrow.ok)(await _temporalio_workflow.CancellationScope.cancellable(async () => fn()));
+			return (0, unthrown.ok)(await _temporalio_workflow.CancellationScope.cancellable(async () => fn()));
 		} catch (error) {
-			if ((0, _temporalio_workflow.isCancellation)(error)) return (0, neverthrow.err)(new require_internal.WorkflowCancelledError(error));
-			return (0, neverthrow.err)(new require_internal.WorkflowScopeError(error));
+			if ((0, _temporalio_workflow.isCancellation)(error)) return (0, unthrown.err)(new require_internal.WorkflowCancelledError(error));
+			throw error;
 		}
 	};
-	return (0, _temporal_contract_contract_result_async._internal_makeResultAsync)(work, (e) => new require_internal.WorkflowScopeError(e));
+	return (0, _temporal_contract_contract_result_async._internal_makeAsyncResult)(work);
 }
 /**
 * Run `fn` inside a non-cancellable Temporal scope. Cancellation requests
@@ -65,10 +63,10 @@ function cancellableScope(fn) {
 * to perform cleanup that must not be interrupted (e.g. releasing a
 * resource after a graceful shutdown).
 *
-* Mirrors `cancellableScope`'s `ResultAsync<...>` shape for symmetry; the
+* Mirrors `cancellableScope`'s `AsyncResult<...>` shape for symmetry; the
 * `err(WorkflowCancelledError)` branch only triggers when cancellation is
-* raised from inside the scope (rare). Non-cancellation errors surface as
-* `err(WorkflowScopeError)`.
+* raised from inside the scope (rare). Non-cancellation errors surface on the
+* `defect` channel.
 *
 * @example
 * ```ts
@@ -80,13 +78,13 @@ function cancellableScope(fn) {
 function nonCancellableScope(fn) {
 	const work = async () => {
 		try {
-			return (0, neverthrow.ok)(await _temporalio_workflow.CancellationScope.nonCancellable(async () => fn()));
+			return (0, unthrown.ok)(await _temporalio_workflow.CancellationScope.nonCancellable(async () => fn()));
 		} catch (error) {
-			if ((0, _temporalio_workflow.isCancellation)(error)) return (0, neverthrow.err)(new require_internal.WorkflowCancelledError(error));
-			return (0, neverthrow.err)(new require_internal.WorkflowScopeError(error));
+			if ((0, _temporalio_workflow.isCancellation)(error)) return (0, unthrown.err)(new require_internal.WorkflowCancelledError(error));
+			throw error;
 		}
 	};
-	return (0, _temporal_contract_contract_result_async._internal_makeResultAsync)(work, (e) => new require_internal.WorkflowScopeError(e));
+	return (0, _temporal_contract_contract_result_async._internal_makeAsyncResult)(work);
 }
 //#endregion
 //#region src/handlers.ts
@@ -187,16 +185,16 @@ function bindUpdateHandler(workflowDefinition, workflowName, updateName, handler
 //#region src/child-workflow.ts
 async function validateChildWorkflowOutput(childDefinition, result, childWorkflowName) {
 	const outputResult = await childDefinition.output["~standard"].validate(result);
-	if (outputResult.issues) return (0, neverthrow.err)(new require_internal.ChildWorkflowError(require_internal.formatChildWorkflowValidationMessage(childWorkflowName, "output", outputResult.issues)));
-	return (0, neverthrow.ok)(outputResult.value);
+	if (outputResult.issues) return (0, unthrown.err)(new require_internal.ChildWorkflowError(require_internal.formatChildWorkflowValidationMessage(childWorkflowName, "output", outputResult.issues)));
+	return (0, unthrown.ok)(outputResult.value);
 }
 async function getAndValidateChildWorkflow(childContract, childWorkflowName, args) {
 	const childDefinition = childContract.workflows[childWorkflowName];
-	if (!childDefinition) return (0, neverthrow.err)(new require_internal.ChildWorkflowNotFoundError(childWorkflowName, Object.keys(childContract.workflows)));
+	if (!childDefinition) return (0, unthrown.err)(new require_internal.ChildWorkflowNotFoundError(childWorkflowName, Object.keys(childContract.workflows)));
 	const inputResult = await childDefinition.input["~standard"].validate(args);
-	if (inputResult.issues) return (0, neverthrow.err)(new require_internal.ChildWorkflowError(require_internal.formatChildWorkflowValidationMessage(childWorkflowName, "input", inputResult.issues)));
+	if (inputResult.issues) return (0, unthrown.err)(new require_internal.ChildWorkflowError(require_internal.formatChildWorkflowValidationMessage(childWorkflowName, "input", inputResult.issues)));
 	const validatedInput = inputResult.value;
-	return (0, neverthrow.ok)({
+	return (0, unthrown.ok)({
 		definition: childDefinition,
 		validatedInput,
 		taskQueue: childContract.taskQueue
@@ -210,35 +208,37 @@ function createTypedChildHandle(handle, childDefinition, childWorkflowName) {
 				try {
 					return validateChildWorkflowOutput(childDefinition, await handle.result(), childWorkflowName);
 				} catch (error) {
-					return (0, neverthrow.err)(require_internal.classifyChildWorkflowError("result", error, childWorkflowName));
+					return (0, unthrown.err)(require_internal.classifyChildWorkflowError("result", error, childWorkflowName));
 				}
 			};
-			return (0, _temporal_contract_contract_result_async._internal_makeResultAsync)(work, (error) => new require_internal.ChildWorkflowError(`Child workflow execution failed: ${error instanceof Error ? error.message : String(error)}`, error));
+			return (0, _temporal_contract_contract_result_async._internal_makeAsyncResult)(work);
 		}
 	};
 }
 function createStartChildWorkflow(childContract, childWorkflowName, options) {
 	const work = async () => {
 		const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options.args);
-		if (validationResult.isErr()) return (0, neverthrow.err)(validationResult.error);
+		(0, _temporal_contract_contract_result_async._internal_assertNoDefect)(validationResult);
+		if (validationResult.isErr()) return (0, unthrown.err)(validationResult.error);
 		const { definition: childDefinition, validatedInput, taskQueue } = validationResult.value;
 		try {
 			const { args: _args, ...temporalOptions } = options;
-			return (0, neverthrow.ok)(createTypedChildHandle(await (0, _temporalio_workflow.startChild)(childWorkflowName, {
+			return (0, unthrown.ok)(createTypedChildHandle(await (0, _temporalio_workflow.startChild)(childWorkflowName, {
 				...temporalOptions,
 				taskQueue,
 				args: [validatedInput]
 			}), childDefinition, childWorkflowName));
 		} catch (error) {
-			return (0, neverthrow.err)(require_internal.classifyChildWorkflowError("startChild", error, String(childWorkflowName)));
+			return (0, unthrown.err)(require_internal.classifyChildWorkflowError("startChild", error, String(childWorkflowName)));
 		}
 	};
-	return (0, _temporal_contract_contract_result_async._internal_makeResultAsync)(work, (error) => new require_internal.ChildWorkflowError(`Failed to start child workflow: ${error instanceof Error ? error.message : String(error)}`, error));
+	return (0, _temporal_contract_contract_result_async._internal_makeAsyncResult)(work);
 }
 function createExecuteChildWorkflow(childContract, childWorkflowName, options) {
 	const work = async () => {
 		const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options.args);
-		if (validationResult.isErr()) return (0, neverthrow.err)(validationResult.error);
+		(0, _temporal_contract_contract_result_async._internal_assertNoDefect)(validationResult);
+		if (validationResult.isErr()) return (0, unthrown.err)(validationResult.error);
 		const { definition: childDefinition, validatedInput, taskQueue } = validationResult.value;
 		try {
 			const { args: _args, ...temporalOptions } = options;
@@ -247,13 +247,14 @@ function createExecuteChildWorkflow(childContract, childWorkflowName, options) {
 				taskQueue,
 				args: [validatedInput]
 			}), childWorkflowName);
-			if (outputValidationResult.isErr()) return (0, neverthrow.err)(outputValidationResult.error);
-			return (0, neverthrow.ok)(outputValidationResult.value);
+			(0, _temporal_contract_contract_result_async._internal_assertNoDefect)(outputValidationResult);
+			if (outputValidationResult.isErr()) return (0, unthrown.err)(outputValidationResult.error);
+			return (0, unthrown.ok)(outputValidationResult.value);
 		} catch (error) {
-			return (0, neverthrow.err)(require_internal.classifyChildWorkflowError("executeChild", error, String(childWorkflowName)));
+			return (0, unthrown.err)(require_internal.classifyChildWorkflowError("executeChild", error, String(childWorkflowName)));
 		}
 	};
-	return (0, _temporal_contract_contract_result_async._internal_makeResultAsync)(work, (error) => new require_internal.ChildWorkflowError(`Failed to execute child workflow: ${error instanceof Error ? error.message : String(error)}`, error));
+	return (0, _temporal_contract_contract_result_async._internal_makeAsyncResult)(work);
 }
 //#endregion
 //#region src/activities-proxy.ts
@@ -310,12 +311,16 @@ function createValidatedActivities(rawActivities, workflowActivitiesDefinition,
 *   },
 *   // Optional: override `activityOptions` for specific activities. Each
 *   // entry shallow-merges over the workflow default — the override wins on
-*   // every property it specifies, including the whole `retry` block.
+*   // every property it specifies, including the whole `retry` block. The
+*   // override is Temporal's full `ActivityOptions`, so `taskQueue` works too,
+*   // letting you route individual activities to a dedicated worker pool.
 *   activityOptionsByName: {
 *     chargePayment: {
 *       startToCloseTimeout: '5 minutes',
 *       retry: { maximumAttempts: 5 },
 *     },
+*     // Route this activity to a dedicated, concurrency-capped queue.
+*     scoreRisk: { taskQueue: 'ml-inference' },
 *   },
 *   implementation: async (context, args) => {
 *     // context.activities: typed activities (workflow + global)
@@ -403,8 +408,8 @@ exports.QueryOutputValidationError = require_internal.QueryOutputValidationError
 exports.SignalInputValidationError = require_internal.SignalInputValidationError;
 exports.UpdateInputValidationError = require_internal.UpdateInputValidationError;
 exports.UpdateOutputValidationError = require_internal.UpdateOutputValidationError;
+exports.ValidationError = require_internal.ValidationError;
 exports.WorkflowCancelledError = require_internal.WorkflowCancelledError;
 exports.WorkflowInputValidationError = require_internal.WorkflowInputValidationError;
 exports.WorkflowOutputValidationError = require_internal.WorkflowOutputValidationError;
-exports.WorkflowScopeError = require_internal.WorkflowScopeError;
 exports.declareWorkflow = declareWorkflow;

package/dist/workflow.d.cts

@@ -1,6 +1,6 @@
-import { _ as ClientInferOutput, a as ChildWorkflowError, c as QueryOutputValidationError, d as UpdateOutputValidationError, f as WorkflowCancelledError, g as ClientInferInput, h as WorkflowScopeError, i as ChildWorkflowCancelledError, l as SignalInputValidationError, m as WorkflowOutputValidationError, n as ActivityInputValidationError, o as ChildWorkflowNotFoundError, p as WorkflowInputValidationError, r as ActivityOutputValidationError, s as QueryInputValidationError, u as UpdateInputValidationError, v as WorkerInferInput, y as WorkerInferOutput } from "./errors-BP48RaOI.cjs";
+import { _ as ClientInferOutput, a as ChildWorkflowError, c as QueryOutputValidationError, d as UpdateOutputValidationError, f as ValidationError, g as ClientInferInput, h as WorkflowOutputValidationError, i as ChildWorkflowCancelledError, l as SignalInputValidationError, m as WorkflowInputValidationError, n as ActivityInputValidationError, o as ChildWorkflowNotFoundError, p as WorkflowCancelledError, r as ActivityOutputValidationError, s as QueryInputValidationError, u as UpdateInputValidationError, v as WorkerInferInput, y as WorkerInferOutput } from "./errors-BNnNzSwE.cjs";
 import { ActivityDefinition, AnyWorkflowDefinition, ContractDefinition, QueryDefinition, QueryNamesOf, SignalDefinition, SignalNamesOf, UpdateDefinition, UpdateNamesOf } from "@temporal-contract/contract";
-import { ResultAsync } from "neverthrow";
+import { AsyncResult } from "unthrown";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 import { ActivityOptions, ChildWorkflowOptions, ContinueAsNewOptions, WorkflowInfo } from "@temporalio/workflow";
 //#region src/handlers.d.ts
@@ -44,13 +44,13 @@ type TypedChildWorkflowOptions<TChildContract extends ContractDefinition, TChild
   args: ClientInferInput<TChildContract["workflows"][TChildWorkflowName]>;
 };
 /**
- * Typed handle for a child workflow with neverthrow `ResultAsync` pattern.
+ * Typed handle for a child workflow with unthrown `AsyncResult` pattern.
  */
 type TypedChildWorkflowHandle<TWorkflow extends AnyWorkflowDefinition> = {
   /**
-   * Get child workflow result with `ResultAsync` pattern.
+   * Get child workflow result with `AsyncResult` pattern.
    */
-  result: () => ResultAsync<ClientInferOutput<TWorkflow>, ChildWorkflowError | ChildWorkflowCancelledError>;
+  result: () => AsyncResult<ClientInferOutput<TWorkflow>, ChildWorkflowError | ChildWorkflowCancelledError>;
   /**
    * Child workflow ID.
    */
@@ -105,12 +105,16 @@ type WorkflowInferWorkflowContextActivities<TContract extends ContractDefinition
  *   },
  *   // Optional: override `activityOptions` for specific activities. Each
  *   // entry shallow-merges over the workflow default — the override wins on
- *   // every property it specifies, including the whole `retry` block.
+ *   // every property it specifies, including the whole `retry` block. The
+ *   // override is Temporal's full `ActivityOptions`, so `taskQueue` works too,
+ *   // letting you route individual activities to a dedicated worker pool.
  *   activityOptionsByName: {
  *     chargePayment: {
  *       startToCloseTimeout: '5 minutes',
  *       retry: { maximumAttempts: 5 },
  *     },
+ *     // Route this activity to a dedicated, concurrency-capped queue.
+ *     scoreRisk: { taskQueue: 'ml-inference' },
  *   },
  *   implementation: async (context, args) => {
  *     // context.activities: typed activities (workflow + global)
@@ -199,10 +203,17 @@ type DeclareWorkflowOptions<TContract extends ContractDefinition, TWorkflowName
    * entire nested `retry` block when present, matching Temporal's
    * single-options-per-`proxyActivities`-call semantics).
    *
+   * The override value is Temporal's full `ActivityOptions`, so any field is
+   * fair game — including `taskQueue`, which lets you route individual
+   * activities to dedicated worker pools (e.g. concurrency-capped queues for
+   * LLM calls) while the rest of the workflow's activities stay on the default
+   * queue. This keeps the Zod-validated typed-activities boundary intact, where
+   * a raw `proxyActivities({ taskQueue })` would forfeit it.
+   *
    * Activity names are typed against the contract; typos surface as TypeScript
    * errors rather than running silently with the default options.
    *
-   * @example
+   * @example Tune timeouts and retries per activity
    * ```ts
    * activityOptions: { startToCloseTimeout: '1 minute' }, // default
    * activityOptionsByName: {
@@ -213,6 +224,16 @@ type DeclareWorkflowOptions<TContract extends ContractDefinition, TWorkflowName
    *   fastValidation: { startToCloseTimeout: '5 seconds' },
    * },
    * ```
+   *
+   * @example Route specific activities to a dedicated task queue
+   * ```ts
+   * activityOptions: { startToCloseTimeout: '10 minutes' }, // default queue
+   * activityOptionsByName: {
+   *   // LLM call → dedicated, concurrency-capped queue.
+   *   extractLayoutChunk: { taskQueue: 'gemini-pro' },
+   *   // finalizeLayout, extractImages, … fall through to the default queue.
+   * },
+   * ```
    */
   activityOptionsByName?: Partial<Record<ActivityNamesFor<TContract, TWorkflowName>, ActivityOptions>>;
 };
@@ -291,7 +312,7 @@ type WorkflowContext<TContract extends ContractDefinition, TWorkflowName extends
    */
   defineUpdate: <K extends UpdateNamesOf<TContract["workflows"][TWorkflowName]>>(updateName: K, handler: UpdateHandlerImplementation<NonNullable<TContract["workflows"][TWorkflowName]["updates"]> extends Record<string, UpdateDefinition> ? NonNullable<TContract["workflows"][TWorkflowName]["updates"]>[K] extends UpdateDefinition ? NonNullable<TContract["workflows"][TWorkflowName]["updates"]>[K] : never : never>) => void;
   /**
-   * Start a child workflow and return a typed handle with ResultAsync pattern
+   * Start a child workflow and return a typed handle with AsyncResult pattern
    *
    * Supports both same-contract and cross-contract child workflows:
    * - Same contract: Pass workflowName from current contract
@@ -311,18 +332,19 @@ type WorkflowContext<TContract extends ContractDefinition, TWorkflowName extends
    *   args: { message: 'Hello' }
    * });
    *
-   * childResult.match(
-   *   async (handle) => {
+   * await childResult.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),
+   * });
    * ```
    */
-  startChildWorkflow: <TChildContract extends ContractDefinition, TChildWorkflowName extends keyof TChildContract["workflows"] & string>(contract: TChildContract, workflowName: TChildWorkflowName, options: TypedChildWorkflowOptions<TChildContract, TChildWorkflowName>) => ResultAsync<TypedChildWorkflowHandle<TChildContract["workflows"][TChildWorkflowName]>, ChildWorkflowError | ChildWorkflowCancelledError | ChildWorkflowNotFoundError>;
+  startChildWorkflow: <TChildContract extends ContractDefinition, TChildWorkflowName extends keyof TChildContract["workflows"] & string>(contract: TChildContract, workflowName: TChildWorkflowName, options: TypedChildWorkflowOptions<TChildContract, TChildWorkflowName>) => AsyncResult<TypedChildWorkflowHandle<TChildContract["workflows"][TChildWorkflowName]>, ChildWorkflowError | ChildWorkflowCancelledError | ChildWorkflowNotFoundError>;
   /**
-   * Execute a child workflow (start and wait for result) with ResultAsync pattern
+   * Execute a child workflow (start and wait for result) with AsyncResult pattern
    *
    * Supports both same-contract and cross-contract child workflows:
    * - Same contract: Pass workflowName from current contract
@@ -342,62 +364,59 @@ type WorkflowContext<TContract extends ContractDefinition, TWorkflowName extends
    *   args: { message: 'Hello' }
    * });
    *
-   * result.match(
-   *   (output) => console.log('Payment processed:', output),
-   *   (error) => console.error('Processing failed:', error),
-   * );
+   * await result.match({
+   *   ok: (output) => console.log('Payment processed:', output),
+   *   err: (error) => console.error('Processing failed:', error),
+   *   defect: (cause) => console.error('Unexpected failure:', cause),
+   * });
    * ```
    */
-  executeChildWorkflow: <TChildContract extends ContractDefinition, TChildWorkflowName extends keyof TChildContract["workflows"] & string>(contract: TChildContract, workflowName: TChildWorkflowName, options: TypedChildWorkflowOptions<TChildContract, TChildWorkflowName>) => ResultAsync<ClientInferOutput<TChildContract["workflows"][TChildWorkflowName]>, ChildWorkflowError | ChildWorkflowCancelledError | ChildWorkflowNotFoundError>;
+  executeChildWorkflow: <TChildContract extends ContractDefinition, TChildWorkflowName extends keyof TChildContract["workflows"] & string>(contract: TChildContract, workflowName: TChildWorkflowName, options: TypedChildWorkflowOptions<TChildContract, TChildWorkflowName>) => AsyncResult<ClientInferOutput<TChildContract["workflows"][TChildWorkflowName]>, ChildWorkflowError | ChildWorkflowCancelledError | ChildWorkflowNotFoundError>;
   /**
    * Run `fn` inside a cancellable Temporal scope. If the workflow (or an
    * ancestor scope) is cancelled while `fn` is in flight, the resulting
-   * ResultAsync resolves to `err(WorkflowCancelledError)` instead of
+   * AsyncResult resolves to `err(WorkflowCancelledError)` instead of
    * rejecting — letting callers handle cancellation explicitly, typically
    * to perform a graceful exit from the current step.
    *
-   * Non-cancellation errors thrown by `fn` resolve to
-   * `err(WorkflowScopeError)` (with the original error preserved on
-   * `cause`). Both failure modes ride neverthrow's railway, so
-   * `result.match(...)` is exhaustive — nothing escapes as an unhandled
-   * rejection.
+   * Non-cancellation errors thrown by `fn` are *unmodeled* failures: they ride
+   * unthrown's `defect` channel (inspectable via `result.isDefect()` /
+   * `result.cause`, re-thrown at the edge), keeping the modeled error channel
+   * to the single anticipated outcome — cancellation.
    *
    * @example
    * ```ts
+   *
    * implementation: async (context, args) => {
    *   const result = await context.cancellableScope(async () => {
    *     return context.activities.processStep(args);
    *   });
    *
-   *   if (result.isErr()) {
-   *     if (result.error instanceof WorkflowCancelledError) {
-   *       // workflow was cancelled — perform cleanup that must not be cancelled:
-   *       await context.nonCancellableScope(async () => {
-   *         await context.activities.releaseResources(args);
-   *       });
-   *       return { status: "cancelled" };
-   *     }
-   *     // result.error instanceof WorkflowScopeError — domain failure
-   *     return { status: "failed" };
+   *   if (result.isErr() && result.error instanceof WorkflowCancelledError) {
+   *     // workflow was cancelled — perform cleanup that must not be cancelled:
+   *     await context.nonCancellableScope(async () => {
+   *       await context.activities.releaseResources(args);
+   *     });
+   *     return { status: "cancelled" };
    *   }
    *
    *   return { status: "ok" };
    * }
    * ```
    */
-  cancellableScope: <T>(fn: () => T | Promise<T>) => ResultAsync<T, WorkflowCancelledError | WorkflowScopeError>;
+  cancellableScope: <T>(fn: () => T | Promise<T>) => AsyncResult<T, WorkflowCancelledError>;
   /**
    * Run `fn` inside a non-cancellable Temporal scope. Cancellation requests
    * from outside the scope are ignored for its duration — the idiomatic way
    * to perform cleanup work that must not be interrupted.
    *
-   * Returns the same `ResultAsync<...>` shape as
+   * Returns the same `AsyncResult<...>` shape as
    * {@link WorkflowContext.cancellableScope} for symmetry; the
    * `err(WorkflowCancelledError)` branch only triggers when cancellation is
    * raised from *inside* the scope, which is rare. Non-cancellation errors
-   * surface as `err(WorkflowScopeError)`.
+   * surface on the `defect` channel.
    */
-  nonCancellableScope: <T>(fn: () => T | Promise<T>) => ResultAsync<T, WorkflowCancelledError | WorkflowScopeError>;
+  nonCancellableScope: <T>(fn: () => T | Promise<T>) => AsyncResult<T, WorkflowCancelledError>;
   /**
    * Continue this workflow execution as a new run, optionally with a different
    * workflow type from another contract.
@@ -431,5 +450,5 @@ type WorkflowContext<TContract extends ContractDefinition, TWorkflowName extends
   };
 }; //# sourceMappingURL=workflow.d.ts.map
 //#endregion
-export { ActivityInputValidationError, ActivityOutputValidationError, ChildWorkflowCancelledError, ChildWorkflowError, ChildWorkflowNotFoundError, QueryInputValidationError, QueryOutputValidationError, SignalInputValidationError, UpdateInputValidationError, UpdateOutputValidationError, WorkflowCancelledError, WorkflowInputValidationError, WorkflowOutputValidationError, WorkflowScopeError, declareWorkflow };
+export { ActivityInputValidationError, ActivityOutputValidationError, ChildWorkflowCancelledError, ChildWorkflowError, ChildWorkflowNotFoundError, QueryInputValidationError, QueryOutputValidationError, SignalInputValidationError, UpdateInputValidationError, UpdateOutputValidationError, ValidationError, WorkflowCancelledError, WorkflowInputValidationError, WorkflowOutputValidationError, declareWorkflow };
 //# sourceMappingURL=workflow.d.cts.map

package/dist/workflow.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow.d.cts","names":[],"sources":["../src/handlers.ts","../src/internal.ts","../src/child-workflow.ts","../src/activities-proxy.ts","../src/workflow.ts"],"mappings":"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"}
+{"version":3,"file":"workflow.d.cts","names":[],"sources":["../src/handlers.ts","../src/internal.ts","../src/child-workflow.ts","../src/activities-proxy.ts","../src/workflow.ts"],"mappings":"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"}