automategraph 1.5.1 → 1.5.3

package/js/tests/harness.js

@@ -0,0 +1,192 @@
+"use strict";
+/* ============================================================
+ * Minimal zero-dependency test harness
+ * ------------------------------------------------------------
+ * - deterministic, sequential execution (isolation per test)
+ * - per-test timeout
+ * - per-test log capture (surfaced in the web report)
+ * - findings tagging (documents observed engine semantics)
+ * ============================================================ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEST_KINDS = void 0;
+exports.suite = suite;
+exports.allTests = allTests;
+exports.runAll = runAll;
+exports.TEST_KINDS = [
+    "unit",
+    "integration",
+    "async",
+    "upgrade",
+    "conformance",
+    "lint",
+    "edges",
+    "registry",
+    "graphjson",
+    "scripts"
+];
+const registry = [];
+let counters = { unit: 0, integration: 0, async: 0, upgrade: 0, conformance: 0, lint: 0, edges: 0, registry: 0, graphjson: 0, scripts: 0 };
+function suite(kind, category) {
+    return {
+        /**
+         * Register a test case.
+         */
+        t(name, fn, options = {}) {
+            counters[kind] += 1;
+            registry.push({
+                id: `${kind[0].toUpperCase()}${counters[kind]}`,
+                kind,
+                category,
+                name,
+                finding: options.finding,
+                timeoutMs: options.timeoutMs ?? 10_000,
+                fn
+            });
+        }
+    };
+}
+function allTests() {
+    return registry;
+}
+function formatLogValue(value) {
+    if (value === undefined)
+        return "";
+    try {
+        return JSON.stringify(value, (_k, v) => typeof v === "bigint" ? v.toString() : v);
+    }
+    catch {
+        return String(value);
+    }
+}
+function errorShape(value) {
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: value.stack
+        };
+    }
+    return { name: "NonErrorThrow", message: String(value) };
+}
+async function withTimeout(operation, timeoutMs, label) {
+    let timer;
+    const guard = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`Test "${label}" exceeded harness timeout of ${timeoutMs}ms ` +
+            `(possible engine hang)`)), timeoutMs);
+    });
+    try {
+        return await Promise.race([operation, guard]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+async function runAll() {
+    const unhandledRejections = [];
+    const onUnhandled = (reason) => {
+        unhandledRejections.push(reason instanceof Error
+            ? `${reason.name}: ${reason.message}`
+            : String(reason));
+    };
+    process.on("unhandledRejection", onUnhandled);
+    const results = [];
+    const startedAll = performance.now();
+    for (const test of allTests()) {
+        const logs = [];
+        const ctx = {
+            log(message, ...values) {
+                const suffix = values
+                    .filter(value => value !== undefined)
+                    .map(value => formatLogValue(value))
+                    .join(" ; ");
+                logs.push(`${message}${suffix ? ` :: ${suffix}` : ""}`);
+            }
+        };
+        const started = performance.now();
+        let record;
+        try {
+            await withTimeout(Promise.resolve().then(() => test.fn(ctx)), test.timeoutMs, test.name);
+            record = {
+                id: test.id,
+                kind: test.kind,
+                category: test.category,
+                name: test.name,
+                finding: test.finding,
+                status: "passed",
+                durationMs: Math.round((performance.now() - started) * 100) / 100,
+                logs
+            };
+        }
+        catch (error) {
+            record = {
+                id: test.id,
+                kind: test.kind,
+                category: test.category,
+                name: test.name,
+                finding: test.finding,
+                status: "failed",
+                durationMs: Math.round((performance.now() - started) * 100) / 100,
+                logs,
+                error: errorShape(error)
+            };
+        }
+        results.push(record);
+        const mark = record.status === "passed" ? "PASS" : "FAIL";
+        process.stdout.write(`[${mark}] ${record.id} ${record.category} :: ${record.name} (${record.durationMs}ms)\n`);
+        if (record.error) {
+            process.stdout.write(`        -> ${record.error.name}: ${record.error.message}\n`);
+        }
+    }
+    const durationMs = Math.round((performance.now() - startedAll) * 100) / 100;
+    // Give detached (non-required) listeners a chance to surface problems
+    // before we snapshot unhandled rejections.
+    await new Promise(resolve => setTimeout(resolve, 50));
+    process.off("unhandledRejection", onUnhandled);
+    const categories = new Map();
+    for (const record of results) {
+        const key = `${record.kind}::${record.category}`;
+        let entry = categories.get(key);
+        if (!entry) {
+            entry = {
+                category: record.category,
+                kind: record.kind,
+                total: 0,
+                passed: 0,
+                failed: 0,
+                durationMs: 0
+            };
+            categories.set(key, entry);
+        }
+        entry.total += 1;
+        entry.passed += record.status === "passed" ? 1 : 0;
+        entry.failed += record.status === "failed" ? 1 : 0;
+        entry.durationMs = Math.round((entry.durationMs + record.durationMs) * 100) / 100;
+    }
+    const byKind = Object.fromEntries(exports.TEST_KINDS.map(kind => {
+        const group = results.filter(record => record.kind === kind);
+        return [
+            kind,
+            {
+                total: group.length,
+                passed: group.filter(record => record.status === "passed").length,
+                failed: group.filter(record => record.status === "failed").length
+            }
+        ];
+    }));
+    return {
+        generatedAt: new Date().toISOString(),
+        nodeVersion: process.version,
+        durationMs,
+        totals: {
+            total: results.length,
+            passed: results.filter(record => record.status === "passed").length,
+            failed: results.filter(record => record.status === "failed").length,
+            byKind
+        },
+        byCategory: [...categories.values()],
+        unhandledRejections,
+        tests: results
+    };
+}
+//# sourceMappingURL=harness.js.map

package/js/tests/harness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness.js","sourceRoot":"","sources":["../../tests/harness.ts"],"names":[],"mappings":"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"}

package/js/tests/helpers.js

@@ -0,0 +1,136 @@
+"use strict";
+/* ============================================================
+ * Shared fixtures / builders / mocks for the AutomateGraph suite
+ * ============================================================ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tick = exports.SpyStorage = exports.BIG = exports.sleep = void 0;
+exports.node = node;
+exports.constNode = constNode;
+exports.g = g;
+exports.linear = linear;
+exports.plugin = plugin;
+exports.closeOnlyPlugin = closeOnlyPlugin;
+exports.capture = capture;
+exports.errorsOnly = errorsOnly;
+exports.logCollector = logCollector;
+exports.sortedIds = sortedIds;
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+exports.sleep = sleep;
+/** Generous per-test timeout for engine round-trips (macrotasks + storage). */
+exports.BIG = { timeoutMs: 20_000 };
+function node(id, run, extra = {}) {
+    return { id, run, ...extra };
+}
+function constNode(id, output, extra = {}) {
+    return node(id, () => output, extra);
+}
+function g(spec) {
+    const nodes = {};
+    for (const definition of spec.nodes)
+        nodes[definition.id] = definition;
+    return {
+        id: spec.id ?? "test-graph",
+        version: spec.version ?? "1.0.0",
+        entryNodes: spec.entryNodes,
+        terminalNodes: spec.terminalNodes,
+        nodes,
+        defaultNodeTimeoutMs: spec.defaultNodeTimeoutMs,
+        errorPolicy: spec.errorPolicy,
+        checkpointEveryNode: spec.checkpointEveryNode,
+        completionPolicy: spec.completionPolicy,
+        functions: spec.functions
+    };
+}
+/** Linear graph: a -> b -> c ... ; last node is the terminal. */
+function linear(ids, run, extra = {}) {
+    const nodes = ids.map((id, index) => node(id, ctx => (run ? run(id, ctx) : `${id}-out`), index < ids.length - 1 ? { next: [ids[index + 1]] } : {}));
+    return g({
+        nodes,
+        entryNodes: [ids[0]],
+        terminalNodes: [ids[ids.length - 1]],
+        ...extra
+    });
+}
+/* ------------------------- storages ------------------------- */
+/** Records snapshots by reference, can be made to fail on the Nth call. */
+class SpyStorage {
+    id = "test.spy-storage";
+    version = "9.9.9";
+    snapshots = [];
+    calls = 0;
+    failOn = () => false;
+    async saveAtomic(snapshot) {
+        this.calls += 1;
+        if (this.failOn(this.calls, snapshot)) {
+            throw new Error(`disk-full@${this.calls}`);
+        }
+        this.snapshots.push(snapshot);
+    }
+    async load(executionId) {
+        for (let i = this.snapshots.length - 1; i >= 0; i -= 1) {
+            if (this.snapshots[i].executionId === executionId) {
+                return this.snapshots[i];
+            }
+        }
+        return null;
+    }
+}
+exports.SpyStorage = SpyStorage;
+function plugin(spec) {
+    const events = [];
+    return {
+        id: spec.id,
+        version: spec.version ?? "1.0.0",
+        required: spec.required,
+        events,
+        async initialize() {
+            events.push(`init:${spec.id}`);
+            await spec.onInitialize?.();
+        },
+        async close() {
+            events.push(`close:${spec.id}`);
+            await spec.onClose?.();
+        }
+    };
+}
+/** Plugin with only a close() hook (no initialize). */
+function closeOnlyPlugin(id, events) {
+    return {
+        id,
+        version: "1.0.0",
+        async close() {
+            events.push(`close:${id}`);
+        }
+    };
+}
+/**
+ * Attaches required listeners (awaited by the bus, therefore
+ * deterministically ordered) and records payloads.
+ */
+function capture(engine, eventNames) {
+    const captured = [];
+    for (const name of eventNames) {
+        engine.events.on(name, (payload) => {
+            captured.push({ event: name, payload });
+        }, { required: true });
+    }
+    return captured;
+}
+function errorsOnly(captured) {
+    return captured.filter(entry => entry.event === "node.failed");
+}
+/** Creates an onLog collector for assertions. */
+function logCollector() {
+    const lines = [];
+    const onLog = (level, message, details) => {
+        lines.push({ level, message, details });
+    };
+    return { lines, onLog };
+}
+/** A promise that resolves on the next macrotask tick. */
+const tick = () => new Promise(resolve => setImmediate(resolve));
+exports.tick = tick;
+function sortedIds(values) {
+    return [...values].sort();
+}
+//# sourceMappingURL=helpers.js.map

package/js/tests/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../tests/helpers.ts"],"names":[],"mappings":"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"}

package/js/tests/lint.test.js

@@ -0,0 +1,317 @@
+"use strict";
+/* ============================================================
+ * LINT PACK — success dead-end rule (v1.2)
+ * ------------------------------------------------------------
+ * Closes the gap found while explaining the C-19 resilience
+ * fixture: a non-terminal node whose success path has nowhere to
+ * go (no `next`) used to pass linting as long as it declared an
+ * error transition.
+ *
+ * New code:
+ *   SUCCESS_DEAD_END (error tier) — the node can only "continue"
+ *   when it fails; a successful output is silently unreachable.
+ *   DEAD_END_NODE stays for the total case (no transitions at all).
+ * The two are mutually exclusive: every node with no `next` gets
+ * exactly one of them.
+ * ============================================================ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const automategraph_1 = require("../src/automategraph");
+const helpers_1 = require("./helpers");
+const harness_1 = require("./harness");
+const lint = (0, harness_1.suite)("lint", "Success dead-end rule");
+const BIG = { timeoutMs: 20_000 };
+/**
+ * The exact C-19 resilience fixture (with its test gate), rebuilt per
+ * call so each test gets a fresh gate promise.
+ */
+function resilienceFixture(options = {}) {
+    let releaseFast = () => { };
+    const fallbackDone = new Promise(resolve => { releaseFast = resolve; });
+    const definition = (0, helpers_1.g)({
+        nodes: [
+            (0, helpers_1.node)("start", () => 1, { next: ["slow-vendor", "fast-vendor"] }),
+            (0, helpers_1.node)("slow-vendor", async () => { await (0, helpers_1.sleep)(80); return "vendor-result"; }, {
+                timeoutMs: 25,
+                onThrow: "vendor-fallback",
+                ...(options.slowNext ? { next: options.slowNext } : {})
+            }),
+            (0, helpers_1.node)("vendor-fallback", () => { releaseFast(); return "cached-price"; }, { next: ["decide"] }),
+            (0, helpers_1.node)("fast-vendor", async () => {
+                await Promise.race([fallbackDone, (0, helpers_1.sleep)(2000)]);
+                return "fresh-price";
+            }, { next: ["decide"] }),
+            (0, helpers_1.node)("decide", async (context) => {
+                await context.emit("pricing.decided", { fallback: context.outputs["vendor-fallback"] });
+                return "decided";
+            }, { next: ["finish"] }),
+            (0, helpers_1.constNode)("finish", "DONE")
+        ],
+        entryNodes: ["start"],
+        terminalNodes: ["finish"]
+    });
+    return definition;
+}
+const codesFor = (definition, nodeId) => (0, automategraph_1.lintGraph)(definition)
+    .filter(issue => issue.nodeId === nodeId)
+    .map(issue => issue.code);
+/* ------------------------------ the rule ------------------------------ */
+lint.t("the exact C-19 fixture is flagged: slow-vendor succeeds into a void", async (t) => {
+    const issues = (0, automategraph_1.lintGraph)(resilienceFixture());
+    const slowIssues = issues.filter(issue => issue.nodeId === "slow-vendor");
+    if (slowIssues.length !== 1) {
+        throw new Error(`slow-vendor issues=${slowIssues.map(i => i.code).join(",") || "none"}`);
+    }
+    const issue = slowIssues[0];
+    if (issue.code !== "SUCCESS_DEAD_END")
+        throw new Error(issue.code);
+    if (issue.level !== "error")
+        throw new Error(issue.level);
+    if (!issue.message.includes('"slow-vendor"'))
+        throw new Error(issue.message);
+    if (!issue.message.includes("no next target"))
+        throw new Error(issue.message);
+    // mutual exclusivity: the old code must not also fire here
+    if (codesFor(resilienceFixture(), "slow-vendor").includes("DEAD_END_NODE")) {
+        throw new Error("both rules fired for the same node");
+    }
+    t.log("issue", `${issue.level}/${issue.code} @ ${issue.nodeId}`);
+    t.log("finding: a node can declare onThrow and still be unreachable on its success path — " +
+        "the previous DEAD_END_NODE rule only asked whether *any* transition existed");
+}, BIG);
+lint.t("the fix suggested by the message clears the issue (next declared)", async (t) => {
+    const fixed = resilienceFixture({ slowNext: ["decide"] });
+    const slowIssues = codesFor(fixed, "slow-vendor");
+    if (slowIssues.includes("SUCCESS_DEAD_END"))
+        throw new Error("issue survived the fix");
+    if (slowIssues.length !== 0)
+        throw new Error(slowIssues.join(","));
+    t.log("slow-vendor issues after adding next", slowIssues.length);
+}, BIG);
+lint.t("declared terminal nodes are never flagged, even without next", () => {
+    const definition = (0, helpers_1.g)({
+        nodes: [(0, helpers_1.constNode)("start", "S", { next: ["end"] }), (0, helpers_1.constNode)("end", "E")],
+        entryNodes: ["start"],
+        terminalNodes: ["end"]
+    });
+    const issues = (0, automategraph_1.lintGraph)(definition);
+    if (issues.some(issue => issue.nodeId === "end")) {
+        throw new Error(`terminal flagged: ${issues.map(i => i.code).join(",")}`);
+    }
+    if (issues.length !== 0)
+        throw new Error(issues.map(i => i.code).join(","));
+});
+lint.t("a node with no transitions at all is DEAD_END_NODE, not SUCCESS_DEAD_END", () => {
+    const definition = (0, helpers_1.g)({
+        nodes: [
+            (0, helpers_1.constNode)("start", "S", { next: ["dead", "end"] }),
+            (0, helpers_1.constNode)("dead", "D"),
+            (0, helpers_1.constNode)("end", "E")
+        ],
+        entryNodes: ["start"],
+        terminalNodes: ["end"]
+    });
+    const codes = codesFor(definition, "dead");
+    if (!codes.includes("DEAD_END_NODE"))
+        throw new Error(`codes=${codes.join(",")}`);
+    if (codes.includes("SUCCESS_DEAD_END"))
+        throw new Error("wrong rule fired");
+});
+lint.t("an ignored fallback does not count as a live error transition", () => {
+    const definition = (0, helpers_1.g)({
+        nodes: [
+            (0, helpers_1.constNode)("start", "S", { next: ["orphanish", "end"] }),
+            // fallback declared, but the effective policy is CONTINUE ⇒ inert
+            (0, helpers_1.node)("orphanish", () => "O", { fallback: "end" }),
+            (0, helpers_1.constNode)("end", "E")
+        ],
+        entryNodes: ["start"],
+        terminalNodes: ["end"]
+    });
+    const codes = codesFor(definition, "orphanish");
+    if (!codes.includes("DEAD_END_NODE"))
+        throw new Error(`codes=${codes.join(",")}`);
+    if (!codes.includes("FALLBACK_TARGET_IGNORED"))
+        throw new Error(`codes=${codes.join(",")}`);
+    if (codes.includes("SUCCESS_DEAD_END"))
+        throw new Error("inert fallback treated as live");
+});
+lint.t("a live fallback (policy FALLBACK) makes it SUCCESS_DEAD_END, not a total dead end", () => {
+    const definition = (0, helpers_1.g)({
+        nodes: [
+            (0, helpers_1.constNode)("start", "S", { next: ["primary", "end"] }),
+            (0, helpers_1.node)("primary", () => "P", { errorPolicy: "FALLBACK", fallback: "end" }),
+            (0, helpers_1.constNode)("end", "E")
+        ],
+        entryNodes: ["start"],
+        terminalNodes: ["end"]
+    });
+    const codes = codesFor(definition, "primary");
+    if (!codes.includes("SUCCESS_DEAD_END"))
+        throw new Error(`codes=${codes.join(",")}`);
+    if (codes.includes("DEAD_END_NODE"))
+        throw new Error("total dead end wrongly reported");
+    if (codes.includes("FALLBACK_TARGET_IGNORED"))
+        throw new Error("fallback should be live");
+});
+lint.t("onThrow alone is treated as a live error transition", () => {
+    const definition = (0, helpers_1.g)({
+        nodes: [
+            (0, helpers_1.constNode)("start", "S", { next: ["risky", "end"] }),
+            (0, helpers_1.node)("risky", () => "R", { onThrow: "end" }),
+            (0, helpers_1.constNode)("end", "E")
+        ],
+        entryNodes: ["start"],
+        terminalNodes: ["end"]
+    });
+    const codes = codesFor(definition, "risky");
+    if (codes.length !== 1 || codes[0] !== "SUCCESS_DEAD_END") {
+        throw new Error(`codes=${codes.join(",")}`);
+    }
+});
+lint.t("unreachable nodes with a success path stay unreachable-only (no noise)", () => {
+    const definition = (0, helpers_1.g)({
+        nodes: [
+            (0, helpers_1.constNode)("start", "S", { next: ["end"] }),
+            (0, helpers_1.constNode)("end", "E"),
+            (0, helpers_1.constNode)("floating", "F", { next: ["end"] })
+        ],
+        entryNodes: ["start"],
+        terminalNodes: ["end"]
+    });
+    const codes = codesFor(definition, "floating");
+    if (!codes.includes("UNREACHABLE_NODE"))
+        throw new Error(`codes=${codes.join(",")}`);
+    if (codes.includes("SUCCESS_DEAD_END"))
+        throw new Error("unexpected success dead-end");
+});
+lint.t("every issue has a stable shape and a known code", t => {
+    const known = new Set([
+        "DUPLICATE_ENTRY",
+        "DUPLICATE_TERMINAL",
+        "UNREACHABLE_NODE",
+        "UNREACHABLE_TERMINAL",
+        "DEAD_END_NODE",
+        "SUCCESS_DEAD_END",
+        "FALLBACK_TARGET_IGNORED"
+    ]);
+    const messy = (0, helpers_1.g)({
+        nodes: [
+            (0, helpers_1.constNode)("start", "S", { next: ["risky", "orphan"] }),
+            (0, helpers_1.node)("risky", () => "R", { onThrow: "end" }),
+            (0, helpers_1.constNode)("orphan", "O"),
+            (0, helpers_1.constNode)("end", "E")
+        ],
+        entryNodes: ["start", "start"],
+        terminalNodes: ["end"]
+    });
+    const issues = (0, automategraph_1.lintGraph)(messy);
+    if (issues.length === 0)
+        throw new Error("expected issues");
+    for (const issue of issues) {
+        if (issue.level !== "error" && issue.level !== "warn")
+            throw new Error(issue.level);
+        if (!known.has(issue.code))
+            throw new Error(`unknown code ${issue.code}`);
+        if (typeof issue.message !== "string" || issue.message.length === 0)
+            throw new Error("empty");
+        if (typeof issue.nodeId !== "string" || issue.nodeId.length === 0)
+            throw new Error("missing nodeId");
+    }
+    const codes = new Set(issues.map(issue => issue.code));
+    for (const expected of ["DUPLICATE_ENTRY", "SUCCESS_DEAD_END", "DEAD_END_NODE"]) {
+        if (!codes.has(expected))
+            throw new Error(`missing ${expected}`);
+    }
+    t.log("codes observed", [...codes].join(", "));
+});
+/* --------------------------- engine integration --------------------------- */
+lint.t("lint: \"warn\" logs SUCCESS_DEAD_END and still completes the C-19 run", async (t) => {
+    const { lines, onLog } = (0, helpers_1.logCollector)();
+    const engine = new automategraph_1.GraphExecutionEngine(resilienceFixture(), { lint: "warn", onLog });
+    const report = await engine.run();
+    if (report.status !== "COMPLETED")
+        throw new Error(report.status);
+    if (!report.results.some(result => result.nodeId === "finish"))
+        throw new Error("finish never ran");
+    const logged = lines.filter(line => line.message.includes("Graph lint [SUCCESS_DEAD_END]"));
+    if (logged.length !== 1)
+        throw new Error(`lint log lines=${logged.length}`);
+    // the line carries the ISSUE severity ("error"); the mode only decides
+    // whether error-tier issues are enforced or merely reported
+    if (logged[0].level !== "error")
+        throw new Error(logged[0].level);
+    const issues = report.lintIssues.filter(issue => issue.code === "SUCCESS_DEAD_END");
+    if (issues.length !== 1 || issues[0].nodeId !== "slow-vendor") {
+        throw new Error("lintIssues missing from the report");
+    }
+    t.log("run status", report.status, "| issue logged at severity 'error' but not enforced in warn mode");
+}, BIG);
+lint.t("lint: \"error\" rejects the C-19 graph before any node runs", async (t) => {
+    const engine = new automategraph_1.GraphExecutionEngine(resilienceFixture(), { lint: "error" });
+    const started = await engine.run();
+    if (started.status !== "REJECTED")
+        throw new Error(started.status);
+    if (started.results.length !== 0)
+        throw new Error(`ran ${started.results.length} nodes`);
+    if (Object.keys(started.outputs).length !== 0)
+        throw new Error("outputs recorded");
+    if (!started.errors[0].message.includes("Graph lint reported")) {
+        throw new Error(started.errors[0].message);
+    }
+    if (!started.lintIssues.some(issue => issue.code === "SUCCESS_DEAD_END")) {
+        throw new Error("lintIssues missing");
+    }
+    t.log("finding: lint enforcement is a pre-flight gate — the graph is rejected before " +
+        "initialization finishes, so no side effects from node callbacks can occur");
+}, BIG);
+/* ------------------------------ regression ------------------------------ */
+lint.t("the C-01 order-pipeline fixture flags audit as DEAD_END_NODE (documented gotcha)", async (t) => {
+    const definition = (0, helpers_1.g)({
+        id: "order-pipeline",
+        version: "2.1.0",
+        nodes: [
+            (0, helpers_1.node)("validate", () => ({ orderId: 7, amount: 120 }), { next: ["fraud", "audit"] }),
+            (0, helpers_1.node)("fraud", () => "clean", { next: ["charge"] }),
+            (0, helpers_1.node)("charge", () => ({ charged: 120 }), { next: ["ship"] }),
+            (0, helpers_1.node)("ship", () => "SHIPPED", { next: ["notify"] }),
+            (0, helpers_1.constNode)("notify", "EMAIL_SENT"),
+            (0, helpers_1.constNode)("audit", "AUDITED")
+        ],
+        entryNodes: ["validate"],
+        terminalNodes: ["notify"]
+    });
+    const issues = (0, automategraph_1.lintGraph)(definition);
+    const audit = issues.filter(issue => issue.nodeId === "audit");
+    if (audit.length !== 1 || audit[0].code !== "DEAD_END_NODE") {
+        throw new Error(`audit issues=${audit.map(i => i.code).join(",") || "none"}`);
+    }
+    if (issues.some(issue => issue.nodeId === "notify"))
+        throw new Error("terminal flagged");
+    // the fixture still runs fine — linting is off by default
+    const report = await new automategraph_1.GraphExecutionEngine(definition).run();
+    if (report.status !== "COMPLETED")
+        throw new Error(report.status);
+    t.log("audit", `${audit[0].level}/${audit[0].code}`, "| run", report.status);
+}, BIG);
+lint.t("a graph with no transition problems lints clean and runs", async (t) => {
+    const definition = (0, helpers_1.g)({
+        nodes: [
+            (0, helpers_1.node)("a", () => "A", { next: ["b"] }),
+            (0, helpers_1.node)("b", () => "B", { next: ["c"] }),
+            (0, helpers_1.constNode)("c", "C")
+        ],
+        entryNodes: ["a"],
+        terminalNodes: ["c"]
+    });
+    const issues = (0, automategraph_1.lintGraph)(definition);
+    if (issues.length !== 0)
+        throw new Error(issues.map(issue => issue.code).join(","));
+    const engine = new automategraph_1.GraphExecutionEngine(definition, { lint: "error" });
+    const captured = (0, helpers_1.capture)(engine, ["graph.finished"]);
+    const report = await engine.run();
+    if (report.status !== "COMPLETED")
+        throw new Error(report.status);
+    if (captured.length !== 1)
+        throw new Error("graph.finished missing");
+}, BIG);
+//# sourceMappingURL=lint.test.js.map