veryfront 0.1.1047 → 0.1.1049

package/esm/src/utils/route-path-utils.d.ts

@@ -39,11 +39,15 @@ interface RouterBasePath {
     type: "app" | "pages" | null;
     relativePath: string | null;
 }
+export interface RouterDirectories {
+    app?: string;
+    pages?: string;
+}
 /**
  * Extract the router base path from a page entity ID.
  * Detects whether it's an App Router (/app/) or Pages Router (/pages/) path.
  */
-export declare function extractRouterBasePath(pageEntityId: string): RouterBasePath;
+export declare function extractRouterBasePath(pageEntityId: string, directories?: RouterDirectories): RouterBasePath;
 /**
  * Result of route parameter extraction
  */
@@ -59,7 +63,7 @@ interface ExtractedRouteParams {
  * @param slug - The URL slug to match against
  * @returns Extracted parameters and whether matching succeeded
  */
-export declare function extractRouteParams(pageEntityId: string, slug: string): ExtractedRouteParams;
+export declare function extractRouteParams(pageEntityId: string, slug: string, directories?: RouterDirectories): ExtractedRouteParams;
 /**
  * Extract relative path from an absolute path by removing the project directory prefix.
  *

package/esm/src/utils/route-path-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route-path-utils.d.ts","sourceRoot":"","sources":["../../../src/src/utils/route-path-utils.ts"],"names":[],"mappings":"AAAA;;;;;4BAK4B;AAE5B,qCAAqC;AACrC,eAAO,MAAM,eAAe,wDAAyD,CAAC;AAEtF,sEAAsE;AACtE,eAAO,MAAM,oBAAoB,yCAA0C,CAAC;AAa5E;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAYtD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;GAEG;AACH,UAAU,cAAc;IACtB,IAAI,EAAE,KAAK,GAAG,OAAO,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,cAAc,CAY1E;AAED;;GAEG;AACH,UAAU,oBAAoB;IAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IAC1C,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,oBAAoB,CA4B3F;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAMpF;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,GAAG,IAAI,CA+B1C;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAErE"}
+{"version":3,"file":"route-path-utils.d.ts","sourceRoot":"","sources":["../../../src/src/utils/route-path-utils.ts"],"names":[],"mappings":"AAAA;;;;;4BAK4B;AAE5B,qCAAqC;AACrC,eAAO,MAAM,eAAe,wDAAyD,CAAC;AAEtF,sEAAsE;AACtE,eAAO,MAAM,oBAAoB,yCAA0C,CAAC;AAa5E;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAYtD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;GAEG;AACH,UAAU,cAAc;IACtB,IAAI,EAAE,KAAK,GAAG,OAAO,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,iBAAiB;IAChC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAYD;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,MAAM,EACpB,WAAW,GAAE,iBAAsB,GAClC,cAAc,CAYhB;AAED;;GAEG;AACH,UAAU,oBAAoB;IAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IAC1C,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,EACZ,WAAW,GAAE,iBAAsB,GAClC,oBAAoB,CA4BtB;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAMpF;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,GAAG,IAAI,CA+B1C;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAErE"}

package/esm/src/utils/route-path-utils.js

@@ -58,18 +58,27 @@ export function removeFileExtension(path) {
 export function extractParamName(segment) {
     return segment.replace(/\[\[\.\.\.|\[\.\.\.|\[|\]\]|\]/g, "");
 }
+function extractPathBelowRoot(pageEntityId, root) {
+    const normalizedPath = `/${pageEntityId.replaceAll("\\", "/").replace(/^\/+/, "")}`;
+    const normalizedRoot = root.replaceAll("\\", "/").replace(/^\/+|\/+$/g, "");
+    if (!normalizedRoot)
+        return null;
+    const marker = `/${normalizedRoot}/`;
+    const rootIndex = normalizedPath.lastIndexOf(marker);
+    return rootIndex === -1 ? null : normalizedPath.substring(rootIndex + marker.length);
+}
 /**
  * Extract the router base path from a page entity ID.
  * Detects whether it's an App Router (/app/) or Pages Router (/pages/) path.
  */
-export function extractRouterBasePath(pageEntityId) {
-    const appIndex = pageEntityId.indexOf("/app/");
-    if (appIndex !== -1) {
-        return { type: "app", relativePath: pageEntityId.substring(appIndex + 5) };
+export function extractRouterBasePath(pageEntityId, directories = {}) {
+    const appRelativePath = extractPathBelowRoot(pageEntityId, directories.app ?? "app");
+    if (appRelativePath !== null) {
+        return { type: "app", relativePath: appRelativePath };
     }
-    const pagesIndex = pageEntityId.indexOf("/pages/");
-    if (pagesIndex !== -1) {
-        return { type: "pages", relativePath: pageEntityId.substring(pagesIndex + 7) };
+    const pagesRelativePath = extractPathBelowRoot(pageEntityId, directories.pages ?? "pages");
+    if (pagesRelativePath !== null) {
+        return { type: "pages", relativePath: pagesRelativePath };
     }
     return { type: null, relativePath: null };
 }
@@ -81,9 +90,9 @@ export function extractRouterBasePath(pageEntityId) {
  * @param slug - The URL slug to match against
  * @returns Extracted parameters and whether matching succeeded
  */
-export function extractRouteParams(pageEntityId, slug) {
+export function extractRouteParams(pageEntityId, slug, directories = {}) {
     const params = {};
-    const { relativePath } = extractRouterBasePath(pageEntityId);
+    const { relativePath } = extractRouterBasePath(pageEntityId, directories);
     if (!relativePath)
         return { params, matched: false };
     const pathSegments = relativePath

package/esm/src/utils/version-constant.d.ts

@@ -1,3 +1,3 @@
 /** Shared version value. */
-export declare const VERSION = "0.1.1047";
+export declare const VERSION = "0.1.1049";
 //# sourceMappingURL=version-constant.d.ts.map

package/esm/src/utils/version-constant.js

@@ -1,4 +1,4 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
 /** Shared version value. */
-export const VERSION = "0.1.1047";
+export const VERSION = "0.1.1049";

package/esm/src/workflow/claude-code/react/use-claude-code-stream.js

@@ -4,7 +4,7 @@
  * Provides real-time streaming of Claude Code agent execution.
  */
 import * as dntShim from "../../../../_dnt.shims.js";
-import { useCallback, useEffect, useRef, useState } from "../../../../react/react.js";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { createClaudeCodeEventState, reduceClaudeCodeEventState, } from "./event-state-reducer.js";
 import { REQUEST_ERROR } from "../../../errors/index.js";
 /** Default delay before reconnecting after disconnect */

package/esm/src/workflow/claude-code/react/use-claude-code-websocket.js

@@ -4,7 +4,7 @@
  * Provides real-time bidirectional communication with Claude Code agents.
  */
 import * as dntShim from "../../../../_dnt.shims.js";
-import { useCallback, useEffect, useRef, useState } from "../../../../react/react.js";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { createClaudeCodeEventState, isClaudeCodeCoreEvent, reduceClaudeCodeEventState, } from "./event-state-reducer.js";
 import { NETWORK_ERROR, REQUEST_ERROR } from "../../../errors/index.js";
 /** Default delay before reconnecting after disconnect */

package/esm/src/workflow/executor/dag/composite-node-execution.d.ts

@@ -0,0 +1,11 @@
+import type { WorkflowNode } from "../../types.js";
+import type { NodeExecutionResult } from "./types.js";
+interface CompositeNodeExecutionInput {
+    node: WorkflowNode;
+    parentSignal?: AbortSignal;
+    cancellationGracePeriod?: number;
+    execute: (abortSignal: AbortSignal) => Promise<NodeExecutionResult>;
+}
+export declare function executeCompositeNodeWithPolicy(input: CompositeNodeExecutionInput): Promise<NodeExecutionResult>;
+export {};
+//# sourceMappingURL=composite-node-execution.d.ts.map

package/esm/src/workflow/executor/dag/composite-node-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite-node-execution.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/composite-node-execution.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAe,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEhE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAStD,UAAU,2BAA2B;IACnC,IAAI,EAAE,YAAY,CAAC;IACnB,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,OAAO,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACrE;AAID,wBAAsB,8BAA8B,CAClD,KAAK,EAAE,2BAA2B,GACjC,OAAO,CAAC,mBAAmB,CAAC,CAyD9B"}

package/esm/src/workflow/executor/dag/composite-node-execution.js

@@ -0,0 +1,147 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+import { TIMEOUT_ERROR } from "../../../errors/index.js";
+import { isVeryfrontError } from "../../../errors/http-error.js";
+import { ensureError } from "../../../errors/veryfront-error.js";
+import { parseDuration, validateRetryConfig } from "../../types.js";
+import { sleep } from "./utils.js";
+const DEFAULT_RETRY_INITIAL_DELAY_MS = 1_000;
+const DEFAULT_RETRY_MAX_DELAY_MS = 30_000;
+const DEFAULT_CANCELLATION_GRACE_PERIOD_MS = 1_000;
+const RETRYABLE_STATUSES = new Set([408, 425, 429, 500, 502, 503, 504]);
+const RETRYABLE_CODE_RE = /\b(ECONNRESET|ECONNREFUSED|ETIMEDOUT|EPIPE|EAI_AGAIN|ENOTFOUND)\b/;
+const nonCooperativeErrors = new WeakSet();
+export async function executeCompositeNodeWithPolicy(input) {
+    const { node, parentSignal, execute } = input;
+    const retry = node.config.retry;
+    if (retry)
+        validateRetryConfig(retry);
+    const maxAttempts = retry?.maxAttempts ?? 1;
+    const timeout = node.config.timeout === undefined
+        ? undefined
+        : parseDuration(node.config.timeout);
+    const startedAt = new Date();
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        parentSignal?.throwIfAborted();
+        try {
+            const result = await executeAttempt(execute, node.id, timeout, parentSignal, input.cancellationGracePeriod);
+            const attemptedResult = withAttempt(result, attempt);
+            if (attemptedResult.state.status !== "failed")
+                return attemptedResult;
+            const error = new Error(attemptedResult.state.error ?? `Composite node "${node.id}" failed`);
+            if (attempt === maxAttempts || !isRetryableError(error, retry))
+                return attemptedResult;
+            await sleep(calculateRetryDelay(attempt, retry), parentSignal);
+        }
+        catch (caught) {
+            parentSignal?.throwIfAborted();
+            const error = ensureError(caught);
+            if (attempt < maxAttempts && isRetryableError(error, retry)) {
+                await sleep(calculateRetryDelay(attempt, retry), parentSignal);
+                continue;
+            }
+            return {
+                state: {
+                    nodeId: node.id,
+                    status: "failed",
+                    error: error.message,
+                    attempt,
+                    startedAt,
+                    completedAt: new Date(),
+                },
+                contextUpdates: {},
+                waiting: false,
+            };
+        }
+    }
+    throw new Error(`Composite node "${node.id}" exhausted its retry attempts`);
+}
+async function executeAttempt(execute, nodeId, timeout, parentSignal, cancellationGracePeriod) {
+    const attemptController = new AbortController();
+    const forwardAbort = () => attemptController.abort(parentSignal?.reason);
+    if (parentSignal?.aborted)
+        forwardAbort();
+    else
+        parentSignal?.addEventListener("abort", forwardAbort, { once: true });
+    const operation = Promise.resolve().then(() => execute(attemptController.signal));
+    const fencedOperation = operation.then((result) => {
+        attemptController.signal.throwIfAborted();
+        return result;
+    });
+    let rejectAbort;
+    const abortPromise = new Promise((_, reject) => {
+        rejectAbort = () => reject(attemptController.signal.reason);
+        if (attemptController.signal.aborted)
+            rejectAbort();
+        else
+            attemptController.signal.addEventListener("abort", rejectAbort, { once: true });
+    });
+    let timeoutId;
+    if (timeout !== undefined) {
+        const timeoutError = TIMEOUT_ERROR.create({
+            detail: `Composite node "${nodeId}" timed out after ${timeout}ms`,
+        });
+        timeoutId = dntShim.setTimeout(() => attemptController.abort(timeoutError), timeout);
+    }
+    try {
+        return await Promise.race([fencedOperation, abortPromise]);
+    }
+    catch (caught) {
+        const error = ensureError(caught);
+        if (attemptController.signal.aborted) {
+            const settled = await waitForCancellationGrace(fencedOperation, cancellationGracePeriod);
+            if (!settled)
+                nonCooperativeErrors.add(error);
+        }
+        throw error;
+    }
+    finally {
+        if (timeoutId !== undefined)
+            clearTimeout(timeoutId);
+        if (rejectAbort)
+            attemptController.signal.removeEventListener("abort", rejectAbort);
+        parentSignal?.removeEventListener("abort", forwardAbort);
+    }
+}
+async function waitForCancellationGrace(operation, configuredGracePeriod) {
+    const gracePeriod = Math.max(0, configuredGracePeriod ?? DEFAULT_CANCELLATION_GRACE_PERIOD_MS);
+    let graceTimeoutId;
+    const settled = operation.then(() => true, () => true);
+    const graceExpired = new Promise((resolve) => {
+        graceTimeoutId = dntShim.setTimeout(() => resolve(false), gracePeriod);
+    });
+    try {
+        return await Promise.race([settled, graceExpired]);
+    }
+    finally {
+        if (graceTimeoutId !== undefined)
+            clearTimeout(graceTimeoutId);
+    }
+}
+function withAttempt(result, attempt) {
+    return {
+        ...result,
+        state: { ...result.state, attempt },
+    };
+}
+function isRetryableError(error, config) {
+    if (nonCooperativeErrors.has(error))
+        return false;
+    if (config?.retryIf)
+        return config.retryIf(error);
+    if (isVeryfrontError(error))
+        return RETRYABLE_STATUSES.has(error.status);
+    const code = error.code;
+    const subject = typeof code === "string" ? code : error.message;
+    return RETRYABLE_CODE_RE.test(subject);
+}
+function calculateRetryDelay(attempt, config) {
+    const initialDelay = config?.initialDelay ?? DEFAULT_RETRY_INITIAL_DELAY_MS;
+    const maxDelay = config?.maxDelay ?? DEFAULT_RETRY_MAX_DELAY_MS;
+    let baseDelay = initialDelay;
+    if (config?.backoff === "exponential")
+        baseDelay = initialDelay * Math.pow(2, attempt - 1);
+    else if (config?.backoff === "linear")
+        baseDelay = initialDelay * attempt;
+    const jitter = baseDelay * 0.1 * (Math.random() * 2 - 1);
+    return Math.floor(Math.min(baseDelay + jitter, maxDelay));
+}

package/esm/src/workflow/executor/dag/graph.js

@@ -51,7 +51,7 @@ export function getReadyNodes(inDegree, nodeStates) {
     const ready = [];
     for (const [nodeId, degree] of inDegree) {
         const state = nodeStates[nodeId];
-        if (degree === 0 && (!state || state.status === "pending")) {
+        if (degree === 0 && (!state || state.status === "pending" || state.status === "failed")) {
             ready.push(nodeId);
         }
     }

package/esm/src/workflow/executor/dag/index.d.ts

@@ -11,7 +11,7 @@ import type { DAGExecutionResult, DAGExecutorConfig } from "./types.js";
 export declare class DAGExecutor {
     private config;
     constructor(config: DAGExecutorConfig);
-    execute(nodes: WorkflowNode[], run: WorkflowRun, startFromNode?: string): Promise<DAGExecutionResult>;
+    execute(nodes: WorkflowNode[], run: WorkflowRun, startFromNode?: string, abortSignal?: AbortSignal): Promise<DAGExecutionResult>;
     private executeNode;
     private executeStepNode;
     private executeParallelNode;

package/esm/src/workflow/executor/dag/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAQV,YAAY,EAEZ,WAAW,EACZ,MAAM,gBAAgB,CAAC;AAIxB,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAE7F,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AAOpB,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAA4B;gBAE9B,MAAM,EAAE,iBAAiB;IAQ/B,OAAO,CACX,KAAK,EAAE,YAAY,EAAE,EACrB,GAAG,EAAE,WAAW,EAChB,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,kBAAkB,CAAC;YAoIhB,WAAW;YAgEX,eAAe;YA0Bf,mBAAmB;YA4CnB,iBAAiB;YA+DjB,eAAe;YA8Bf,sBAAsB;YA+DtB,UAAU;YAqBV,iBAAiB;CAmBhC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAQV,YAAY,EAEZ,WAAW,EACZ,MAAM,gBAAgB,CAAC;AAIxB,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAE7F,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AAQpB,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAA4B;gBAE9B,MAAM,EAAE,iBAAiB;IAQ/B,OAAO,CACX,KAAK,EAAE,YAAY,EAAE,EACrB,GAAG,EAAE,WAAW,EAChB,aAAa,CAAC,EAAE,MAAM,EACtB,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,kBAAkB,CAAC;YAyIhB,WAAW;YAqGX,eAAe;YA4Bf,mBAAmB;YAoDnB,iBAAiB;YAwEjB,eAAe;YA8Bf,sBAAsB;YA0EtB,UAAU;YAqBV,iBAAiB;CAoBhC"}

package/esm/src/workflow/executor/dag/index.js

@@ -11,6 +11,7 @@ import { deriveNodeStatus, shouldCheckpoint } from "./utils.js";
 import { buildGraph, getReadyNodes, hasCycle, updateInDegreesForCompletedNodes } from "./graph.js";
 import { executeLoopNodeStrategy } from "./loop-node-strategy.js";
 import { executeMapNodeStrategy } from "./map-node-strategy.js";
+import { executeCompositeNodeWithPolicy } from "./composite-node-execution.js";
 export class DAGExecutor {
     config;
     constructor(config) {
@@ -20,7 +21,8 @@ export class DAGExecutor {
             ...config,
         };
     }
-    async execute(nodes, run, startFromNode) {
+    async execute(nodes, run, startFromNode, abortSignal) {
+        abortSignal?.throwIfAborted();
         const context = { ...run.context };
         const nodeStates = { ...run.nodeStates };
         const { adjList, inDegree, nodeMap } = buildGraph(nodes);
@@ -36,9 +38,11 @@ export class DAGExecutor {
         }
         let ready = startFromNode ? [startFromNode] : getReadyNodes(inDegree, nodeStates);
         while (ready.length > 0) {
+            abortSignal?.throwIfAborted();
             const batch = ready.slice(0, this.config.maxConcurrency);
             ready = ready.slice(this.config.maxConcurrency);
-            const results = await Promise.allSettled(batch.map((nodeId) => this.executeNode(nodeMap.get(nodeId), context, nodeStates)));
+            const results = await Promise.allSettled(batch.map((nodeId) => this.executeNode(nodeMap.get(nodeId), context, nodeStates, abortSignal)));
+            abortSignal?.throwIfAborted();
             // Record the state of EVERY node in the batch before deciding the batch's
             // outcome. The whole batch already ran (Promise.allSettled), so returning
             // on the first failure would drop the persisted state of later nodes that
@@ -131,7 +135,8 @@ export class DAGExecutor {
             nodeStates,
         };
     }
-    async executeNode(node, context, nodeStates) {
+    async executeNode(node, context, nodeStates, abortSignal) {
+        abortSignal?.throwIfAborted();
         const nodeId = node.id;
         const existingState = nodeStates[nodeId];
         if (existingState?.status === "completed") {
@@ -139,6 +144,7 @@ export class DAGExecutor {
         }
         this.config.onNodeStart?.(nodeId);
         if (node.config.skip && (await node.config.skip(context))) {
+            abortSignal?.throwIfAborted();
             const state = this.config.stepExecutor.createSkippedState(nodeId);
             this.config.onNodeComplete?.(nodeId, state);
             return { state, contextUpdates: {}, waiting: false };
@@ -146,36 +152,63 @@ export class DAGExecutor {
         const config = node.config;
         switch (config.type) {
             case "step":
-                return this.executeStepNode(node, context);
+                return this.executeStepNode(node, context, abortSignal);
             case "parallel":
-                return this.executeParallelNode(node, config, context, nodeStates);
+                return executeCompositeNodeWithPolicy({
+                    node,
+                    parentSignal: abortSignal,
+                    cancellationGracePeriod: this.config.cancellationGracePeriod,
+                    execute: (attemptSignal) => this.executeParallelNode(node, config, context, nodeStates, attemptSignal),
+                });
             case "map":
-                return executeMapNodeStrategy({
+                return executeCompositeNodeWithPolicy({
                     node,
-                    config,
-                    context,
-                    nodeStates,
-                    runtime: {
-                        executeChildGraph: (nodes, run, options) => this.executeChildGraph(nodes, run, options),
-                        onNodeComplete: this.config.onNodeComplete,
-                    },
+                    parentSignal: abortSignal,
+                    cancellationGracePeriod: this.config.cancellationGracePeriod,
+                    execute: (attemptSignal) => executeMapNodeStrategy({
+                        node,
+                        config,
+                        context,
+                        nodeStates,
+                        runtime: {
+                            executeChildGraph: (nodes, run, options) => this.executeChildGraph(nodes, run, options, attemptSignal),
+                            onNodeComplete: this.config.onNodeComplete,
+                            abortSignal: attemptSignal,
+                        },
+                    }),
                 });
             case "branch":
-                return this.executeBranchNode(node, config, context, nodeStates);
+                return executeCompositeNodeWithPolicy({
+                    node,
+                    parentSignal: abortSignal,
+                    cancellationGracePeriod: this.config.cancellationGracePeriod,
+                    execute: (attemptSignal) => this.executeBranchNode(node, config, context, nodeStates, attemptSignal),
+                });
             case "wait":
                 return this.executeWaitNode(node, config, context);
             case "subWorkflow":
-                return this.executeSubWorkflowNode(node, config, context);
+                return executeCompositeNodeWithPolicy({
+                    node,
+                    parentSignal: abortSignal,
+                    cancellationGracePeriod: this.config.cancellationGracePeriod,
+                    execute: (attemptSignal) => this.executeSubWorkflowNode(node, config, context, attemptSignal),
+                });
             case "loop":
-                return executeLoopNodeStrategy({
+                return executeCompositeNodeWithPolicy({
                     node,
-                    config,
-                    context,
-                    nodeStates,
-                    runtime: {
-                        executeChildGraph: (nodes, run) => this.executeChildGraph(nodes, run),
-                        onNodeComplete: this.config.onNodeComplete,
-                    },
+                    parentSignal: abortSignal,
+                    cancellationGracePeriod: this.config.cancellationGracePeriod,
+                    execute: (attemptSignal) => executeLoopNodeStrategy({
+                        node,
+                        config,
+                        context,
+                        nodeStates,
+                        runtime: {
+                            executeChildGraph: (nodes, run) => this.executeChildGraph(nodes, run, undefined, attemptSignal),
+                            onNodeComplete: this.config.onNodeComplete,
+                            abortSignal: attemptSignal,
+                        },
+                    }),
                 });
             default:
                 throw INVALID_ARGUMENT.create({
@@ -184,8 +217,9 @@ export class DAGExecutor {
                 });
         }
     }
-    async executeStepNode(node, context) {
-        const result = await this.config.stepExecutor.execute(node, context);
+    async executeStepNode(node, context, abortSignal) {
+        const result = await this.config.stepExecutor.execute(node, context, abortSignal);
+        abortSignal?.throwIfAborted();
         const state = {
             nodeId: node.id,
             status: result.success ? "completed" : "failed",
@@ -203,7 +237,8 @@ export class DAGExecutor {
             waiting: false,
         };
     }
-    async executeParallelNode(node, config, context, nodeStates) {
+    async executeParallelNode(node, config, context, nodeStates, abortSignal) {
+        abortSignal?.throwIfAborted();
         const startTime = Date.now();
         const result = await this.execute(config.nodes, {
             id: `${node.id}_parallel`,
@@ -218,7 +253,8 @@ export class DAGExecutor {
             checkpoints: [],
             pendingApprovals: [],
             createdAt: new Date(),
-        });
+        }, undefined, abortSignal);
+        abortSignal?.throwIfAborted();
         Object.assign(nodeStates, result.nodeStates);
         const state = {
             nodeId: node.id,
@@ -236,9 +272,11 @@ export class DAGExecutor {
             waiting: result.waiting,
         };
     }
-    async executeBranchNode(node, config, context, nodeStates) {
+    async executeBranchNode(node, config, context, nodeStates, abortSignal) {
+        abortSignal?.throwIfAborted();
         const startTime = Date.now();
         const conditionResult = await config.condition(context);
+        abortSignal?.throwIfAborted();
         const branchNodes = conditionResult ? config.then : (config.else ?? []);
         if (branchNodes.length === 0) {
             const state = {
@@ -264,7 +302,8 @@ export class DAGExecutor {
             checkpoints: [],
             pendingApprovals: [],
             createdAt: new Date(),
-        });
+        }, undefined, abortSignal);
+        abortSignal?.throwIfAborted();
         Object.assign(nodeStates, result.nodeStates);
         const state = {
             nodeId: node.id,
@@ -307,7 +346,8 @@ export class DAGExecutor {
             waiting: true,
         };
     }
-    async executeSubWorkflowNode(node, config, context) {
+    async executeSubWorkflowNode(node, config, context, abortSignal) {
+        abortSignal?.throwIfAborted();
         const startTime = Date.now();
         if (typeof config.workflow === "string") {
             throw NOT_SUPPORTED.create({
@@ -318,9 +358,11 @@ export class DAGExecutor {
         const input = typeof config.input === "function"
             ? await config.input(context)
             : (config.input ?? context.input);
+        abortSignal?.throwIfAborted();
         const steps = typeof workflowDef.steps === "function"
             ? workflowDef.steps({ input, context })
             : workflowDef.steps;
+        abortSignal?.throwIfAborted();
         const subRunId = `${node.id}_sub_${generateId()}`;
         const result = await this.execute(steps, {
             id: subRunId,
@@ -333,10 +375,12 @@ export class DAGExecutor {
             checkpoints: [],
             pendingApprovals: [],
             createdAt: new Date(),
-        });
+        }, undefined, abortSignal);
+        abortSignal?.throwIfAborted();
         let finalOutput = result.context;
         if (result.completed && config.output) {
             finalOutput = config.output(result.context);
+            abortSignal?.throwIfAborted();
         }
         const state = {
             nodeId: node.id,
@@ -367,9 +411,9 @@ export class DAGExecutor {
         };
         await this.config.checkpointManager.save(runId, checkpoint);
     }
-    async executeChildGraph(nodes, run, options) {
+    async executeChildGraph(nodes, run, options, abortSignal) {
         if (!options?.maxConcurrency) {
-            return await this.execute(nodes, run);
+            return await this.execute(nodes, run, undefined, abortSignal);
         }
         // Run the child graph on a scoped executor rather than mutating
         // this.config.maxConcurrency. Concurrent child graphs (e.g. parallel map
@@ -379,6 +423,6 @@ export class DAGExecutor {
             ...this.config,
             maxConcurrency: options.maxConcurrency,
         });
-        return await childExecutor.execute(nodes, run);
+        return await childExecutor.execute(nodes, run, undefined, abortSignal);
     }
 }

package/esm/src/workflow/executor/dag/loop-node-strategy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loop-node-strategy.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/loop-node-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,cAAc,EACd,SAAS,EACT,eAAe,EACf,YAAY,EACb,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,UAAU,4BAA4B;IACpC,IAAI,EAAE,YAAY,CAAC;IACnB,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACtC,OAAO,EAAE,mBAAmB,CAAC;CAC9B;AAQD,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,mBAAmB,CAAC,CA6J9B"}
+{"version":3,"file":"loop-node-strategy.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/loop-node-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,cAAc,EACd,SAAS,EACT,eAAe,EACf,YAAY,EACb,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,UAAU,4BAA4B;IACpC,IAAI,EAAE,YAAY,CAAC;IACnB,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACtC,OAAO,EAAE,mBAAmB,CAAC;CAC9B;AAQD,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,mBAAmB,CAAC,CAqK9B"}

package/esm/src/workflow/executor/dag/loop-node-strategy.js

@@ -2,6 +2,7 @@ import { parseDuration } from "../../types.js";
 import { sleep } from "./utils.js";
 export async function executeLoopNodeStrategy(input) {
     const { node, config, context, nodeStates, runtime } = input;
+    runtime.abortSignal?.throwIfAborted();
     const startTime = Date.now();
     const previousResults = [];
     let iteration = 0;
@@ -23,6 +24,7 @@ export async function executeLoopNodeStrategy(input) {
         resumeIteration = existingLoopState.iteration;
     }
     while (iteration < config.maxIterations) {
+        runtime.abortSignal?.throwIfAborted();
         const loopContext = {
             iteration,
             totalIterations: iteration,
@@ -30,7 +32,9 @@ export async function executeLoopNodeStrategy(input) {
             isFirstIteration: iteration === 0,
             isLastAllowedIteration: iteration === config.maxIterations - 1,
         };
-        if (!(await config.while(context, loopContext))) {
+        const shouldContinue = await config.while(context, loopContext);
+        runtime.abortSignal?.throwIfAborted();
+        if (!shouldContinue) {
             exitReason = "condition";
             exitedViaCondition = true;
             break;
@@ -38,6 +42,7 @@ export async function executeLoopNodeStrategy(input) {
         const steps = typeof config.steps === "function"
             ? config.steps(context, loopContext)
             : config.steps;
+        runtime.abortSignal?.throwIfAborted();
         // On resume, rehydrate the in-flight iteration's child node states so its
         // already-completed steps are skipped instead of re-executed (H9).
         const iterationNodeStates = resumeIteration === iteration && resumeIterationNodeStates
@@ -57,6 +62,7 @@ export async function executeLoopNodeStrategy(input) {
             pendingApprovals: [],
             createdAt: new Date(),
         });
+        runtime.abortSignal?.throwIfAborted();
         if (result.waiting) {
             Object.assign(nodeStates, result.nodeStates);
             const state = {
@@ -91,7 +97,7 @@ export async function executeLoopNodeStrategy(input) {
         Object.assign(nodeStates, result.nodeStates);
         if (config.delay && iteration < config.maxIterations - 1) {
             const delayMs = typeof config.delay === "number" ? config.delay : parseDuration(config.delay);
-            await sleep(delayMs);
+            await sleep(delayMs, runtime.abortSignal);
         }
         iteration++;
     }
@@ -108,9 +114,11 @@ export async function executeLoopNodeStrategy(input) {
     let completionUpdates = {};
     if (exitReason === "maxIterations" && config.onMaxIterations) {
         completionUpdates = await config.onMaxIterations(context, finalLoopContext);
+        runtime.abortSignal?.throwIfAborted();
     }
     else if (exitReason === "condition" && config.onComplete) {
         completionUpdates = await config.onComplete(context, finalLoopContext);
+        runtime.abortSignal?.throwIfAborted();
     }
     const output = {
         exitReason,

package/esm/src/workflow/executor/dag/map-node-strategy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"map-node-strategy.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/map-node-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,eAAe,EAEf,YAAY,EAEb,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,UAAU,2BAA2B;IACnC,IAAI,EAAE,YAAY,CAAC;IACnB,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACtC,OAAO,EAAE,mBAAmB,CAAC;CAC9B;AAqCD,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,2BAA2B,GACjC,OAAO,CAAC,mBAAmB,CAAC,CAgE9B"}
+{"version":3,"file":"map-node-strategy.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/executor/dag/map-node-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,eAAe,EAEf,YAAY,EAEb,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,UAAU,2BAA2B;IACnC,IAAI,EAAE,YAAY,CAAC;IACnB,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACtC,OAAO,EAAE,mBAAmB,CAAC;CAC9B;AAqCD,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,2BAA2B,GACjC,OAAO,CAAC,mBAAmB,CAAC,CAmE9B"}

package/esm/src/workflow/executor/dag/map-node-strategy.js

@@ -27,8 +27,10 @@ function createMapChildNodes(node, config, items) {
 }
 export async function executeMapNodeStrategy(input) {
     const { node, config, context, nodeStates, runtime } = input;
+    runtime.abortSignal?.throwIfAborted();
     const startTime = Date.now();
     const items = typeof config.items === "function" ? await config.items(context) : config.items;
+    runtime.abortSignal?.throwIfAborted();
     if (!Array.isArray(items)) {
         throw INVALID_ARGUMENT.create({ detail: `Map node "${node.id}" items must be an array` });
     }
@@ -58,6 +60,7 @@ export async function executeMapNodeStrategy(input) {
         pendingApprovals: [],
         createdAt: new Date(),
     }, config.concurrency ? { maxConcurrency: config.concurrency } : undefined);
+    runtime.abortSignal?.throwIfAborted();
     Object.assign(nodeStates, result.nodeStates);
     const outputs = childNodes.map((child) => result.nodeStates[child.id]?.output);
     const state = {

package/esm/src/workflow/executor/dag/node-strategy-types.d.ts

@@ -7,5 +7,6 @@ export type ExecuteChildGraph = (nodes: WorkflowNode[], run: WorkflowRun, option
 export interface NodeStrategyRuntime {
     executeChildGraph: ExecuteChildGraph;
     onNodeComplete?: (nodeId: string, state: NodeState) => void;
+    abortSignal?: AbortSignal;
 }
 //# sourceMappingURL=node-strategy-types.d.ts.map