@temporal-contract/worker 1.0.0 → 2.1.0

package/dist/{internal-Tj4m4f_K.cjs → internal-Cwch3OHR.cjs}

@@ -1,47 +1,7 @@
+let _temporal_contract_contract = require("@temporal-contract/contract");
 let _temporalio_workflow = require("@temporalio/workflow");
-//#region src/format.ts
-/**
-* Pattern for string keys safe to render with dot notation. A "safe" key is a
-* JavaScript identifier (letters/digits/underscore/$, not starting with a
-* digit). Anything else — keys containing dots, spaces, leading digits, the
-* empty string, the literal string `"0"` etc. — gets bracket-quoted so the
-* path is unambiguous. Reserved words are accepted: we are formatting a
-* diagnostic, not generating runnable code.
-*/
-const SAFE_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-/**
-* Render a Standard Schema {@link StandardSchemaV1.Issue} into a human-readable
-* string that includes the failing field's path.
-*/
-function formatIssue(issue) {
-	if (issue.path === void 0 || issue.path.length === 0) return issue.message;
-	let path = "";
-	for (let i = 0; i < issue.path.length; i++) {
-		const segment = issue.path[i];
-		const key = segment !== null && typeof segment === "object" && "key" in segment ? segment.key : segment;
-		if (typeof key === "number") path += `[${key}]`;
-		else if (typeof key === "string" && SAFE_IDENTIFIER.test(key)) path += i === 0 ? key : `.${key}`;
-		else if (typeof key === "string") path += `[${JSON.stringify(key)}]`;
-		else path += `[${String(key)}]`;
-	}
-	return `at ${path}: ${issue.message}`;
-}
-/**
-* Join a list of validation issues into a single message, with each issue
-* rendered via {@link formatIssue} so field paths surface in the error text.
-*/
-function summarizeIssues(issues) {
-	return issues.map(formatIssue).join("; ");
-}
-/**
-* Build the message attached to a `ChildWorkflowError` for input/output
-* validation failures. Centralized so the worker and any future call sites
-* format identically.
-*/
-function formatChildWorkflowValidationMessage(workflowName, direction, issues) {
-	return `Child workflow "${workflowName}" ${direction} validation failed: ${summarizeIssues(issues)}`;
-}
-//#endregion
+let _temporalio_common = require("@temporalio/common");
+require("@temporal-contract/contract/result-async");
 //#region src/errors.ts
 /**
 * Base error class for worker errors
@@ -70,7 +30,7 @@ var ActivityDefinitionNotFoundError = class extends WorkerError {
 */
 var ActivityInputValidationError = class extends WorkerError {
 	constructor(activityName, issues) {
-		const message = summarizeIssues(issues);
+		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
 		super(`Activity "${activityName}" input validation failed: ${message}`);
 		this.activityName = activityName;
 		this.issues = issues;
@@ -82,7 +42,7 @@ var ActivityInputValidationError = class extends WorkerError {
 */
 var ActivityOutputValidationError = class extends WorkerError {
 	constructor(activityName, issues) {
-		const message = summarizeIssues(issues);
+		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
 		super(`Activity "${activityName}" output validation failed: ${message}`);
 		this.activityName = activityName;
 		this.issues = issues;
@@ -94,7 +54,7 @@ var ActivityOutputValidationError = class extends WorkerError {
 */
 var WorkflowInputValidationError = class extends WorkerError {
 	constructor(workflowName, issues) {
-		const message = summarizeIssues(issues);
+		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
 		super(`Workflow "${workflowName}" input validation failed: ${message}`);
 		this.workflowName = workflowName;
 		this.issues = issues;
@@ -106,7 +66,7 @@ var WorkflowInputValidationError = class extends WorkerError {
 */
 var WorkflowOutputValidationError = class extends WorkerError {
 	constructor(workflowName, issues) {
-		const message = summarizeIssues(issues);
+		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
 		super(`Workflow "${workflowName}" output validation failed: ${message}`);
 		this.workflowName = workflowName;
 		this.issues = issues;
@@ -118,7 +78,7 @@ var WorkflowOutputValidationError = class extends WorkerError {
 */
 var SignalInputValidationError = class extends WorkerError {
 	constructor(signalName, issues) {
-		const message = summarizeIssues(issues);
+		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
 		super(`Signal "${signalName}" input validation failed: ${message}`);
 		this.signalName = signalName;
 		this.issues = issues;
@@ -130,7 +90,7 @@ var SignalInputValidationError = class extends WorkerError {
 */
 var QueryInputValidationError = class extends WorkerError {
 	constructor(queryName, issues) {
-		const message = summarizeIssues(issues);
+		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
 		super(`Query "${queryName}" input validation failed: ${message}`);
 		this.queryName = queryName;
 		this.issues = issues;
@@ -142,7 +102,7 @@ var QueryInputValidationError = class extends WorkerError {
 */
 var QueryOutputValidationError = class extends WorkerError {
 	constructor(queryName, issues) {
-		const message = summarizeIssues(issues);
+		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
 		super(`Query "${queryName}" output validation failed: ${message}`);
 		this.queryName = queryName;
 		this.issues = issues;
@@ -154,7 +114,7 @@ var QueryOutputValidationError = class extends WorkerError {
 */
 var UpdateInputValidationError = class extends WorkerError {
 	constructor(updateName, issues) {
-		const message = summarizeIssues(issues);
+		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
 		super(`Update "${updateName}" input validation failed: ${message}`);
 		this.updateName = updateName;
 		this.issues = issues;
@@ -166,7 +126,7 @@ var UpdateInputValidationError = class extends WorkerError {
 */
 var UpdateOutputValidationError = class extends WorkerError {
 	constructor(updateName, issues) {
-		const message = summarizeIssues(issues);
+		const message = (0, _temporal_contract_contract.summarizeIssues)(issues);
 		super(`Update "${updateName}" output validation failed: ${message}`);
 		this.updateName = updateName;
 		this.issues = issues;
@@ -186,7 +146,13 @@ var ChildWorkflowNotFoundError = class extends WorkerError {
 	}
 };
 /**
-* Generic error for child workflow operations
+* Generic error for child workflow operations.
+*
+* When the child execution itself fails (Temporal's `ChildWorkflowFailure`),
+* `cause` is set to the *unwrapped* underlying failure (`ApplicationFailure`,
+* `TimeoutFailure`, `TerminatedFailure`, etc.) lifted from Temporal's wrapper —
+* 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 {
 	constructor(message, cause) {
@@ -195,13 +161,37 @@ var ChildWorkflowError = class extends WorkerError {
 	}
 };
 /**
-* Error returned in the `Result.Error` branch 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 while still surfacing
-* non-cancellation errors as Future rejections.
+* 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.
+*
+* 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.
+*/
+var ChildWorkflowCancelledError = class extends ChildWorkflowError {
+	constructor(workflowName, cause) {
+		super(`Child workflow "${workflowName}" was cancelled`, cause);
+		this.workflowName = workflowName;
+		this.name = "ChildWorkflowCancelledError";
+	}
+};
+/**
+* Error surfaced in the `err(...)` branch of a `ResultAsync` 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`.
 */
 var WorkflowCancelledError = class extends WorkerError {
 	constructor(cause) {
@@ -209,6 +199,42 @@ var WorkflowCancelledError = class extends WorkerError {
 		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";
+	}
+};
 //#endregion
 //#region src/internal.ts
 /**
@@ -219,6 +245,15 @@ var WorkflowCancelledError = class extends WorkerError {
 * In-package tests import it directly via relative path.
 */
 /**
+* Build the message attached to a `ChildWorkflowError` for input/output
+* validation failures. Centralized so the worker formats child-workflow
+* validation diagnostics identically across call sites. Composes the shared
+* `summarizeIssues` from `@temporal-contract/contract`.
+*/
+function formatChildWorkflowValidationMessage(workflowName, direction, issues) {
+	return `Child workflow "${workflowName}" ${direction} validation failed: ${(0, _temporal_contract_contract.summarizeIssues)(issues)}`;
+}
+/**
 * Extract the single payload from a Temporal handler's `...args` array.
 *
 * Temporal invokes handlers with whatever was passed via `args: [...]` at the
@@ -348,6 +383,49 @@ function looksLikeCrossContractCall(arg1, arg2) {
 	const workflows = candidate["workflows"];
 	return typeof workflows === "object" && workflows !== null;
 }
+/**
+* Map a thrown error from `startChild` / `executeChild` / `handle.result()`
+* (the worker-side child-workflow API) into the discriminated union surfaced
+* by the typed worker. Mirrors the client's `classifyResultError`:
+*
+* - Cancellation (detected via `@temporalio/workflow`'s `isCancellation`,
+*   which sees through nested `ChildWorkflowFailure → CancelledFailure`
+*   chains) → {@link ChildWorkflowCancelledError}, with the original error
+*   carried as `cause`.
+* - Temporal's `ChildWorkflowFailure` (a wrapper whose actionable failure —
+*   `ApplicationFailure`, `TimeoutFailure`, `TerminatedFailure`, etc. — lives
+*   on its `cause` field) → {@link ChildWorkflowError}, with that *inner*
+*   cause forwarded so consumers can match `err.cause instanceof
+*   ApplicationFailure` without unwrapping twice. (If the wrapper's `cause`
+*   is `undefined`, the wrapper itself is forwarded so identity is
+*   preserved.)
+* - Anything else → {@link ChildWorkflowError} carrying the raw thrown value
+*   as `cause`.
+*
+* The `operation` discriminator drives the human-readable error message so
+* call sites don't have to format their own.
+*
+* Note: `ChildWorkflowNotFoundError` is *not* produced here — it's only
+* thrown from the input-validation path when the workflow definition is
+* missing on the contract, before any Temporal call happens.
+*/
+function classifyChildWorkflowError(operation, error, childWorkflowName) {
+	if ((0, _temporalio_workflow.isCancellation)(error)) return new ChildWorkflowCancelledError(childWorkflowName, error);
+	if (error instanceof _temporalio_common.ChildWorkflowFailure) {
+		const inner = error.cause ?? error;
+		const innerMessage = inner instanceof Error ? inner.message : String(inner);
+		return new ChildWorkflowError(`${describeChildWorkflowOperation(operation, childWorkflowName)}: ${innerMessage}`, inner);
+	}
+	const message = error instanceof Error ? error.message : String(error);
+	return new ChildWorkflowError(`${describeChildWorkflowOperation(operation, childWorkflowName)}: ${message}`, error);
+}
+function describeChildWorkflowOperation(operation, childWorkflowName) {
+	switch (operation) {
+		case "startChild": return `Failed to start child workflow "${childWorkflowName}"`;
+		case "executeChild": return `Failed to execute child workflow "${childWorkflowName}"`;
+		case "result": return `Child workflow "${childWorkflowName}" execution failed`;
+	}
+}
 //#endregion
 Object.defineProperty(exports, "ActivityDefinitionNotFoundError", {
 	enumerable: true,
@@ -367,6 +445,12 @@ Object.defineProperty(exports, "ActivityOutputValidationError", {
 		return ActivityOutputValidationError;
 	}
 });
+Object.defineProperty(exports, "ChildWorkflowCancelledError", {
+	enumerable: true,
+	get: function() {
+		return ChildWorkflowCancelledError;
+	}
+});
 Object.defineProperty(exports, "ChildWorkflowError", {
 	enumerable: true,
 	get: function() {
@@ -427,12 +511,24 @@ Object.defineProperty(exports, "WorkflowOutputValidationError", {
 		return WorkflowOutputValidationError;
 	}
 });
+Object.defineProperty(exports, "WorkflowScopeError", {
+	enumerable: true,
+	get: function() {
+		return WorkflowScopeError;
+	}
+});
 Object.defineProperty(exports, "buildRawActivitiesProxy", {
 	enumerable: true,
 	get: function() {
 		return buildRawActivitiesProxy;
 	}
 });
+Object.defineProperty(exports, "classifyChildWorkflowError", {
+	enumerable: true,
+	get: function() {
+		return classifyChildWorkflowError;
+	}
+});
 Object.defineProperty(exports, "createContinueAsNew", {
 	enumerable: true,
 	get: function() {

package/dist/worker.d.mts

@@ -1,6 +1,6 @@
 import { ActivitiesHandler } from "./activity.mjs";
-import { Worker, WorkerOptions } from "@temporalio/worker";
 import { ContractDefinition } from "@temporal-contract/contract";
+import { Worker, WorkerOptions } from "@temporalio/worker";
 
 //#region src/worker.d.ts
 /**