@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.0

package/vendor/dynamic-workflow/testing/journal-contract-artifacts.js

@@ -0,0 +1,195 @@
+/**
+ * 修复原因：journal-contract.ts 顶到 oxlint max-lines 上限（400 行），把用户面产物行（kind: "artifact"、artifactId 列、report 标签）的用例拆到本文件；
+ * 公开面仍从 journal-contract.ts 导出（`runJournalStoreContract` 按原顺序调用各主题的注册函数）。
+ *
+ * 注意：这里只登记 `it(...)`，不另开 describe——套件的分组与用例顺序必须与拆分前逐字相同。
+ */
+import { expect, it } from "vitest";
+import { baseRun } from "./journal-contract-helpers.js";
+export function registerArtifactCases(factory) {
+    // ——— 用户面产物（docs/dynamic-workflow/authoring.md）———
+    // ⚠ 这里的 artifact 是脚本发布给用户看的交付物，不是 `RunSettlement.artifact`
+    // （脚本顶层返回值）。两义并存，见 spec 的「术语」表。
+    // 内容成员成功发布的落库形状：`kind: "artifact"`、`result` 即整条 ArtifactVersionRecord、
+    // `artifactId` 指向它发布的那个产物。两个实现都必须**逐字**回读——`uri` 是字节的唯一
+    // 去路（字节不进 journal），加工或丢弃它就等于把一个已发布的产物变成打不开的卡片。
+    it("round-trips a completed artifact node with its version record", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const record = {
+            id: "book",
+            kind: "file",
+            version: 2,
+            title: "注意力之书",
+            description: "59 页 typst 排版",
+            contentType: "application/pdf",
+            bytes: 1_234_567,
+            uri: "zcode-artifact://ses_parent/abc123",
+            sourcePath: "out/book.pdf",
+            publishedAt: 1_725_000_000_000,
+            primary: true,
+        };
+        const node = {
+            runId: "r1",
+            siteId: "artifact#1",
+            ordinal: 2,
+            kind: "artifact",
+            inputHash: "ah",
+            status: "completed",
+            result: record,
+            artifactId: "book",
+        };
+        store.putNode(node);
+        const stored = store.getNode("r1", "artifact#1", 2);
+        expect(stored).toEqual(node);
+        expect(stored?.result).toEqual(record);
+    });
+    // 预置声明的行：同一个 kind、同一列 artifactId，只是 result 里装的是 spec 而不是字节元数据。
+    // 看板本身不含数据（它的每个点是一行标签 report），所以这一行就是「这个看板存在过」的全部记录。
+    it("round-trips a preset declaration artifact node with its spec", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const record = {
+            id: "perf",
+            kind: "chart",
+            version: 1,
+            title: "查询延迟",
+            spec: { type: "line", x: { field: "round" }, y: [{ field: "queryMsAfter" }] },
+        };
+        const node = {
+            runId: "r1",
+            siteId: "artifact#2",
+            ordinal: 1,
+            kind: "artifact",
+            inputHash: "ph",
+            status: "completed",
+            result: record,
+            artifactId: "perf",
+        };
+        store.putNode(node);
+        expect(store.getNode("r1", "artifact#2", 1)).toEqual(node);
+    });
+    // 失败的发布必须**带着 artifactId 落库**：读面要能说出「这个 id 的这次发布没成功」。
+    // 失败行没有 result（字节从未写成），错误在 error 上——这与 settled failure 必须落库
+    // 是同一条重放健全性要求。
+    it("round-trips a failed artifact node with its error and artifact id", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const failed = {
+            runId: "r1",
+            siteId: "artifact#1",
+            ordinal: 3,
+            kind: "artifact",
+            inputHash: "ah3",
+            status: "failed",
+            error: { code: "ArtifactSourceMissing", message: "out/book.pdf 不存在" },
+            artifactId: "book",
+        };
+        store.putNode(failed);
+        const stored = store.getNode("r1", "artifact#1", 3);
+        expect(stored).toEqual(failed);
+        expect(stored !== undefined && "result" in stored).toBe(false);
+    });
+    // 内容成员走的是「准入 running → 结算」两次写，而 putNode 是整条替换的 upsert：
+    // 结算那一次若不再带上 artifactId，产物归属会被抹掉，那次发布就从「本 run 有哪些产物」
+    // 的读面上消失。引擎两次写都带着它，这条把该形状钉在存储层。
+    it("keeps the artifact id across the running → settled rewrite", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const running = {
+            runId: "r1",
+            siteId: "artifact#1",
+            ordinal: 1,
+            kind: "artifact",
+            inputHash: "ah",
+            status: "running",
+            artifactId: "book",
+        };
+        store.putNode(running);
+        expect(store.getNode("r1", "artifact#1", 1)).toEqual(running);
+        store.putNode({
+            ...running,
+            status: "completed",
+            result: { id: "book", kind: "file", version: 1 },
+        });
+        const settled = store.getNode("r1", "artifact#1", 1);
+        expect(settled.status).toBe("completed");
+        expect(settled.artifactId).toBe("book");
+    });
+    // 「看板是 journal 的投影」这条不变式的落点：一个看板的每个点都是一行
+    // `kind = "report"` ∧ `artifactId` 相符。标签因此必须与 item 同寿地落在 report 行上。
+    it("round-trips the artifact tag on a report node", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const tagged = {
+            runId: "r1",
+            siteId: "report#1",
+            ordinal: 3,
+            kind: "report",
+            inputHash: "rh",
+            status: "completed",
+            result: { round: 3, queryMsAfter: 12.5 },
+            artifactId: "perf",
+        };
+        store.putNode(tagged);
+        expect(store.getNode("r1", "report#1", 3)).toEqual(tagged);
+    });
+    // 未打标签的 report、ask、world-* 与 0029 之前的历史行都没有这一列：必须解成**缺席的键**
+    // 而不是一个值为 undefined 的键。看板取数按「artifactId 相符」筛行，多出来的键会让
+    // 整条 toEqual 失败，也会让「没有标签」与「标签是 undefined」在读面上不可分辨。
+    it("leaves artifactId absent on nodes that carry no artifact", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const plain = {
+            runId: "r1",
+            siteId: "report#2",
+            ordinal: 1,
+            kind: "report",
+            inputHash: "rh2",
+            status: "completed",
+            result: { finding: "untagged" },
+        };
+        store.putNode(plain);
+        const stored = store.getNode("r1", "report#2", 1);
+        expect("artifactId" in stored).toBe(false);
+        expect(stored).toEqual(plain);
+    });
+    // listNodes 是引擎恢复产物版本号的取数面（「该 id 已 completed 的行数 + 1」，同
+    // reportCount 的恢复法），所以标签必须在枚举读面上也在场——只在 getNode 上回读是不够的。
+    it("returns artifactId from listNodes as well as getNode", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        store.putNode({
+            runId: "r1",
+            siteId: "artifact#1",
+            ordinal: 1,
+            kind: "artifact",
+            inputHash: "a1",
+            status: "completed",
+            result: { id: "book", kind: "file", version: 1 },
+            artifactId: "book",
+        });
+        store.putNode({
+            runId: "r1",
+            siteId: "report#1",
+            ordinal: 1,
+            kind: "report",
+            inputHash: "r1h",
+            status: "completed",
+            result: { round: 1 },
+            artifactId: "perf",
+        });
+        store.putNode({
+            runId: "r1",
+            siteId: "ask#1",
+            ordinal: 1,
+            kind: "ask",
+            inputHash: "k1",
+            status: "completed",
+            result: "plain",
+        });
+        const nodes = store.listNodes("r1", { kinds: "all", withResult: true });
+        expect(nodes.map((n) => n.artifactId)).toEqual(["book", "perf", undefined]);
+        expect("artifactId" in nodes[2]).toBe(false);
+    });
+}

package/vendor/dynamic-workflow/testing/journal-contract-events.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 修复原因：journal-contract.ts 顶到 oxlint max-lines 上限（400 行），把事件（追加序号、resume 续号、cursor 分页、按 run 隔离）的用例拆到本文件；
+ * 公开面仍从 journal-contract.ts 导出（`runJournalStoreContract` 按原顺序调用各主题的注册函数）。
+ *
+ * 注意：这里只登记 `it(...)`，不另开 describe——套件的分组与用例顺序必须与拆分前逐字相同。
+ */
+import type { JournalStorePort } from "../engine/index.js";
+export declare function registerEventCases(factory: () => JournalStorePort): void;
+//# sourceMappingURL=journal-contract-events.d.ts.map

package/vendor/dynamic-workflow/testing/journal-contract-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal-contract-events.d.ts","sourceRoot":"","sources":["../../src/testing/journal-contract-events.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG3D,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,gBAAgB,GAAG,IAAI,CA+LxE"}

package/vendor/dynamic-workflow/testing/journal-contract-events.js

@@ -0,0 +1,163 @@
+/**
+ * 修复原因：journal-contract.ts 顶到 oxlint max-lines 上限（400 行），把事件（追加序号、resume 续号、cursor 分页、按 run 隔离）的用例拆到本文件；
+ * 公开面仍从 journal-contract.ts 导出（`runJournalStoreContract` 按原顺序调用各主题的注册函数）。
+ *
+ * 注意：这里只登记 `it(...)`，不另开 describe——套件的分组与用例顺序必须与拆分前逐字相同。
+ */
+import { expect, it } from "vitest";
+import { baseRun, logs } from "./journal-contract-helpers.js";
+export function registerEventCases(factory) {
+    it("appends events with monotonic sequence and lists them in order", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const a = store.appendEvent("r1", { type: "log", message: "one" });
+        const b = store.appendEvent("r1", { type: "log", message: "two" });
+        expect(a.sequence).toBe(0);
+        expect(b.sequence).toBe(1);
+        const events = store.listEvents("r1", { types: "all", reportItems: "all" });
+        expect(events.map((e) => e.sequence)).toEqual([0, 1]);
+        expect(events.map((e) => (e.event.type === "log" ? e.event.message : ""))).toEqual([
+            "one",
+            "two",
+        ]);
+    });
+    it("stamps timeCreated on append and gives the same instant back on read", () => {
+        // 事件日志里唯一的时钟（docs/execution-engine.md「The journal」）：日志行的年龄、子代理上一次
+        // 动作的时刻都只能从它算。两个实现都必须填——让读者现取 Date.now() 兜底，会把一次冷重放里
+        // 一周前的整段历史全标成「刚刚」。追加路径与读回路径必须给同一个数，否则同一条事件两面不一。
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const before = Date.now();
+        const appended = store.appendEvent("r1", { type: "log", message: "one" });
+        const after = Date.now();
+        expect(appended.timeCreated).toBeTypeOf("number");
+        expect(appended.timeCreated).toBeGreaterThanOrEqual(before);
+        expect(appended.timeCreated).toBeLessThanOrEqual(after);
+        const [read] = store.listEvents("r1", { types: "all", reportItems: "all" });
+        expect(read?.timeCreated).toBe(appended.timeCreated);
+    });
+    it("throws when appending an event to an unknown run", () => {
+        // 孤儿事件写进去也永远读不回来（listEvents 按 runId 取），与 putActor/putNode 一样
+        // 属于契约破坏，必须当场大声失败。SQLite 侧由 dwf_event 的 FK 保证同一语义。
+        const store = factory();
+        expect(() => store.appendEvent("nope", { type: "log", message: "orphan" })).toThrow();
+    });
+    it("continues event sequence monotonically over a pre-populated store (resume case)", () => {
+        // resume 语义：新引擎接管一个已有事件的 store 时，appendEvent 必须从既有最大序号之后继续，
+        // 既不重置也不复用序号。内存实现天然满足；此断言逼迫阶段二的 SQLite 实现走同一 MAX(sequence)+1 语义。
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        store.appendEvent("r1", { type: "log", message: "pre-0" });
+        store.appendEvent("r1", { type: "log", message: "pre-1" });
+        // 模拟 resume：同一 store 上继续追加（生产中是另一个引擎实例接管）。
+        const resumed = store.appendEvent("r1", { type: "log", message: "post" });
+        expect(resumed.sequence).toBe(2);
+        const sequences = store
+            .listEvents("r1", { types: "all", reportItems: "all" })
+            .map((e) => e.sequence);
+        expect(sequences).toEqual([0, 1, 2]);
+        // 序号唯一（无复用）且单调递增。
+        expect(new Set(sequences).size).toBe(sequences.length);
+        for (let i = 1; i < sequences.length; i++)
+            expect(sequences[i]).toBeGreaterThan(sequences[i - 1]);
+    });
+    it("pages events with afterSequence as a strictly-greater cursor", () => {
+        // cursor 是"已读到的最后一个 sequence"，而不是偏移量：afterSequence: 0 必须跳过
+        // sequence 0（它已被读过），而不是从第 0 个开始。sequence 从 0 起，所以把 cursor
+        // 当偏移量的实现在这条断言上才会露馅——第一页会重复一条。
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        for (const message of ["e0", "e1", "e2"])
+            store.appendEvent("r1", { type: "log", message });
+        expect(logs(store.listEvents("r1", { types: "all", reportItems: "all" }))).toEqual([
+            "e0",
+            "e1",
+            "e2",
+        ]);
+        expect(logs(store.listEvents("r1", { types: "all", reportItems: "all", afterSequence: 0 }))).toEqual(["e1", "e2"]);
+        expect(logs(store.listEvents("r1", { types: "all", reportItems: "all", afterSequence: 1 }))).toEqual(["e2"]);
+        expect(store.listEvents("r1", { types: "all", reportItems: "all", afterSequence: 2 })).toEqual([]);
+    });
+    it("returns an empty page for an out-of-range cursor instead of throwing", () => {
+        // 详情页在 lastEventSequence 抬升时重取；投影与 journal 之间存在竞态窗口，
+        // 客户端拿着一个尚未存在的 cursor 回来是正常时序，不是错误。
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        store.appendEvent("r1", { type: "log", message: "only" });
+        expect(store.listEvents("r1", { types: "all", reportItems: "all", afterSequence: 99 })).toEqual([]);
+        // 未知 run 同样是空页：listEvents 全量形态今天就是这个语义，加 cursor 不改它。
+        expect(store.listEvents("nope", { types: "all", reportItems: "all", afterSequence: 0 })).toEqual([]);
+    });
+    it("caps a page at limit and keeps it anchored at the cursor", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        for (let i = 0; i < 5; i++)
+            store.appendEvent("r1", { type: "log", message: `e${i}` });
+        expect(logs(store.listEvents("r1", { types: "all", reportItems: "all", limit: 2 }))).toEqual([
+            "e0",
+            "e1",
+        ]);
+        expect(logs(store.listEvents("r1", { types: "all", reportItems: "all", afterSequence: 1, limit: 2 }))).toEqual(["e2", "e3"]);
+        // limit 超过剩余条数时给出剩余全部，不补空位。
+        expect(logs(store.listEvents("r1", { types: "all", reportItems: "all", afterSequence: 3, limit: 10 }))).toEqual(["e4"]);
+        expect(store.listEvents("r1", { types: "all", reportItems: "all", limit: 0 })).toEqual([]);
+    });
+    it("walks every event exactly once when paging by cursor (no overlap, no gap)", () => {
+        // 分页的整体性质：逐页推进 cursor 走完整条 journal，结果必须与一次性全量读逐字相同。
+        // 「差一」错误（>= 而非 >、或 limit 与 cursor 相互干扰）只会在这条断言上暴露。
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const total = 7;
+        for (let i = 0; i < total; i++)
+            store.appendEvent("r1", { type: "log", message: `e${i}` });
+        const walked = [];
+        let cursor;
+        for (let guard = 0; guard <= total; guard++) {
+            const page = store.listEvents("r1", {
+                types: "all",
+                reportItems: "all",
+                afterSequence: cursor,
+                limit: 3,
+            });
+            if (page.length === 0)
+                break;
+            for (const stored of page)
+                walked.push(stored.sequence);
+            cursor = page[page.length - 1].sequence;
+        }
+        expect(walked).toEqual(store.listEvents("r1", { types: "all", reportItems: "all" }).map((e) => e.sequence));
+        expect(new Set(walked).size).toBe(total);
+    });
+    it("keeps the cursor valid across resume", () => {
+        // resume 后 sequence 从既有最大值之后继续，所以 run 之前记下的 cursor 依然只
+        // 取到新事件；若实现按"每 run 每次从 0 重编号"或按行 id 而非 sequence 排序，
+        // 客户端会重收旧事件或漏掉新事件。
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        store.appendEvent("r1", { type: "log", message: "pre-0" });
+        store.appendEvent("r1", { type: "log", message: "pre-1" });
+        const cursor = store.listEvents("r1", { types: "all", reportItems: "all" }).at(-1).sequence;
+        // 模拟 resume：另一个引擎实例接管同一个 store 继续追加。
+        store.updateRunStatus("r1", "running");
+        store.appendEvent("r1", { type: "log", message: "post-0" });
+        store.appendEvent("r1", { type: "log", message: "post-1" });
+        const tail = store.listEvents("r1", {
+            types: "all",
+            reportItems: "all",
+            afterSequence: cursor,
+        });
+        expect(logs(tail)).toEqual(["post-0", "post-1"]);
+        expect(tail.map((e) => e.sequence)).toEqual([cursor + 1, cursor + 2]);
+    });
+    it("scopes event pages per runId", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        store.createRun(baseRun("r2"));
+        store.appendEvent("r1", { type: "log", message: "r1-0" });
+        store.appendEvent("r2", { type: "log", message: "r2-0" });
+        store.appendEvent("r2", { type: "log", message: "r2-1" });
+        // 每个 run 的 sequence 各自从 0 起，因此 cursor 必须与 runId 一同过滤。
+        expect(logs(store.listEvents("r1", { types: "all", reportItems: "all", afterSequence: 0 }))).toEqual([]);
+        expect(logs(store.listEvents("r2", { types: "all", reportItems: "all", afterSequence: 0 }))).toEqual(["r2-1"]);
+    });
+}

package/vendor/dynamic-workflow/testing/journal-contract-helpers.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 修复原因：journal-contract.ts 顶到 oxlint max-lines 上限（400 行），把各主题模块共用的
+ * 夹具（CAPS / baseRun / logs）拆到本文件；公开面仍从 journal-contract.ts 导出。
+ */
+import type { RunRecord, StoredEvent } from "../engine/index.js";
+export declare function baseRun(runId: string): RunRecord;
+/** 取出一页 log 事件的正文，用于逐页比对（事件种类无关的分页断言用它读得更直白）。 */
+export declare function logs(events: StoredEvent[]): string[];
+//# sourceMappingURL=journal-contract-helpers.d.ts.map

package/vendor/dynamic-workflow/testing/journal-contract-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal-contract-helpers.d.ts","sourceRoot":"","sources":["../../src/testing/journal-contract-helpers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAIjE,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAEhD;AAED,iDAAiD;AACjD,wBAAgB,IAAI,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,EAAE,CAEpD"}

package/vendor/dynamic-workflow/testing/journal-contract-helpers.js

@@ -0,0 +1,12 @@
+/**
+ * 修复原因：journal-contract.ts 顶到 oxlint max-lines 上限（400 行），把各主题模块共用的
+ * 夹具（CAPS / baseRun / logs）拆到本文件；公开面仍从 journal-contract.ts 导出。
+ */
+const CAPS = { maxConcurrency: 4 };
+export function baseRun(runId) {
+    return { runId, caps: CAPS, spentTokens: 0, status: "running" };
+}
+/** 取出一页 log 事件的正文，用于逐页比对（事件种类无关的分页断言用它读得更直白）。 */
+export function logs(events) {
+    return events.map((e) => (e.event.type === "log" ? e.event.message : `<${e.event.type}>`));
+}

package/vendor/dynamic-workflow/testing/journal-contract-isolation.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 修复原因：journal-contract.ts 顶到 oxlint max-lines 上限（400 行），把存储边界隔离与按 runId 作用域的收尾用例拆到本文件；
+ * 公开面仍从 journal-contract.ts 导出（`runJournalStoreContract` 按原顺序调用各主题的注册函数）。
+ *
+ * 注意：这里只登记 `it(...)`，不另开 describe——套件的分组与用例顺序必须与拆分前逐字相同。
+ */
+import type { JournalStorePort } from "../engine/index.js";
+export declare function registerIsolationCases(factory: () => JournalStorePort): void;
+//# sourceMappingURL=journal-contract-isolation.d.ts.map

package/vendor/dynamic-workflow/testing/journal-contract-isolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal-contract-isolation.d.ts","sourceRoot":"","sources":["../../src/testing/journal-contract-isolation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AAGvE,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,gBAAgB,GAAG,IAAI,CAsC5E"}

package/vendor/dynamic-workflow/testing/journal-contract-isolation.js

@@ -0,0 +1,46 @@
+/**
+ * 修复原因：journal-contract.ts 顶到 oxlint max-lines 上限（400 行），把存储边界隔离与按 runId 作用域的收尾用例拆到本文件；
+ * 公开面仍从 journal-contract.ts 导出（`runJournalStoreContract` 按原顺序调用各主题的注册函数）。
+ *
+ * 注意：这里只登记 `it(...)`，不另开 describe——套件的分组与用例顺序必须与拆分前逐字相同。
+ */
+import { expect, it } from "vitest";
+import { baseRun } from "./journal-contract-helpers.js";
+export function registerIsolationCases(factory) {
+    it("isolates stored records from later mutation of the caller's object", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const node = {
+            runId: "r1",
+            siteId: "ask#1",
+            ordinal: 1,
+            kind: "ask",
+            inputHash: "abc",
+            status: "completed",
+            result: { nested: { value: 1 } },
+        };
+        store.putNode(node);
+        // 改动调用方持有的对象不应影响已存记录（存储边界隔离）。
+        node.result.nested.value = 999;
+        const stored = store.getNode("r1", "ask#1", 1);
+        expect(stored).toBeDefined();
+        const result = stored.result;
+        expect(result.nested.value).toBe(1);
+    });
+    it("scopes records per runId", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        store.createRun(baseRun("r2"));
+        store.putNode({
+            runId: "r1",
+            siteId: "ask#1",
+            ordinal: 1,
+            kind: "ask",
+            inputHash: "h",
+            status: "completed",
+        });
+        expect(store.listNodes("r1", { kinds: "all", withResult: true })).toHaveLength(1);
+        expect(store.listNodes("r2", { kinds: "all", withResult: true })).toHaveLength(0);
+        expect(store.getNode("r2", "ask#1", 1)).toBeUndefined();
+    });
+}

package/vendor/dynamic-workflow/testing/journal-contract-nodes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 修复原因：journal-contract.ts 顶到 oxlint max-lines 上限（400 行），把actor 记录与节点记录（ask / world / report 行、缺席键、messageBoundary 回填）的用例拆到本文件；
+ * 公开面仍从 journal-contract.ts 导出（`runJournalStoreContract` 按原顺序调用各主题的注册函数）。
+ *
+ * 注意：这里只登记 `it(...)`，不另开 describe——套件的分组与用例顺序必须与拆分前逐字相同。
+ */
+import type { JournalStorePort } from "../engine/index.js";
+export declare function registerNodeCases(factory: () => JournalStorePort): void;
+//# sourceMappingURL=journal-contract-nodes.d.ts.map

package/vendor/dynamic-workflow/testing/journal-contract-nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal-contract-nodes.d.ts","sourceRoot":"","sources":["../../src/testing/journal-contract-nodes.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAe,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AAGpF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,gBAAgB,GAAG,IAAI,CAgPvE"}