@temporal-contract/worker 2.4.0 → 3.0.0

package/dist/{errors-CE56feY1.d.mts → errors-BNnNzSwE.d.mts}

@@ -33,12 +33,6 @@ type ClientInferOutput<T extends {
 }> = StandardSchemaV1.InferOutput<T["output"]>;
 //#endregion
 //#region src/errors.d.ts
-/**
- * Base error class for worker errors
- */
-declare abstract class WorkerError extends Error {
-  protected constructor(message: string, cause?: unknown);
-}
 /**
  * Base class for the contract's runtime validation failures — workflow and
  * activity input/output, plus signal/query/update payloads.
@@ -71,12 +65,15 @@ declare abstract class ValidationError extends ApplicationFailure {
   readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
   protected constructor(message: string, type: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
 }
+declare const ActivityDefinitionNotFoundError_base: import("unthrown").TaggedErrorConstructor<"@temporal-contract/ActivityDefinitionNotFoundError">;
 /**
  * Error thrown when an activity definition is not found in the contract
  */
-declare class ActivityDefinitionNotFoundError extends WorkerError {
-  readonly activityName: string;
-  readonly availableDefinitions: readonly string[];
+declare class ActivityDefinitionNotFoundError extends ActivityDefinitionNotFoundError_base<{
+  activityName: string;
+  availableDefinitions: readonly string[];
+  message: string;
+}> {
   constructor(activityName: string, availableDefinitions?: readonly string[]);
 }
 /**
@@ -142,14 +139,18 @@ declare class UpdateOutputValidationError extends ValidationError {
   readonly updateName: string;
   constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
 }
+declare const ChildWorkflowNotFoundError_base: import("unthrown").TaggedErrorConstructor<"@temporal-contract/ChildWorkflowNotFoundError">;
 /**
  * Error thrown when a child workflow is not found in the contract
  */
-declare class ChildWorkflowNotFoundError extends WorkerError {
-  readonly workflowName: string;
-  readonly availableWorkflows: readonly string[];
+declare class ChildWorkflowNotFoundError extends ChildWorkflowNotFoundError_base<{
+  workflowName: string;
+  availableWorkflows: readonly string[];
+  message: string;
+}> {
   constructor(workflowName: string, availableWorkflows?: readonly string[]);
 }
+declare const ChildWorkflowError_base: import("unthrown").TaggedErrorConstructor<"@temporal-contract/ChildWorkflowError">;
 /**
  * Generic error for child workflow operations.
  *
@@ -159,74 +160,54 @@ declare class ChildWorkflowNotFoundError extends WorkerError {
  * mirroring the client-side `WorkflowFailedError.cause` behavior, so callers
  * can branch on the failure category in one step instead of unwrapping twice.
  */
-declare class ChildWorkflowError extends WorkerError {
+declare class ChildWorkflowError extends ChildWorkflowError_base<{
+  message: string;
+  cause?: unknown;
+}> {
   constructor(message: string, cause?: unknown);
 }
+declare const ChildWorkflowCancelledError_base: import("unthrown").TaggedErrorConstructor<"@temporal-contract/ChildWorkflowCancelledError">;
 /**
- * Discriminated variant of {@link ChildWorkflowError} surfaced when a child
- * workflow operation (start, execute, or wait-for-result) was cancelled —
- * either because the parent workflow itself was cancelled, the child was
- * explicitly cancelled, or its enclosing cancellation scope was. Detected via
- * `@temporalio/workflow`'s `isCancellation(...)`, which sees through nested
- * `ChildWorkflowFailure` / `CancelledFailure` chains.
+ * Discriminated variant surfaced when a child workflow operation (start,
+ * execute, or wait-for-result) was cancelled — either because the parent
+ * workflow itself was cancelled, the child was explicitly cancelled, or its
+ * enclosing cancellation scope was. Detected via `@temporalio/workflow`'s
+ * `isCancellation(...)`, which sees through nested `ChildWorkflowFailure` /
+ * `CancelledFailure` chains.
  *
- * Extends {@link ChildWorkflowError} so existing `instanceof ChildWorkflowError`
- * checks still match cancellation, while `instanceof ChildWorkflowCancelledError`
- * lets call sites narrow further when they need to branch on cancellation
- * explicitly without inspecting `error.cause` against a Temporal SDK class —
- * the worker-side analogue of the client-side cause-forwarding pattern.
- */
-declare class ChildWorkflowCancelledError extends ChildWorkflowError {
-  readonly workflowName: string;
+ * A sibling of {@link ChildWorkflowError} rather than a subclass: both are
+ * distinct {@link TaggedError}s, so call sites discriminate on the `_tag`
+ * (or `instanceof ChildWorkflowCancelledError`) instead of relying on an
+ * `instanceof ChildWorkflowError` that also matches cancellation. `matchTags`
+ * folds the `ChildWorkflowError | ChildWorkflowCancelledError` union
+ * exhaustively.
+ */
+declare class ChildWorkflowCancelledError extends ChildWorkflowCancelledError_base<{
+  workflowName: string;
+  cause?: unknown;
+  message: string;
+}> {
   constructor(workflowName: string, cause?: unknown);
 }
+declare const WorkflowCancelledError_base: import("unthrown").TaggedErrorConstructor<"@temporal-contract/WorkflowCancelledError">;
 /**
- * Error surfaced in the `err(...)` branch of a `ResultAsync` when a typed
+ * Error surfaced in the `err(...)` branch of an `AsyncResult` when a typed
  * cancellation scope is cancelled via Temporal's cancellation propagation.
  * Returned by both `context.cancellableScope` (when the workflow or an
  * ancestor scope cancels) and `context.nonCancellableScope` (when
  * cancellation is raised from inside the scope). Distinct from arbitrary
  * thrown errors so call sites can branch on cancellation explicitly.
  *
- * Non-cancellation errors thrown inside a scope surface as a sibling
- * {@link WorkflowScopeError} on the same `err(...)` channel, so callers can
- * use `instanceof` to discriminate without falling back to `try/catch`.
- */
-declare class WorkflowCancelledError extends WorkerError {
+ * Non-cancellation errors thrown inside a scope are *unmodeled* failures: they
+ * surface on the scope's `defect` channel (re-thrown at the edge / inspectable
+ * via `result.isDefect()` and `result.cause`), not as a typed `err(...)`.
+ */
+declare class WorkflowCancelledError extends WorkflowCancelledError_base<{
+  cause?: unknown;
+  message: string;
+}> {
   constructor(cause?: unknown);
 }
-/**
- * Error surfaced in the `err(...)` branch of a `ResultAsync` when the
- * function passed to `cancellableScope` / `nonCancellableScope` throws a
- * non-cancellation error.
- *
- * The original error is preserved on `cause` so call sites can introspect
- * it without losing identity:
- *
- * @example
- * ```ts
- * const result = await context.cancellableScope(async () => {
- *   return await context.activities.processStep(args);
- * });
- *
- * if (result.isErr()) {
- *   if (result.error instanceof WorkflowCancelledError) {
- *     // graceful cancellation
- *   } else if (result.error instanceof WorkflowScopeError) {
- *     // domain error — `result.error.cause` is the original throwable
- *   }
- * }
- * ```
- *
- * Introduced so the scope helpers route every failure through neverthrow's
- * railway. Previously, non-cancellation errors were re-thrown out of the
- * helper, which became a `ResultAsync` rejection (`new ResultAsync(promise)`
- * does not catch) — they leaked as unhandled rejections rather than
- * surfacing on the typed error channel callers actually inspect.
- */
-declare class WorkflowScopeError extends WorkerError {
-  constructor(cause: unknown);
-}
 //#endregion
-export { ClientInferInput as _, ChildWorkflowError as a, WorkerInferOutput as b, QueryOutputValidationError as c, UpdateOutputValidationError as d, ValidationError as f, WorkflowScopeError as g, WorkflowOutputValidationError as h, ChildWorkflowCancelledError as i, SignalInputValidationError as l, WorkflowInputValidationError as m, ActivityInputValidationError as n, ChildWorkflowNotFoundError as o, WorkflowCancelledError as p, ActivityOutputValidationError as r, QueryInputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateInputValidationError as u, ClientInferOutput as v, WorkerInferInput as y };
-//# sourceMappingURL=errors-CE56feY1.d.mts.map
+export { ClientInferOutput as _, ChildWorkflowError as a, QueryOutputValidationError as c, UpdateOutputValidationError as d, ValidationError as f, ClientInferInput as g, WorkflowOutputValidationError as h, ChildWorkflowCancelledError as i, SignalInputValidationError as l, WorkflowInputValidationError as m, ActivityInputValidationError as n, ChildWorkflowNotFoundError as o, WorkflowCancelledError as p, ActivityOutputValidationError as r, QueryInputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateInputValidationError as u, WorkerInferInput as v, WorkerInferOutput as y };
+//# sourceMappingURL=errors-BNnNzSwE.d.mts.map

package/dist/errors-BNnNzSwE.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-BNnNzSwE.d.mts","names":[],"sources":["../src/types.ts","../src/errors.ts"],"mappings":"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"}

package/dist/{internal-o5vk6e1H.cjs → internal-Clwokr1z.cjs}

@@ -1,19 +1,10 @@
 let _temporal_contract_contract = require("@temporal-contract/contract");
 let _temporalio_common = require("@temporalio/common");
+let unthrown = require("unthrown");
 let _temporalio_workflow = require("@temporalio/workflow");
 require("@temporal-contract/contract/result-async");
 //#region src/errors.ts
 /**
-* Base error class for worker errors
-*/
-var WorkerError = class extends Error {
-	constructor(message, cause) {
-		super(message, { cause });
-		this.name = "WorkerError";
-		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-	}
-};
-/**
 * Base class for the contract's runtime validation failures — workflow and
 * activity input/output, plus signal/query/update payloads.
 *
@@ -58,15 +49,14 @@ var ValidationError = class extends _temporalio_common.ApplicationFailure {
 /**
 * Error thrown when an activity definition is not found in the contract
 */
-var ActivityDefinitionNotFoundError = class extends WorkerError {
-	activityName;
-	availableDefinitions;
+var ActivityDefinitionNotFoundError = class extends (0, unthrown.TaggedError)("@temporal-contract/ActivityDefinitionNotFoundError", { name: "ActivityDefinitionNotFoundError" }) {
 	constructor(activityName, availableDefinitions = []) {
 		const available = availableDefinitions.length > 0 ? availableDefinitions.join(", ") : "none";
-		super(`Activity definition not found for: "${activityName}". Available activities: ${available}`);
-		this.activityName = activityName;
-		this.availableDefinitions = availableDefinitions;
-		this.name = "ActivityDefinitionNotFoundError";
+		super({
+			activityName,
+			availableDefinitions,
+			message: `Activity definition not found for: "${activityName}". Available activities: ${available}`
+		});
 	}
 };
 /**
@@ -171,15 +161,14 @@ var UpdateOutputValidationError = class extends ValidationError {
 /**
 * Error thrown when a child workflow is not found in the contract
 */
-var ChildWorkflowNotFoundError = class extends WorkerError {
-	workflowName;
-	availableWorkflows;
+var ChildWorkflowNotFoundError = class extends (0, unthrown.TaggedError)("@temporal-contract/ChildWorkflowNotFoundError", { name: "ChildWorkflowNotFoundError" }) {
 	constructor(workflowName, availableWorkflows = []) {
 		const available = availableWorkflows.length > 0 ? availableWorkflows.join(", ") : "none";
-		super(`Child workflow not found: "${workflowName}". Available workflows: ${available}`);
-		this.workflowName = workflowName;
-		this.availableWorkflows = availableWorkflows;
-		this.name = "ChildWorkflowNotFoundError";
+		super({
+			workflowName,
+			availableWorkflows,
+			message: `Child workflow not found: "${workflowName}". Available workflows: ${available}`
+		});
 	}
 };
 /**
@@ -191,86 +180,56 @@ var ChildWorkflowNotFoundError = class extends WorkerError {
 * mirroring the client-side `WorkflowFailedError.cause` behavior, so callers
 * can branch on the failure category in one step instead of unwrapping twice.
 */
-var ChildWorkflowError = class extends WorkerError {
+var ChildWorkflowError = class extends (0, unthrown.TaggedError)("@temporal-contract/ChildWorkflowError", { name: "ChildWorkflowError" }) {
 	constructor(message, cause) {
-		super(message, cause);
-		this.name = "ChildWorkflowError";
+		super({
+			message,
+			cause
+		});
 	}
 };
 /**
-* Discriminated variant of {@link ChildWorkflowError} surfaced when a child
-* workflow operation (start, execute, or wait-for-result) was cancelled —
-* either because the parent workflow itself was cancelled, the child was
-* explicitly cancelled, or its enclosing cancellation scope was. Detected via
-* `@temporalio/workflow`'s `isCancellation(...)`, which sees through nested
-* `ChildWorkflowFailure` / `CancelledFailure` chains.
+* Discriminated variant surfaced when a child workflow operation (start,
+* execute, or wait-for-result) was cancelled — either because the parent
+* workflow itself was cancelled, the child was explicitly cancelled, or its
+* enclosing cancellation scope was. Detected via `@temporalio/workflow`'s
+* `isCancellation(...)`, which sees through nested `ChildWorkflowFailure` /
+* `CancelledFailure` chains.
 *
-* Extends {@link ChildWorkflowError} so existing `instanceof ChildWorkflowError`
-* checks still match cancellation, while `instanceof ChildWorkflowCancelledError`
-* lets call sites narrow further when they need to branch on cancellation
-* explicitly without inspecting `error.cause` against a Temporal SDK class —
-* the worker-side analogue of the client-side cause-forwarding pattern.
+* A sibling of {@link ChildWorkflowError} rather than a subclass: both are
+* distinct {@link TaggedError}s, so call sites discriminate on the `_tag`
+* (or `instanceof ChildWorkflowCancelledError`) instead of relying on an
+* `instanceof ChildWorkflowError` that also matches cancellation. `matchTags`
+* folds the `ChildWorkflowError | ChildWorkflowCancelledError` union
+* exhaustively.
 */
-var ChildWorkflowCancelledError = class extends ChildWorkflowError {
-	workflowName;
+var ChildWorkflowCancelledError = class extends (0, unthrown.TaggedError)("@temporal-contract/ChildWorkflowCancelledError", { name: "ChildWorkflowCancelledError" }) {
 	constructor(workflowName, cause) {
-		super(`Child workflow "${workflowName}" was cancelled`, cause);
-		this.workflowName = workflowName;
-		this.name = "ChildWorkflowCancelledError";
+		super({
+			workflowName,
+			cause,
+			message: `Child workflow "${workflowName}" was cancelled`
+		});
 	}
 };
 /**
-* Error surfaced in the `err(...)` branch of a `ResultAsync` when a typed
+* Error surfaced in the `err(...)` branch of an `AsyncResult` when a typed
 * cancellation scope is cancelled via Temporal's cancellation propagation.
 * Returned by both `context.cancellableScope` (when the workflow or an
 * ancestor scope cancels) and `context.nonCancellableScope` (when
 * cancellation is raised from inside the scope). Distinct from arbitrary
 * thrown errors so call sites can branch on cancellation explicitly.
 *
-* Non-cancellation errors thrown inside a scope surface as a sibling
-* {@link WorkflowScopeError} on the same `err(...)` channel, so callers can
-* use `instanceof` to discriminate without falling back to `try/catch`.
+* Non-cancellation errors thrown inside a scope are *unmodeled* failures: they
+* surface on the scope's `defect` channel (re-thrown at the edge / inspectable
+* via `result.isDefect()` and `result.cause`), not as a typed `err(...)`.
 */
-var WorkflowCancelledError = class extends WorkerError {
+var WorkflowCancelledError = class extends (0, unthrown.TaggedError)("@temporal-contract/WorkflowCancelledError", { name: "WorkflowCancelledError" }) {
 	constructor(cause) {
-		super("Workflow cancellation scope was cancelled", cause);
-		this.name = "WorkflowCancelledError";
-	}
-};
-/**
-* Error surfaced in the `err(...)` branch of a `ResultAsync` when the
-* function passed to `cancellableScope` / `nonCancellableScope` throws a
-* non-cancellation error.
-*
-* The original error is preserved on `cause` so call sites can introspect
-* it without losing identity:
-*
-* @example
-* ```ts
-* const result = await context.cancellableScope(async () => {
-*   return await context.activities.processStep(args);
-* });
-*
-* if (result.isErr()) {
-*   if (result.error instanceof WorkflowCancelledError) {
-*     // graceful cancellation
-*   } else if (result.error instanceof WorkflowScopeError) {
-*     // domain error — `result.error.cause` is the original throwable
-*   }
-* }
-* ```
-*
-* Introduced so the scope helpers route every failure through neverthrow's
-* railway. Previously, non-cancellation errors were re-thrown out of the
-* helper, which became a `ResultAsync` rejection (`new ResultAsync(promise)`
-* does not catch) — they leaked as unhandled rejections rather than
-* surfacing on the typed error channel callers actually inspect.
-*/
-var WorkflowScopeError = class extends WorkerError {
-	constructor(cause) {
-		const message = cause instanceof Error ? `Workflow cancellation scope caught a non-cancellation error: ${cause.message}` : "Workflow cancellation scope caught a non-cancellation error";
-		super(message, cause);
-		this.name = "WorkflowScopeError";
+		super({
+			cause,
+			message: "Workflow cancellation scope was cancelled"
+		});
 	}
 };
 //#endregion
@@ -329,7 +288,7 @@ function buildRawActivitiesProxy(workflowActivities, contractActivities, default
 	const defaultProxy = (0, _temporalio_workflow.proxyActivities)(defaultOptions);
 	const overrideEntries = overrides ? Object.entries(overrides).filter((entry) => entry[1] !== void 0) : [];
 	if (overrideEntries.length === 0) return defaultProxy;
-	const declared = new Set([...Object.keys(workflowActivities ?? {}), ...Object.keys(contractActivities ?? {})]);
+	const declared = /* @__PURE__ */ new Set([...Object.keys(workflowActivities ?? {}), ...Object.keys(contractActivities ?? {})]);
 	for (const [name] of overrideEntries) if (!declared.has(name)) throw new Error(`activityOptionsByName entry "${name}" does not match any declared activity. Available: ${[...declared].join(", ") || "none"}.`);
 	const overriddenFns = {};
 	for (const [name, override] of overrideEntries) {
@@ -555,12 +514,6 @@ Object.defineProperty(exports, "WorkflowOutputValidationError", {
 		return WorkflowOutputValidationError;
 	}
 });
-Object.defineProperty(exports, "WorkflowScopeError", {
-	enumerable: true,
-	get: function() {
-		return WorkflowScopeError;
-	}
-});
 Object.defineProperty(exports, "buildRawActivitiesProxy", {
 	enumerable: true,
 	get: function() {

package/dist/{internal-D0wfFl0y.mjs → internal-DqYK4YQK.mjs}

@@ -1,19 +1,10 @@
 import { summarizeIssues } from "@temporal-contract/contract";
 import { ApplicationFailure, ChildWorkflowFailure } from "@temporalio/common";
+import { TaggedError } from "unthrown";
 import { isCancellation, makeContinueAsNewFunc, proxyActivities } from "@temporalio/workflow";
-import { _internal_makeResultAsync as makeResultAsync } from "@temporal-contract/contract/result-async";
+import { _internal_assertNoDefect as assertNoDefect, _internal_makeAsyncResult as makeAsyncResult } from "@temporal-contract/contract/result-async";
 //#region src/errors.ts
 /**
-* Base error class for worker errors
-*/
-var WorkerError = class extends Error {
-	constructor(message, cause) {
-		super(message, { cause });
-		this.name = "WorkerError";
-		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-	}
-};
-/**
 * Base class for the contract's runtime validation failures — workflow and
 * activity input/output, plus signal/query/update payloads.
 *
@@ -58,15 +49,14 @@ var ValidationError = class extends ApplicationFailure {
 /**
 * Error thrown when an activity definition is not found in the contract
 */
-var ActivityDefinitionNotFoundError = class extends WorkerError {
-	activityName;
-	availableDefinitions;
+var ActivityDefinitionNotFoundError = class extends TaggedError("@temporal-contract/ActivityDefinitionNotFoundError", { name: "ActivityDefinitionNotFoundError" }) {
 	constructor(activityName, availableDefinitions = []) {
 		const available = availableDefinitions.length > 0 ? availableDefinitions.join(", ") : "none";
-		super(`Activity definition not found for: "${activityName}". Available activities: ${available}`);
-		this.activityName = activityName;
-		this.availableDefinitions = availableDefinitions;
-		this.name = "ActivityDefinitionNotFoundError";
+		super({
+			activityName,
+			availableDefinitions,
+			message: `Activity definition not found for: "${activityName}". Available activities: ${available}`
+		});
 	}
 };
 /**
@@ -171,15 +161,14 @@ var UpdateOutputValidationError = class extends ValidationError {
 /**
 * Error thrown when a child workflow is not found in the contract
 */
-var ChildWorkflowNotFoundError = class extends WorkerError {
-	workflowName;
-	availableWorkflows;
+var ChildWorkflowNotFoundError = class extends TaggedError("@temporal-contract/ChildWorkflowNotFoundError", { name: "ChildWorkflowNotFoundError" }) {
 	constructor(workflowName, availableWorkflows = []) {
 		const available = availableWorkflows.length > 0 ? availableWorkflows.join(", ") : "none";
-		super(`Child workflow not found: "${workflowName}". Available workflows: ${available}`);
-		this.workflowName = workflowName;
-		this.availableWorkflows = availableWorkflows;
-		this.name = "ChildWorkflowNotFoundError";
+		super({
+			workflowName,
+			availableWorkflows,
+			message: `Child workflow not found: "${workflowName}". Available workflows: ${available}`
+		});
 	}
 };
 /**
@@ -191,86 +180,56 @@ var ChildWorkflowNotFoundError = class extends WorkerError {
 * mirroring the client-side `WorkflowFailedError.cause` behavior, so callers
 * can branch on the failure category in one step instead of unwrapping twice.
 */
-var ChildWorkflowError = class extends WorkerError {
+var ChildWorkflowError = class extends TaggedError("@temporal-contract/ChildWorkflowError", { name: "ChildWorkflowError" }) {
 	constructor(message, cause) {
-		super(message, cause);
-		this.name = "ChildWorkflowError";
+		super({
+			message,
+			cause
+		});
 	}
 };
 /**
-* Discriminated variant of {@link ChildWorkflowError} surfaced when a child
-* workflow operation (start, execute, or wait-for-result) was cancelled —
-* either because the parent workflow itself was cancelled, the child was
-* explicitly cancelled, or its enclosing cancellation scope was. Detected via
-* `@temporalio/workflow`'s `isCancellation(...)`, which sees through nested
-* `ChildWorkflowFailure` / `CancelledFailure` chains.
+* Discriminated variant surfaced when a child workflow operation (start,
+* execute, or wait-for-result) was cancelled — either because the parent
+* workflow itself was cancelled, the child was explicitly cancelled, or its
+* enclosing cancellation scope was. Detected via `@temporalio/workflow`'s
+* `isCancellation(...)`, which sees through nested `ChildWorkflowFailure` /
+* `CancelledFailure` chains.
 *
-* Extends {@link ChildWorkflowError} so existing `instanceof ChildWorkflowError`
-* checks still match cancellation, while `instanceof ChildWorkflowCancelledError`
-* lets call sites narrow further when they need to branch on cancellation
-* explicitly without inspecting `error.cause` against a Temporal SDK class —
-* the worker-side analogue of the client-side cause-forwarding pattern.
+* A sibling of {@link ChildWorkflowError} rather than a subclass: both are
+* distinct {@link TaggedError}s, so call sites discriminate on the `_tag`
+* (or `instanceof ChildWorkflowCancelledError`) instead of relying on an
+* `instanceof ChildWorkflowError` that also matches cancellation. `matchTags`
+* folds the `ChildWorkflowError | ChildWorkflowCancelledError` union
+* exhaustively.
 */
-var ChildWorkflowCancelledError = class extends ChildWorkflowError {
-	workflowName;
+var ChildWorkflowCancelledError = class extends TaggedError("@temporal-contract/ChildWorkflowCancelledError", { name: "ChildWorkflowCancelledError" }) {
 	constructor(workflowName, cause) {
-		super(`Child workflow "${workflowName}" was cancelled`, cause);
-		this.workflowName = workflowName;
-		this.name = "ChildWorkflowCancelledError";
+		super({
+			workflowName,
+			cause,
+			message: `Child workflow "${workflowName}" was cancelled`
+		});
 	}
 };
 /**
-* Error surfaced in the `err(...)` branch of a `ResultAsync` when a typed
+* Error surfaced in the `err(...)` branch of an `AsyncResult` when a typed
 * cancellation scope is cancelled via Temporal's cancellation propagation.
 * Returned by both `context.cancellableScope` (when the workflow or an
 * ancestor scope cancels) and `context.nonCancellableScope` (when
 * cancellation is raised from inside the scope). Distinct from arbitrary
 * thrown errors so call sites can branch on cancellation explicitly.
 *
-* Non-cancellation errors thrown inside a scope surface as a sibling
-* {@link WorkflowScopeError} on the same `err(...)` channel, so callers can
-* use `instanceof` to discriminate without falling back to `try/catch`.
+* Non-cancellation errors thrown inside a scope are *unmodeled* failures: they
+* surface on the scope's `defect` channel (re-thrown at the edge / inspectable
+* via `result.isDefect()` and `result.cause`), not as a typed `err(...)`.
 */
-var WorkflowCancelledError = class extends WorkerError {
+var WorkflowCancelledError = class extends TaggedError("@temporal-contract/WorkflowCancelledError", { name: "WorkflowCancelledError" }) {
 	constructor(cause) {
-		super("Workflow cancellation scope was cancelled", cause);
-		this.name = "WorkflowCancelledError";
-	}
-};
-/**
-* Error surfaced in the `err(...)` branch of a `ResultAsync` when the
-* function passed to `cancellableScope` / `nonCancellableScope` throws a
-* non-cancellation error.
-*
-* The original error is preserved on `cause` so call sites can introspect
-* it without losing identity:
-*
-* @example
-* ```ts
-* const result = await context.cancellableScope(async () => {
-*   return await context.activities.processStep(args);
-* });
-*
-* if (result.isErr()) {
-*   if (result.error instanceof WorkflowCancelledError) {
-*     // graceful cancellation
-*   } else if (result.error instanceof WorkflowScopeError) {
-*     // domain error — `result.error.cause` is the original throwable
-*   }
-* }
-* ```
-*
-* Introduced so the scope helpers route every failure through neverthrow's
-* railway. Previously, non-cancellation errors were re-thrown out of the
-* helper, which became a `ResultAsync` rejection (`new ResultAsync(promise)`
-* does not catch) — they leaked as unhandled rejections rather than
-* surfacing on the typed error channel callers actually inspect.
-*/
-var WorkflowScopeError = class extends WorkerError {
-	constructor(cause) {
-		const message = cause instanceof Error ? `Workflow cancellation scope caught a non-cancellation error: ${cause.message}` : "Workflow cancellation scope caught a non-cancellation error";
-		super(message, cause);
-		this.name = "WorkflowScopeError";
+		super({
+			cause,
+			message: "Workflow cancellation scope was cancelled"
+		});
 	}
 };
 //#endregion
@@ -329,7 +288,7 @@ function buildRawActivitiesProxy(workflowActivities, contractActivities, default
 	const defaultProxy = proxyActivities(defaultOptions);
 	const overrideEntries = overrides ? Object.entries(overrides).filter((entry) => entry[1] !== void 0) : [];
 	if (overrideEntries.length === 0) return defaultProxy;
-	const declared = new Set([...Object.keys(workflowActivities ?? {}), ...Object.keys(contractActivities ?? {})]);
+	const declared = /* @__PURE__ */ new Set([...Object.keys(workflowActivities ?? {}), ...Object.keys(contractActivities ?? {})]);
 	for (const [name] of overrideEntries) if (!declared.has(name)) throw new Error(`activityOptionsByName entry "${name}" does not match any declared activity. Available: ${[...declared].join(", ") || "none"}.`);
 	const overriddenFns = {};
 	for (const [name, override] of overrideEntries) {
@@ -465,6 +424,6 @@ function describeChildWorkflowOperation(operation, childWorkflowName) {
 	}
 }
 //#endregion
-export { WorkflowScopeError as S, UpdateOutputValidationError as _, formatChildWorkflowValidationMessage as a, WorkflowInputValidationError as b, ActivityInputValidationError as c, ChildWorkflowError as d, ChildWorkflowNotFoundError as f, UpdateInputValidationError as g, SignalInputValidationError as h, extractHandlerInput as i, ActivityOutputValidationError as l, QueryOutputValidationError as m, classifyChildWorkflowError as n, makeResultAsync as o, QueryInputValidationError as p, createContinueAsNew as r, ActivityDefinitionNotFoundError as s, buildRawActivitiesProxy as t, ChildWorkflowCancelledError as u, ValidationError as v, WorkflowOutputValidationError as x, WorkflowCancelledError as y };
+export { WorkflowOutputValidationError as S, UpdateInputValidationError as _, extractHandlerInput as a, WorkflowCancelledError as b, ActivityDefinitionNotFoundError as c, ChildWorkflowCancelledError as d, ChildWorkflowError as f, SignalInputValidationError as g, QueryOutputValidationError as h, createContinueAsNew as i, ActivityInputValidationError as l, QueryInputValidationError as m, buildRawActivitiesProxy as n, formatChildWorkflowValidationMessage as o, ChildWorkflowNotFoundError as p, classifyChildWorkflowError as r, makeAsyncResult as s, assertNoDefect as t, ActivityOutputValidationError as u, UpdateOutputValidationError as v, WorkflowInputValidationError as x, ValidationError as y };
 
-//# sourceMappingURL=internal-D0wfFl0y.mjs.map
+//# sourceMappingURL=internal-DqYK4YQK.mjs.map