taskmeld 0.1.1

package/dist/src/pipeline/diagnostics/dependency-diagnostic.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diagnoseNodeDependency = exports.REASON_MESSAGES = void 0;
+const dependency_check_1 = require("../execution/dependency-check");
+exports.REASON_MESSAGES = {
+    dependency_satisfied: "依赖已满足",
+    source_not_success: "上游节点未成功（当前状态不满足依赖）",
+    source_failed: "上游节点执行失败",
+    source_skipped: "上游节点已跳过",
+    route_mismatch: "路由不匹配（上游路由值与边要求不一致）",
+    cross_branch_edge_blocked: "跨支线边已被阻断",
+    group_not_success: "上游并行组未成功",
+    source_disabled_dependency_satisfied: "上游节点已禁用（视为依赖满足）",
+    source_disabled_route_impossible: "上游节点已禁用但路由边无法满足",
+    missing_source_item_run: "缺少上游节点条目运行记录",
+    missing_group_item_run: "缺少上游并行组条目运行记录",
+};
+const resolveOutcome = (satisfiedCount, impossibleCount, totalIncoming, policy) => {
+    if (policy === "any") {
+        if (satisfiedCount > 0)
+            return "queued";
+        if (impossibleCount === totalIncoming)
+            return "skipped";
+        return "waiting";
+    }
+    if (satisfiedCount === totalIncoming)
+        return "queued";
+    if (satisfiedCount + impossibleCount === totalIncoming && impossibleCount > 0)
+        return "skipped";
+    return "waiting";
+};
+const resolveReason = (satisfied, impossible, ctx, edge, itemKey) => {
+    if (satisfied) {
+        if (ctx.isGroupId(edge.from))
+            return "dependency_satisfied";
+        if (!ctx.isWorkflowNodeEnabled(edge.from))
+            return "source_disabled_dependency_satisfied";
+        return "dependency_satisfied";
+    }
+    if (ctx.isCrossBranchEdge(edge))
+        return "cross_branch_edge_blocked";
+    if (ctx.isGroupId(edge.from)) {
+        const sourceGroup = ctx.getGroupItemRun(edge.from, itemKey);
+        if (!sourceGroup)
+            return "missing_group_item_run";
+        if (sourceGroup.status === "failed")
+            return "group_not_success";
+        if (sourceGroup.status === "skipped")
+            return "group_not_success";
+        return "group_not_success";
+    }
+    if (!ctx.isWorkflowNodeEnabled(edge.from)) {
+        if (edge.when !== null)
+            return "source_disabled_route_impossible";
+        return "source_disabled_dependency_satisfied";
+    }
+    const source = ctx.getItemRun(edge.from, itemKey);
+    if (!source)
+        return "missing_source_item_run";
+    if (edge.when && source.status === "success" && source.route !== edge.when) {
+        return "route_mismatch";
+    }
+    if (source.status === "failed")
+        return "source_failed";
+    if (source.status === "skipped")
+        return "source_skipped";
+    return "source_not_success";
+};
+const diagnoseNodeDependency = (run, graph, nodeId, itemKey) => {
+    const workflowNode = graph.getWorkflowNodeById(nodeId);
+    const policy = workflowNode?.dependencyPolicy === "any" ? "any" : "all";
+    const incoming = graph.getIncomingEdges(nodeId);
+    const itemRuns = (run.itemRuns ?? [])
+        .filter((item) => item.nodeId === nodeId)
+        .filter((item) => !itemKey || item.itemKey === itemKey);
+    if (itemRuns.length === 0)
+        return [];
+    const ctx = {
+        isCrossBranchEdge: (edge) => graph.isCrossBranchEdge(edge),
+        isGroupId: (id) => graph.isGroupId(id),
+        isWorkflowNodeEnabled: (id) => graph.isWorkflowNodeEnabled(id),
+        isRoutePolicyNode: (id) => (graph.getWorkflowNodeById(id)?.routePolicy?.allowed.length ?? 0) > 0,
+        getGroupItemRun: (groupId, key) => (run.groupItemRuns ?? []).find((item) => item.groupId === groupId && item.itemKey === key) ?? null,
+        getItemRun: (node, key) => (run.itemRuns ?? []).find((item) => item.nodeId === node && item.itemKey === key) ?? null,
+    };
+    return itemRuns.map((item) => {
+        const incomingDiagnostics = incoming.map((edge) => {
+            const satisfied = (0, dependency_check_1.isDependencySatisfied)(item.itemKey, edge, ctx);
+            const impossible = (0, dependency_check_1.canNeverSatisfy)(item.itemKey, edge, ctx);
+            const reason = resolveReason(satisfied, impossible, ctx, edge, item.itemKey);
+            return { from: edge.from, when: edge.when, satisfied, impossible, reason };
+        });
+        const satisfiedCount = incomingDiagnostics.filter((d) => d.satisfied).length;
+        const impossibleCount = incomingDiagnostics.filter((d) => d.impossible).length;
+        const outcome = resolveOutcome(satisfiedCount, impossibleCount, incoming.length, policy);
+        return {
+            itemKey: item.itemKey,
+            nodeId: item.nodeId,
+            incoming: incomingDiagnostics,
+            policy,
+            outcome,
+        };
+    });
+};
+exports.diagnoseNodeDependency = diagnoseNodeDependency;

package/dist/src/pipeline/diagnostics/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REASON_MESSAGES = exports.diagnoseNodeDependency = void 0;
+var dependency_diagnostic_1 = require("./dependency-diagnostic");
+Object.defineProperty(exports, "diagnoseNodeDependency", { enumerable: true, get: function () { return dependency_diagnostic_1.diagnoseNodeDependency; } });
+Object.defineProperty(exports, "REASON_MESSAGES", { enumerable: true, get: function () { return dependency_diagnostic_1.REASON_MESSAGES; } });

package/dist/src/pipeline/dispatch/pipeline-inbound-queue.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildJobId = exports.createPipelineInboundQueue = void 0;
+const promises_1 = require("node:fs/promises");
+const pipeline_link_1 = require("../types/pipeline-link");
+Object.defineProperty(exports, "buildJobId", { enumerable: true, get: function () { return pipeline_link_1.buildJobId; } });
+const data_dir_1 = require("../../app/data-dir");
+const QUEUE_FILE = (0, data_dir_1.resolveTaskMeldDataPath)("pipeline-inbound-queue.jsonl");
+const MAX_COMPLETED_JOBS = 500;
+const COMPACT_TRIGGER_EVENT_COUNT = 2000;
+const pruneCompletedJobs = (snapshot) => {
+    const completed = [];
+    for (const job of snapshot.values()) {
+        if (job.status === "success" || job.status === "failed" || job.status === "canceled") {
+            completed.push(job);
+        }
+    }
+    if (completed.length <= MAX_COMPLETED_JOBS)
+        return;
+    completed.sort((a, b) => (a.finishedAt ?? "").localeCompare(b.finishedAt ?? ""));
+    const toDelete = completed.length - MAX_COMPLETED_JOBS;
+    for (let i = 0; i < toDelete; i++) {
+        snapshot.delete(completed[i].jobId);
+    }
+};
+const createPipelineInboundQueue = () => {
+    let jobSnapshot = new Map();
+    const replay = async () => {
+        const newSnapshot = new Map();
+        try {
+            const raw = await (0, promises_1.readFile)(QUEUE_FILE, "utf8");
+            const lines = raw.trim().split("\n").filter(Boolean);
+            for (const line of lines) {
+                try {
+                    const event = JSON.parse(line);
+                    applyEvent(event, newSnapshot);
+                }
+                catch {
+                    // Skip malformed lines
+                }
+            }
+        }
+        catch {
+            // File not found, start empty
+        }
+        // 重放后自动回收"running"状态的 job：这些 job 属于上次进程崩溃前已启动但未完成的任务，
+        // 恢复为 pending 并清空 targetRunId，让 drainer 重新调度执行。
+        for (const [jobId, job] of newSnapshot) {
+            if (job.status === "running") {
+                newSnapshot.set(jobId, {
+                    ...job,
+                    status: "pending",
+                    targetRunId: null,
+                    startedAt: null,
+                    error: "recovered_after_crash",
+                });
+            }
+        }
+        jobSnapshot = newSnapshot;
+    };
+    const applyEvent = (event, snapshot) => {
+        const now = new Date().toISOString();
+        switch (event.type) {
+            case "job.created": {
+                snapshot.set(event.job.jobId, { ...event.job });
+                break;
+            }
+            case "job.running": {
+                const job = snapshot.get(event.jobId);
+                if (job) {
+                    snapshot.set(event.jobId, {
+                        ...job,
+                        status: "running",
+                        targetRunId: event.targetRunId,
+                        startedAt: event.at,
+                        attempts: job.attempts + 1,
+                    });
+                }
+                break;
+            }
+            case "job.success": {
+                const job = snapshot.get(event.jobId);
+                if (job) {
+                    snapshot.set(event.jobId, {
+                        ...job,
+                        status: "success",
+                        finishedAt: event.at,
+                    });
+                }
+                pruneCompletedJobs(snapshot);
+                break;
+            }
+            case "job.failed": {
+                const job = snapshot.get(event.jobId);
+                if (job) {
+                    snapshot.set(event.jobId, {
+                        ...job,
+                        status: "failed",
+                        targetRunId: event.targetRunId ?? job.targetRunId,
+                        finishedAt: event.at,
+                        error: event.error,
+                    });
+                }
+                pruneCompletedJobs(snapshot);
+                break;
+            }
+            case "job.canceled": {
+                const job = snapshot.get(event.jobId);
+                if (job) {
+                    snapshot.set(event.jobId, {
+                        ...job,
+                        status: "canceled",
+                        finishedAt: event.at,
+                    });
+                }
+                pruneCompletedJobs(snapshot);
+                break;
+            }
+            case "job.retry_requested": {
+                const job = snapshot.get(event.jobId);
+                if (job) {
+                    snapshot.set(event.jobId, {
+                        ...job,
+                        status: "pending",
+                        targetRunId: null,
+                        startedAt: null,
+                        finishedAt: null,
+                        error: null,
+                    });
+                }
+                break;
+            }
+        }
+    };
+    const persistEvent = async (event) => {
+        await (0, promises_1.mkdir)((0, data_dir_1.resolveTaskMeldDataPath)(), { recursive: true });
+        const line = JSON.stringify(event) + "\n";
+        await (0, promises_1.appendFile)(QUEUE_FILE, line, "utf8");
+    };
+    let writeChain = Promise.resolve();
+    let eventsSinceCompact = 0;
+    const enqueueWrite = (op) => {
+        const next = writeChain.catch(() => { }).then(op);
+        writeChain = next.then(() => { }, () => { });
+        return next;
+    };
+    const compactJsonl = async (snapshot) => {
+        const tmpFile = `${QUEUE_FILE}.compact`;
+        await (0, promises_1.mkdir)((0, data_dir_1.resolveTaskMeldDataPath)(), { recursive: true });
+        const lines = [];
+        const now = new Date().toISOString();
+        for (const job of snapshot.values()) {
+            lines.push(JSON.stringify({ type: "job.created", at: now, job }));
+        }
+        await (0, promises_1.writeFile)(tmpFile, lines.length > 0 ? lines.join("\n") + "\n" : "", "utf8");
+        await (0, promises_1.rename)(tmpFile, QUEUE_FILE);
+        eventsSinceCompact = 0;
+    };
+    const filterByPipeline = (toPipelineId, status) => [...jobSnapshot.values()]
+        .filter((j) => j.toPipelineId === toPipelineId && (!status || j.status === status))
+        .sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.jobId.localeCompare(b.jobId));
+    const queue = {
+        initialize: async () => {
+            await enqueueWrite(async () => {
+                await replay();
+                pruneCompletedJobs(jobSnapshot);
+                await compactJsonl(jobSnapshot);
+            });
+        },
+        getJobs: (toPipelineId) => filterByPipeline(toPipelineId),
+        getPendingJobs: (toPipelineId) => filterByPipeline(toPipelineId, "pending"),
+        getRunningJob: (toPipelineId) => {
+            const running = filterByPipeline(toPipelineId, "running");
+            return running.length > 0 ? running[0] : null;
+        },
+        getJobById: (jobId) => jobSnapshot.get(jobId) ?? null,
+        getJobCount: (toPipelineId) => filterByPipeline(toPipelineId).length,
+        getPendingCount: (toPipelineId) => filterByPipeline(toPipelineId, "pending").length,
+        appendEvent: async (event) => {
+            await enqueueWrite(async () => {
+                await persistEvent(event);
+                applyEvent(event, jobSnapshot);
+                eventsSinceCompact += 1;
+                if (eventsSinceCompact >= COMPACT_TRIGGER_EVENT_COUNT) {
+                    await compactJsonl(jobSnapshot);
+                }
+            });
+        },
+        cancelJob: async (jobId, reason) => {
+            const job = jobSnapshot.get(jobId);
+            if (!job)
+                return { ok: false, error: "pipeline_queue_job_not_found" };
+            if (job.status !== "pending")
+                return { ok: false, error: "pipeline_queue_job_not_cancelable" };
+            await queue.appendEvent({ type: "job.canceled", at: new Date().toISOString(), jobId, reason });
+            return { ok: true };
+        },
+        retryJob: async (jobId) => {
+            const job = jobSnapshot.get(jobId);
+            if (!job)
+                return { ok: false, error: "pipeline_queue_job_not_found" };
+            if (job.status !== "failed" && job.status !== "canceled") {
+                return { ok: false, error: "pipeline_queue_job_not_retryable" };
+            }
+            await queue.appendEvent({ type: "job.retry_requested", at: new Date().toISOString(), jobId });
+            const updated = jobSnapshot.get(jobId);
+            if (!updated)
+                return { ok: false, error: "pipeline_queue_job_not_found" };
+            return { ok: true, job: updated };
+        },
+        getJobSnapshot: () => jobSnapshot,
+    };
+    return queue;
+};
+exports.createPipelineInboundQueue = createPipelineInboundQueue;

package/dist/src/pipeline/dispatch/pipeline-link-dispatcher.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPipelineLinkDispatcher = void 0;
+const pipeline_link_1 = require("../types/pipeline-link");
+const createPipelineLinkDispatcher = (deps) => {
+    const { linkStore, inboundQueue, pipelineExists } = deps;
+    const validateContract = (link, output) => {
+        if (!link.inputContract)
+            return true;
+        const { requireType, requireSchemaVersion } = link.inputContract;
+        if (requireType && output.artifactRef.type !== requireType)
+            return false;
+        if (requireSchemaVersion !== undefined && output.artifactRef.schemaVersion !== requireSchemaVersion)
+            return false;
+        return true;
+    };
+    return {
+        dispatch: async (output) => {
+            const links = await linkStore.list();
+            const matchingLinks = links.filter((l) => l.enabled && l.fromPipelineId === output.pipelineId);
+            let dispatched = 0;
+            const errors = [];
+            for (const link of matchingLinks) {
+                if (!pipelineExists(link.toPipelineId)) {
+                    errors.push(`link ${link.id}: downstream pipeline ${link.toPipelineId} not found`);
+                    continue;
+                }
+                if (!validateContract(link, output)) {
+                    errors.push(`link ${link.id}: input contract mismatch`);
+                    continue;
+                }
+                const pendingCount = inboundQueue.getPendingCount(link.toPipelineId);
+                if (pendingCount >= link.maxPendingJobs) {
+                    errors.push(`link ${link.id}: queue full (${pendingCount}/${link.maxPendingJobs})`);
+                    continue;
+                }
+                // Dedup: check if job already exists for this link+output
+                const jobId = (0, pipeline_link_1.buildJobId)(link.id, output.outputId);
+                const existing = inboundQueue.getJobById(jobId);
+                if (existing) {
+                    continue; // Already dispatched, skip
+                }
+                const now = new Date().toISOString();
+                const job = {
+                    schemaVersion: 1,
+                    jobId,
+                    linkId: link.id,
+                    fromPipelineId: output.pipelineId,
+                    toPipelineId: link.toPipelineId,
+                    status: "pending",
+                    upstreamOutput: output,
+                    targetRunId: null,
+                    attempts: 0,
+                    createdAt: now,
+                    startedAt: null,
+                    finishedAt: null,
+                    error: null,
+                };
+                await inboundQueue.appendEvent({ type: "job.created", at: now, job });
+                dispatched += 1;
+            }
+            return { dispatched, errors };
+        },
+    };
+};
+exports.createPipelineLinkDispatcher = createPipelineLinkDispatcher;

package/dist/src/pipeline/dispatch/pipeline-link-store.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPipelineLinkStore = void 0;
+const promises_1 = require("node:fs/promises");
+const pipeline_link_1 = require("../types/pipeline-link");
+const data_dir_1 = require("../../app/data-dir");
+const LINKS_FILE = (0, data_dir_1.resolveTaskMeldDataPath)("pipeline-links.json");
+const loadLinksDocument = async () => {
+    try {
+        const raw = await (0, promises_1.readFile)(LINKS_FILE, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && parsed.version === 1) {
+            return parsed;
+        }
+    }
+    catch {
+        // File not found or invalid, return default
+    }
+    return { version: 1, items: [] };
+};
+const saveLinksDocument = async (doc) => {
+    await (0, promises_1.mkdir)((0, data_dir_1.resolveTaskMeldDataPath)(), { recursive: true });
+    await (0, promises_1.writeFile)(LINKS_FILE, JSON.stringify(doc, null, 2), "utf8");
+};
+const createPipelineLinkStore = () => {
+    const store = {
+        list: async () => {
+            const doc = await loadLinksDocument();
+            return doc.items;
+        },
+        getById: async (id) => {
+            const doc = await loadLinksDocument();
+            return doc.items.find((link) => link.id === id) ?? null;
+        },
+        create: async (link) => {
+            if (!(0, pipeline_link_1.isValidLinkId)(link.id)) {
+                return { ok: false, error: "pipeline_link_invalid_id" };
+            }
+            if (link.fromPipelineId === link.toPipelineId) {
+                return { ok: false, error: "pipeline_link_self_loop" };
+            }
+            const doc = await loadLinksDocument();
+            if (doc.items.some((l) => l.id === link.id)) {
+                return { ok: false, error: "pipeline_link_already_exists" };
+            }
+            // Check for duplicate same from/to without contract differentiation
+            const existingSamePair = doc.items.filter((l) => l.fromPipelineId === link.fromPipelineId && l.toPipelineId === link.toPipelineId);
+            if (existingSamePair.length > 0) {
+                const contractMatch = existingSamePair.every((l) => {
+                    const a = l.inputContract;
+                    const b = link.inputContract;
+                    if (!a && !b)
+                        return true;
+                    if (!a || !b)
+                        return false;
+                    return a.requireType === b.requireType && a.requireSchemaVersion === b.requireSchemaVersion;
+                });
+                if (contractMatch) {
+                    return { ok: false, error: "pipeline_link_duplicate" };
+                }
+            }
+            doc.items.push(link);
+            await saveLinksDocument(doc);
+            return { ok: true, link };
+        },
+        update: async (id, patch) => {
+            const doc = await loadLinksDocument();
+            const index = doc.items.findIndex((l) => l.id === id);
+            if (index < 0) {
+                return { ok: false, error: "pipeline_link_not_found" };
+            }
+            const now = new Date().toISOString();
+            doc.items[index] = {
+                ...doc.items[index],
+                ...patch,
+                updatedAt: now,
+            };
+            await saveLinksDocument(doc);
+            return { ok: true, link: doc.items[index] };
+        },
+        remove: async (id) => {
+            const doc = await loadLinksDocument();
+            const index = doc.items.findIndex((l) => l.id === id);
+            if (index < 0) {
+                return { ok: false, error: "pipeline_link_not_found" };
+            }
+            doc.items.splice(index, 1);
+            await saveLinksDocument(doc);
+            return { ok: true };
+        },
+    };
+    return store;
+};
+exports.createPipelineLinkStore = createPipelineLinkStore;

package/dist/src/pipeline/dispatch/pipeline-queue-drainer.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPipelineQueueDrainer = void 0;
+const createPipelineQueueDrainer = (deps) => {
+    const drainInFlightByPipelineId = new Map();
+    const { inboundQueue, linkStore, isPipelineBusy, executeInboundJob } = deps;
+    const drainOne = async (toPipelineId) => {
+        if (isPipelineBusy(toPipelineId))
+            return;
+        const pendingJobs = inboundQueue.getPendingJobs(toPipelineId);
+        if (pendingJobs.length === 0)
+            return;
+        const job = pendingJobs[0];
+        const now = new Date().toISOString();
+        // Check if there's already a running job for this pipeline
+        const runningJob = inboundQueue.getRunningJob(toPipelineId);
+        if (runningJob)
+            return;
+        const result = await executeInboundJob({
+            jobId: job.jobId,
+            linkId: job.linkId,
+            upstreamOutput: job.upstreamOutput,
+        });
+        if (result.ok && result.runId) {
+            await inboundQueue.appendEvent({
+                type: "job.success",
+                at: new Date().toISOString(),
+                jobId: job.jobId,
+                targetRunId: result.runId,
+            });
+        }
+        else {
+            const link = await linkStore.getById(job.linkId);
+            const onJobFailed = link?.onJobFailed ?? "continue";
+            await inboundQueue.appendEvent({
+                type: "job.failed",
+                at: new Date().toISOString(),
+                jobId: job.jobId,
+                targetRunId: result.runId,
+                error: result.error ?? "unknown_error",
+            });
+            if (onJobFailed === "pause") {
+                return; // Stop draining this queue
+            }
+        }
+        // Continue draining if more pending jobs
+        if (inboundQueue.getPendingJobs(toPipelineId).length > 0) {
+            setImmediate(() => drainer.requestDrainInboundQueue(toPipelineId));
+        }
+    };
+    const drainer = {
+        requestDrainInboundQueue: (toPipelineId) => {
+            // If already draining, reuse existing promise
+            if (drainInFlightByPipelineId.has(toPipelineId))
+                return;
+            const drainPromise = drainOne(toPipelineId).finally(() => {
+                drainInFlightByPipelineId.delete(toPipelineId);
+            });
+            drainInFlightByPipelineId.set(toPipelineId, drainPromise);
+        },
+        onPipelineRunCompleted: (pipelineId) => {
+            // When a pipeline run completes, check if there are pending jobs to drain
+            const pendingJobs = inboundQueue.getPendingJobs(pipelineId);
+            if (pendingJobs.length > 0) {
+                setImmediate(() => drainer.requestDrainInboundQueue(pipelineId));
+            }
+        },
+    };
+    return drainer;
+};
+exports.createPipelineQueueDrainer = createPipelineQueueDrainer;

package/dist/src/pipeline/execution/dependency-check.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canNeverSatisfy = exports.isDependencySatisfied = void 0;
+const routes_1 = require("../workflow/routes");
+const isDependencySatisfied = (itemKey, edge, ctx) => {
+    if (ctx.isCrossBranchEdge(edge))
+        return false;
+    if (ctx.isGroupId(edge.from)) {
+        const sourceGroup = ctx.getGroupItemRun(edge.from, itemKey);
+        if (!sourceGroup)
+            return false;
+        return sourceGroup.status === "success";
+    }
+    if (!ctx.isWorkflowNodeEnabled(edge.from)) {
+        return edge.when === null;
+    }
+    const source = ctx.getItemRun(edge.from, itemKey);
+    if (!source)
+        return false;
+    if (source.status !== "success")
+        return false;
+    if (!edge.when) {
+        return ctx.isRoutePolicyNode(edge.from) ? source.route === routes_1.MAINLINE_ROUTE_VALUE : true;
+    }
+    return source.route === edge.when;
+};
+exports.isDependencySatisfied = isDependencySatisfied;
+const canNeverSatisfy = (itemKey, edge, ctx) => {
+    if (ctx.isCrossBranchEdge(edge))
+        return true;
+    if (ctx.isGroupId(edge.from)) {
+        const sourceGroup = ctx.getGroupItemRun(edge.from, itemKey);
+        if (!sourceGroup)
+            return false;
+        return sourceGroup.status === "failed" || sourceGroup.status === "skipped";
+    }
+    if (!ctx.isWorkflowNodeEnabled(edge.from)) {
+        return edge.when !== null;
+    }
+    const source = ctx.getItemRun(edge.from, itemKey);
+    if (!source)
+        return false;
+    if (source.status === "failed" || source.status === "skipped" || source.status === "stopped")
+        return true;
+    if (source.status === "success" && edge.when === null && ctx.isRoutePolicyNode(edge.from)) {
+        return source.route !== routes_1.MAINLINE_ROUTE_VALUE;
+    }
+    if (source.status === "success" && edge.when && source.route !== edge.when)
+        return true;
+    return false;
+};
+exports.canNeverSatisfy = canNeverSatisfy;

package/dist/src/pipeline/execution/execution-result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });