@temporal-contract/worker 2.3.1 → 3.0.0

package/dist/{internal-DcM-YWYX.cjs → internal-Clwokr1z.cjs}

@@ -1,170 +1,174 @@
 let _temporal_contract_contract = require("@temporal-contract/contract");
-let _temporalio_workflow = require("@temporalio/workflow");
 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
+* Base class for the contract's runtime validation failures — workflow and
+* activity input/output, plus signal/query/update payloads.
+*
+* These extend Temporal's {@link ApplicationFailure} with `nonRetryable: true`
+* rather than a plain `Error`, and that distinction is load-bearing. The
+* TypeScript SDK classifies a non-`TemporalFailure` thrown from *workflow* code
+* as a Workflow Task failure — presumed to be a transient code bug or
+* non-determinism — and retries the task indefinitely, leaving the execution
+* silently `Running` forever (it looks like the worker "hung"). Only a
+* `TemporalFailure` such as `ApplicationFailure` fails the Workflow Execution
+* terminally. The same logic applies at the activity boundary, where Temporal's
+* default retry policy has unlimited attempts: a plain `Error` would retry
+* forever too.
+*
+* Contract validation failures are deterministic — the schema is static, so bad
+* input/output never becomes valid on replay or retry — so they are surfaced as
+* non-retryable, failing fast with a clear error instead of an infinite retry
+* loop.
+*
+* The concrete subclass name is passed through as the failure `type`, so it
+* stays discriminable after crossing Temporal's serialization boundary (where
+* the JS class identity is lost) via `failure.type`. The failing field path is
+* carried in the human-readable `message` (see {@link summarizeIssues}). The
+* raw `issues` remain available as a property for in-process inspection.
+*
+* See issue #251.
 */
-var WorkerError = class extends Error {
-	constructor(message, cause) {
-		super(message, { cause });
-		this.name = "WorkerError";
+var ValidationError = class extends _temporalio_common.ApplicationFailure {
+	issues;
+	constructor(message, type, issues) {
+		super(message, type, true);
+		this.issues = issues;
+		Object.defineProperty(this, "name", {
+			value: type,
+			writable: true,
+			configurable: true,
+			enumerable: true
+		});
 		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
 	}
 };
 /**
 * 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}`
+		});
 	}
 };
 /**
 * Error thrown when activity input validation fails
 */
-var ActivityInputValidationError = class extends WorkerError {
+var ActivityInputValidationError = class extends ValidationError {
 	activityName;
-	issues;
 	constructor(activityName, issues) {
 		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
-		super(`Activity "${activityName}" input validation failed: ${message}`);
+		super(`Activity "${activityName}" input validation failed: ${message}`, "ActivityInputValidationError", issues);
 		this.activityName = activityName;
-		this.issues = issues;
-		this.name = "ActivityInputValidationError";
 	}
 };
 /**
 * Error thrown when activity output validation fails
 */
-var ActivityOutputValidationError = class extends WorkerError {
+var ActivityOutputValidationError = class extends ValidationError {
 	activityName;
-	issues;
 	constructor(activityName, issues) {
 		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
-		super(`Activity "${activityName}" output validation failed: ${message}`);
+		super(`Activity "${activityName}" output validation failed: ${message}`, "ActivityOutputValidationError", issues);
 		this.activityName = activityName;
-		this.issues = issues;
-		this.name = "ActivityOutputValidationError";
 	}
 };
 /**
 * Error thrown when workflow input validation fails
 */
-var WorkflowInputValidationError = class extends WorkerError {
+var WorkflowInputValidationError = class extends ValidationError {
 	workflowName;
-	issues;
 	constructor(workflowName, issues) {
 		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
-		super(`Workflow "${workflowName}" input validation failed: ${message}`);
+		super(`Workflow "${workflowName}" input validation failed: ${message}`, "WorkflowInputValidationError", issues);
 		this.workflowName = workflowName;
-		this.issues = issues;
-		this.name = "WorkflowInputValidationError";
 	}
 };
 /**
 * Error thrown when workflow output validation fails
 */
-var WorkflowOutputValidationError = class extends WorkerError {
+var WorkflowOutputValidationError = class extends ValidationError {
 	workflowName;
-	issues;
 	constructor(workflowName, issues) {
 		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
-		super(`Workflow "${workflowName}" output validation failed: ${message}`);
+		super(`Workflow "${workflowName}" output validation failed: ${message}`, "WorkflowOutputValidationError", issues);
 		this.workflowName = workflowName;
-		this.issues = issues;
-		this.name = "WorkflowOutputValidationError";
 	}
 };
 /**
 * Error thrown when signal input validation fails
 */
-var SignalInputValidationError = class extends WorkerError {
+var SignalInputValidationError = class extends ValidationError {
 	signalName;
-	issues;
 	constructor(signalName, issues) {
 		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
-		super(`Signal "${signalName}" input validation failed: ${message}`);
+		super(`Signal "${signalName}" input validation failed: ${message}`, "SignalInputValidationError", issues);
 		this.signalName = signalName;
-		this.issues = issues;
-		this.name = "SignalInputValidationError";
 	}
 };
 /**
 * Error thrown when query input validation fails
 */
-var QueryInputValidationError = class extends WorkerError {
+var QueryInputValidationError = class extends ValidationError {
 	queryName;
-	issues;
 	constructor(queryName, issues) {
 		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
-		super(`Query "${queryName}" input validation failed: ${message}`);
+		super(`Query "${queryName}" input validation failed: ${message}`, "QueryInputValidationError", issues);
 		this.queryName = queryName;
-		this.issues = issues;
-		this.name = "QueryInputValidationError";
 	}
 };
 /**
 * Error thrown when query output validation fails
 */
-var QueryOutputValidationError = class extends WorkerError {
+var QueryOutputValidationError = class extends ValidationError {
 	queryName;
-	issues;
 	constructor(queryName, issues) {
 		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
-		super(`Query "${queryName}" output validation failed: ${message}`);
+		super(`Query "${queryName}" output validation failed: ${message}`, "QueryOutputValidationError", issues);
 		this.queryName = queryName;
-		this.issues = issues;
-		this.name = "QueryOutputValidationError";
 	}
 };
 /**
 * Error thrown when update input validation fails
 */
-var UpdateInputValidationError = class extends WorkerError {
+var UpdateInputValidationError = class extends ValidationError {
 	updateName;
-	issues;
 	constructor(updateName, issues) {
 		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
-		super(`Update "${updateName}" input validation failed: ${message}`);
+		super(`Update "${updateName}" input validation failed: ${message}`, "UpdateInputValidationError", issues);
 		this.updateName = updateName;
-		this.issues = issues;
-		this.name = "UpdateInputValidationError";
 	}
 };
 /**
 * Error thrown when update output validation fails
 */
-var UpdateOutputValidationError = class extends WorkerError {
+var UpdateOutputValidationError = class extends ValidationError {
 	updateName;
-	issues;
 	constructor(updateName, issues) {
 		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
-		super(`Update "${updateName}" output validation failed: ${message}`);
+		super(`Update "${updateName}" output validation failed: ${message}`, "UpdateOutputValidationError", issues);
 		this.updateName = updateName;
-		this.issues = issues;
-		this.name = "UpdateOutputValidationError";
 	}
 };
 /**
 * 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}`
+		});
 	}
 };
 /**
@@ -176,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
@@ -314,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) {
@@ -516,6 +490,12 @@ Object.defineProperty(exports, "UpdateOutputValidationError", {
 		return UpdateOutputValidationError;
 	}
 });
+Object.defineProperty(exports, "ValidationError", {
+	enumerable: true,
+	get: function() {
+		return ValidationError;
+	}
+});
 Object.defineProperty(exports, "WorkflowCancelledError", {
 	enumerable: true,
 	get: function() {
@@ -534,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() {