@floken-io/engine 0.0.1

package/dist/conformance.js

@@ -0,0 +1,711 @@
+import { ENGINE_ERROR_CODES, EngineError, deepEqual, STATE_SCHEMA_VERSION } from './chunk-RMCROXES.js';
+
+// src/conformance/report.ts
+async function runConformanceCases(suite, subject, specs) {
+  const cases = [];
+  for (const [name, refs, body] of specs) {
+    try {
+      await body();
+      cases.push({ name, refs, ok: true });
+    } catch (e) {
+      cases.push({ name, refs, ok: false, error: describeError(e) });
+    }
+  }
+  const passed = cases.filter((c) => c.ok).length;
+  const failed = cases.length - passed;
+  return {
+    suite,
+    // `exactOptionalPropertyTypes`：不能用 `subject: undefined` 占键
+    ...subject === void 0 ? {} : { subject },
+    cases,
+    total: cases.length,
+    passed,
+    failed,
+    ok: failed === 0
+  };
+}
+function formatConformanceReport(report) {
+  const head = `[${report.suite} conformance]${report.subject === void 0 ? "" : ` ${report.subject}`}`;
+  const lines = [`${report.ok ? "\u2713" : "\u2717"} ${head} \u2014 ${report.passed}/${report.total} \u901A\u8FC7`];
+  for (const c of report.cases) {
+    const refs = c.refs.length === 0 ? "" : ` (${c.refs.join(" ")})`;
+    if (c.ok) lines.push(`  \u2713 ${c.name}${refs}`);
+    else lines.push(`  \u2717 ${c.name}${refs}`, `      ${c.error ?? "(\u65E0\u9519\u8BEF\u4FE1\u606F)"}`);
+  }
+  return lines.join("\n");
+}
+function assertTrue(cond, message) {
+  if (!cond) throw new Error(message);
+}
+function assertDeepEqual(actual, expected, what) {
+  if (!deepEqual(actual, expected)) {
+    throw new Error(`${what}\uFF1A\u671F\u671B ${show(expected)}\uFF0C\u5B9E\u5F97 ${show(actual)}`);
+  }
+}
+function isEngineErrorLike(e) {
+  if (e instanceof EngineError) return true;
+  return typeof e === "object" && e !== null && e.floken === true && typeof e.code === "string";
+}
+function assertEngineErrorValue(value, expectedCode, what) {
+  if (!isEngineErrorLike(value)) {
+    throw new Error(`${what}\uFF1A\u671F\u671B\u629B EngineError\uFF0C\u5B9E\u5F97 ${describeError(value)}`);
+  }
+  assertTrue(
+    value.code === expectedCode,
+    `${what}\uFF1A\u9519\u8BEF\u7801\u671F\u671B ${expectedCode}\uFF0C\u5B9E\u5F97 ${value.code}`
+  );
+  assertTrue(
+    value.floken === true,
+    `${what}\uFF1A\u9519\u8BEF\u7F3A floken \u5370\u8BB0 \u2014\u2014 \u5BBF\u4E3B\u81EA\u7814\u5B9E\u73B0\u987B\u7528 engine \u5BFC\u51FA\u7684\u5DE5\u5382\u629B\u9519\uFF0C\u5426\u5219\u5F15\u64CE\u65E0\u6CD5\u5F52\u4E00`
+  );
+  assertTrue(value.pkg === "engine", `${what}\uFF1Apkg \u671F\u671B 'engine'\uFF0C\u5B9E\u5F97 ${String(value.pkg)}`);
+  return value;
+}
+async function mustThrow(fn, what) {
+  try {
+    await fn();
+  } catch (e) {
+    return e;
+  }
+  throw new Error(`${what}\uFF1A\u671F\u671B\u629B\u9519\uFF0C\u4F46\u6B63\u5E38\u8FD4\u56DE\u4E86`);
+}
+async function catchEngineError(fn, expectedCode, what) {
+  return assertEngineErrorValue(await mustThrow(fn, what), expectedCode, what);
+}
+function describeError(e) {
+  if (isEngineErrorLike(e)) {
+    const hint = e.hint === void 0 ? "" : ` \u2014 ${e.hint}`;
+    return `${e.name}: ${e.message} [${e.code}]${hint}`;
+  }
+  if (e instanceof Error) return `${e.name}: ${e.message}`;
+  return show(e);
+}
+function show(value) {
+  if (value === void 0) return "undefined";
+  try {
+    const s = JSON.stringify(value);
+    return s === void 0 ? String(value) : s;
+  } catch {
+    return String(value);
+  }
+}
+
+// src/conformance/store.ts
+var TS = "2026-09-30T00:00:00.000Z";
+var seq = 0;
+function uniqueId(prefix) {
+  seq += 1;
+  return `${prefix}_${seq.toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function makeState(instanceId, over = {}) {
+  return {
+    instanceId,
+    processId: "expense",
+    definitionVersion: 1,
+    status: over.status ?? "running",
+    rev: over.rev ?? 0,
+    stateSchema: STATE_SCHEMA_VERSION,
+    startedAt: TS,
+    updatedAt: TS,
+    ...over.businessKey === void 0 ? {} : { businessKey: over.businessKey },
+    tokens: [{ id: `${instanceId}::t1`, nodeId: "Task_Approve", state: "active", assignee: "u_1" }],
+    completedNodes: [],
+    variables: over.variables ?? { amount: 100 },
+    auditTrail: [{ seq: 1, at: TS, actor: "u_1", action: "start" }]
+  };
+}
+var conflict = ENGINE_ERROR_CODES.PERSIST_CONFLICT;
+var exists = ENGINE_ERROR_CODES.PERSIST_ALREADY_EXISTS;
+async function runStoreConformance(store, options = {}) {
+  const prefix = options.idPrefix ?? "floken-conf";
+  const newId = () => uniqueId(prefix);
+  return runConformanceCases("store", options.subject, [
+    // ── 读路径 ──
+    [
+      "load \u672A\u77E5 id \u8FD4\u56DE null\uFF08\u4E0D\u5F97\u629B\u9519\uFF09",
+      ["\xA77.2"],
+      async () => {
+        const got = await store.load(newId());
+        assertTrue(got === null, `\u671F\u671B null\uFF0C\u5B9E\u5F97 ${show(got)}`);
+      }
+    ],
+    // ── INSERT 路径 ──
+    [
+      "INSERT\uFF1AexpectedRev === 0 \u6210\u529F\uFF0C\u4E14 rev \u88AB\u5F52\u4E00\u5316\u4E3A 1\uFF08\u4E0D\u4FE1\u4EFB next.rev\uFF09",
+      ["INV-1", "AC-E11"],
+      async () => {
+        const s = makeState(newId(), { rev: 999 });
+        await store.save(s, 0);
+        const got = await store.load(s.instanceId);
+        assertTrue(got !== null, "INSERT \u540E load \u8FD4\u56DE null");
+        assertDeepEqual(
+          got.rev,
+          1,
+          "INSERT \u540E\u7684 rev\uFF08\u5B58\u50A8\u5C42\u987B\u6309 expectedRev+1 \u5F52\u4E00\u5316\uFF0C\u4E0E SQL \u7684 SET rev = rev + 1 \u540C\u6784\uFF09"
+        );
+      }
+    ],
+    [
+      "INSERT \u540E\u5B8C\u6574\u5185\u5BB9\u53EF\u6309 id \u8BFB\u56DE\uFF08\u9664 rev \u5916\u9010\u5B57\u6BB5\u6DF1\u7B49\uFF09",
+      ["\xA77.2"],
+      async () => {
+        const s = makeState(newId(), { businessKey: "BK_1" });
+        await store.save(s, 0);
+        const got = await store.load(s.instanceId);
+        assertTrue(got !== null, "INSERT \u540E load \u8FD4\u56DE null");
+        assertDeepEqual({ ...got, rev: 0 }, { ...s, rev: 0 }, "\u8BFB\u56DE\u5185\u5BB9");
+      }
+    ],
+    // ── 隔离性（内存与 SQL 都必须成立，实现机制不同） ──
+    [
+      "load() \u4EA4\u51FA\u526F\u672C\uFF1A\u5BBF\u4E3B\u6539\u52A8\u624B\u91CC\u90A3\u4EFD\u4E0D\u5F97\u6CC4\u6F0F\u8FDB\u5DF2\u63D0\u4EA4\u72B6\u6001",
+      ["\xA79 T5"],
+      async () => {
+        const s = makeState(newId());
+        await store.save(s, 0);
+        const first = await store.load(s.instanceId);
+        assertTrue(first !== null, "load \u8FD4\u56DE null");
+        first.status = "terminated";
+        first.variables.leak = true;
+        const second = await store.load(s.instanceId);
+        assertTrue(second !== null, "load \u8FD4\u56DE null");
+        assertTrue(
+          second.status === "running",
+          `load() \u672A\u4EA4\u51FA\u526F\u672C\uFF1A\u5BBF\u4E3B\u7684\u6539\u52A8\u6CC4\u6F0F\u8FDB\u4E86\u5E93\uFF08status \u5B9E\u5F97 ${second.status}\uFF09`
+        );
+        assertTrue(
+          second.variables.leak === void 0,
+          `load() \u672A\u505A\u6DF1\u62F7\u8D1D\uFF1A\u5D4C\u5957\u5B57\u6BB5\u88AB\u6CC4\u6F0F\uFF08variables.leak \u5B9E\u5F97 ${show(second.variables.leak)}\uFF09`
+        );
+      }
+    ],
+    [
+      "save() \u5B58\u5165\u526F\u672C\uFF1Asave \u4E4B\u540E\u6539 next \u4E0D\u5F97\u5F71\u54CD\u5DF2\u63D0\u4EA4\u72B6\u6001",
+      ["\xA79 T5"],
+      async () => {
+        const s = makeState(newId(), { businessKey: "BK_ORIGINAL" });
+        await store.save(s, 0);
+        s.businessKey = "BK_MUTATED_AFTER_SAVE";
+        s.variables.amount = 999;
+        const got = await store.load(s.instanceId);
+        assertTrue(got !== null, "load \u8FD4\u56DE null");
+        assertTrue(
+          got.businessKey === "BK_ORIGINAL",
+          `save() \u5B58\u4E86\u5F15\u7528\u800C\u975E\u526F\u672C\uFF08businessKey \u5B9E\u5F97 ${show(got.businessKey)}\uFF09`
+        );
+        assertTrue(
+          got.variables.amount === 100,
+          `save() \u672A\u505A\u6DF1\u62F7\u8D1D\uFF1A\u5D4C\u5957\u5B57\u6BB5\u88AB\u6539\uFF08variables.amount \u5B9E\u5F97 ${show(got.variables.amount)}\uFF09`
+        );
+      }
+    ],
+    [
+      "load() \u8FD4\u56DE\u503C JSON \u5F80\u8FD4\u6DF1\u7B49\uFF08INV-14\uFF1A\u5E93\u5185\u53EA\u5141\u8BB8\u7EAF\u6570\u636E\uFF09",
+      ["INV-14", "AC-E8"],
+      async () => {
+        const s = makeState(newId());
+        await store.save(s, 0);
+        const got = await store.load(s.instanceId);
+        assertTrue(got !== null, "load \u8FD4\u56DE null");
+        assertDeepEqual(JSON.parse(JSON.stringify(got)), got, "JSON \u5F80\u8FD4");
+      }
+    ],
+    // ── INSERT 冲突 ──
+    [
+      "\u91CD\u590D INSERT \u629B PERSIST_ALREADY_EXISTS\uFF0C\u4E14\u4E0D\u8986\u76D6\u539F\u8BB0\u5F55\u3001\u4E0D\u6D88\u8D39 rev",
+      ["AC-E11"],
+      async () => {
+        const first = makeState(newId(), { businessKey: "BK_1" });
+        await store.save(first, 0);
+        const second = makeState(first.instanceId, { businessKey: "BK_2" });
+        await catchEngineError(
+          () => store.save(second, 0),
+          exists,
+          "\u540C id \u4E8C\u6B21 INSERT"
+        );
+        const got = await store.load(first.instanceId);
+        assertTrue(got !== null, "load \u8FD4\u56DE null");
+        assertTrue(
+          got.businessKey === "BK_1",
+          `ALREADY_EXISTS \u4E4B\u540E\u539F\u8BB0\u5F55\u88AB\u8986\u76D6\uFF08businessKey \u5B9E\u5F97 ${show(got.businessKey)}\uFF09`
+        );
+        assertTrue(got.rev === 1, `\u5931\u8D25\u8DEF\u5F84\u4E0D\u5F97\u6D88\u8D39 rev\uFF08\u5B9E\u5F97 ${got.rev}\uFF09`);
+      }
+    ],
+    // ── CAS 路径 ──
+    [
+      "CAS \u6210\u529F\uFF1AexpectedRev \u547D\u4E2D \u2192 \u5199\u5165\u751F\u6548\u4E14 rev \u6070\u597D +1",
+      ["INV-1", "AC-E11"],
+      async () => {
+        const s = makeState(newId());
+        await store.save(s, 0);
+        await store.save({ ...s, businessKey: "BK_2" }, 1);
+        const got = await store.load(s.instanceId);
+        assertTrue(got !== null, "load \u8FD4\u56DE null");
+        assertTrue(got.rev === 2, `CAS \u540E rev \u5E94\u4E3A 2\uFF08\u5B9E\u5F97 ${got.rev}\uFF09`);
+        assertTrue(
+          got.businessKey === "BK_2",
+          `CAS \u5185\u5BB9\u672A\u751F\u6548\uFF08businessKey \u5B9E\u5F97 ${show(got.businessKey)}\uFF09`
+        );
+      }
+    ],
+    [
+      "CAS \u5931\u8D25\uFF08rev \u843D\u540E\uFF09\u629B PERSIST_CONFLICT\uFF0C\u4E14\u5E93\u5185 rev \u4E0E\u5185\u5BB9\u90FD\u4E0D\u53D8",
+      ["INV-1", "AC-E11"],
+      async () => {
+        const s = makeState(newId());
+        await store.save(s, 0);
+        await store.save({ ...s, businessKey: "BK_2" }, 1);
+        const err = await catchEngineError(
+          () => store.save({ ...s, businessKey: "BK_STALE" }, 1),
+          conflict,
+          "\u843D\u540E rev \u7684 CAS"
+        );
+        assertDeepEqual(err.details?.actualRev, 2, "details.actualRev");
+        const got = await store.load(s.instanceId);
+        assertTrue(got !== null, "load \u8FD4\u56DE null");
+        assertTrue(got.rev === 2, `CONFLICT \u540E rev \u4E0D\u5F97\u53D8\uFF08\u5B9E\u5F97 ${got.rev}\uFF09`);
+        assertTrue(
+          got.businessKey === "BK_2",
+          `CONFLICT \u540E\u5185\u5BB9\u4E0D\u5F97\u53D8\uFF08businessKey \u5B9E\u5F97 ${show(got.businessKey)}\uFF09`
+        );
+      }
+    ],
+    [
+      "CAS \u5931\u8D25\uFF08rev \u8D85\u524D\uFF09\u540C\u6837\u629B PERSIST_CONFLICT\uFF08\u4E0D\u5F97\u5F53\u6210\u6210\u529F\uFF09",
+      ["INV-1", "AC-E11"],
+      async () => {
+        const s = makeState(newId());
+        await store.save(s, 0);
+        const err = await catchEngineError(
+          () => store.save({ ...s, businessKey: "BK_AHEAD" }, 5),
+          conflict,
+          "\u8D85\u524D rev \u7684 CAS"
+        );
+        assertDeepEqual(err.details?.actualRev, 1, "details.actualRev");
+        const got = await store.load(s.instanceId);
+        assertTrue(got !== null, "load \u8FD4\u56DE null");
+        assertTrue(got.rev === 1, `CONFLICT \u540E rev \u4E0D\u5F97\u53D8\uFF08\u5B9E\u5F97 ${got.rev}\uFF09`);
+      }
+    ],
+    [
+      "\u5B9E\u4F8B\u4E0D\u5B58\u5728 + expectedRev > 0 \u2192 \u629B PERSIST_CONFLICT\uFF08\u4E14\u4E0D\u5EFA\u884C\u3001details \u65E0 actualRev\uFF09",
+      ["INV-1", "AC-E11"],
+      async () => {
+        const s = makeState(newId());
+        const err = await catchEngineError(
+          () => store.save(s, 3),
+          conflict,
+          "\u672A\u77E5\u5B9E\u4F8B\u7684 CAS"
+        );
+        assertTrue(
+          !("actualRev" in (err.details ?? {})),
+          `\u5B9E\u4F8B\u4E0D\u5B58\u5728\u65F6 details \u4E0D\u5E94\u5E26 actualRev\uFF08\u5B9E\u5F97 ${show(err.details)}\uFF09`
+        );
+        assertTrue(await store.load(s.instanceId) === null, "CONFLICT \u4E0D\u5F97\u987A\u5E26\u5EFA\u884C");
+      }
+    ],
+    [
+      "\u5E76\u53D1\u540C rev \u7684\u4E24\u4E2A save\uFF1A\u6070\u4E00\u80DC\u4E00\u8D25\uFF08CAS \u539F\u5B50\u6027\uFF0CNFR-E5\uFF09",
+      ["INV-1", "NFR-E5"],
+      async () => {
+        const s = makeState(newId());
+        await store.save(s, 0);
+        const results = await Promise.allSettled([
+          store.save({ ...s, businessKey: "A" }, 1),
+          store.save({ ...s, businessKey: "B" }, 1)
+        ]);
+        const won = results.filter((r) => r.status === "fulfilled").length;
+        const lost = results.filter((r) => r.status === "rejected").length;
+        assertTrue(
+          won === 1 && lost === 1,
+          `\u540C\u4E00 rev \u7684\u5E76\u53D1 save \u5FC5\u987B\u6070\u4E00\u80DC\u4E00\u8D25\uFF08\u5B9E\u5F97 ${won} \u80DC ${lost} \u8D25\uFF09\u2014\u2014 \u5168\u80DC = \u9759\u9ED8\u8986\u76D6`
+        );
+        const rejected = results.find((r) => r.status === "rejected");
+        assertTrue(rejected !== void 0, "\u6CA1\u6709\u5931\u8D25\u7684 save");
+        assertEngineErrorValue(rejected.reason, conflict, "\u5E76\u53D1 save \u7684\u8D25\u8005");
+        const got = await store.load(s.instanceId);
+        assertTrue(got !== null, "load \u8FD4\u56DE null");
+        assertTrue(got.rev === 2, `CAS \u53EA\u5E94\u53D1\u751F\u4E00\u6B21\uFF0Crev \u5E94\u4E3A 2\uFF08\u5B9E\u5F97 ${got.rev}\uFF09`);
+        const winner = results[0]?.status === "fulfilled" ? "A" : "B";
+        assertTrue(
+          got.businessKey === winner,
+          `\u5E93\u5185\u5E94\u4E3A\u80DC\u8005\u7684\u5185\u5BB9\uFF08\u671F\u671B ${winner}\uFF0C\u5B9E\u5F97 ${show(got.businessKey)}\uFF09`
+        );
+      }
+    ],
+    // ── 写入前置校验 ──
+    [
+      "\u5199\u5165\u975E\u7EAF\u6570\u636E\u5FC5\u987B\u629B\u9519\uFF0C\u4E14\u4E0D\u6C61\u67D3\u5E93\uFF08AC-E8 / INV-14\uFF09",
+      ["AC-E8", "INV-14"],
+      async () => {
+        const s = makeState(newId());
+        const dirty = { ...s, variables: { bad: () => 1 } };
+        await catchEngineError(() => store.save(dirty, 0), "ENGINE_STATE_SHAPE_INVALID", "\u5199\u5165\u542B\u51FD\u6570\u7684 state");
+        assertTrue(
+          await store.load(s.instanceId) === null,
+          "\u810F\u6570\u636E\u4E0D\u5F97\u5165\u5E93\uFF1A\u5199\u5165\u524D\u5C31\u8BE5\u62D2\u7EDD\uFF0C\u800C\u4E0D\u662F\u8BA9\u5E93\u91CC\u51FA\u73B0\u975E\u7EAF\u6570\u636E"
+        );
+      }
+    ]
+  ]);
+}
+
+// src/conformance/projection.ts
+var TS2 = "2026-09-30T00:00:00.000Z";
+var seq2 = 0;
+function uniqueId2(prefix) {
+  seq2 += 1;
+  return `${prefix}_p${seq2.toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function header(instanceId, rev) {
+  return {
+    instanceId,
+    processId: "expense",
+    definitionVersion: 1,
+    status: "running",
+    rev,
+    stateSchema: STATE_SCHEMA_VERSION,
+    startedAt: TS2,
+    updatedAt: TS2
+  };
+}
+function task(args) {
+  return {
+    taskId: args.taskId,
+    instanceId: args.instanceId,
+    nodeId: args.nodeId ?? "Task_Approve",
+    assignee: args.assignee ?? "u_1",
+    status: args.status ?? "active",
+    createdAt: TS2
+  };
+}
+function delta(instanceId, over = {}) {
+  const rev = over.rev ?? 1;
+  return {
+    rev,
+    action: over.action ?? { name: "approve", actor: "u_1", at: TS2 },
+    added: over.added ?? [],
+    removed: over.removed ?? [],
+    changed: over.changed ?? [],
+    instance: header(instanceId, rev)
+  };
+}
+function index(tasks) {
+  return new Map(tasks.map((t) => [t.taskId, t]));
+}
+function assertSameTask(actual, expected, what) {
+  assertTrue(actual !== void 0, `${what}\uFF1AtaskId=${expected.taskId} \u8BFB\u4E0D\u56DE\u6765\uFF08\u53EF\u80FD\u88AB\u8BEF\u5F53\u6210 removed\uFF1F\uFF09`);
+  assertDeepEqual(
+    {
+      taskId: actual.taskId,
+      instanceId: actual.instanceId,
+      nodeId: actual.nodeId,
+      assignee: actual.assignee,
+      status: actual.status,
+      createdAt: actual.createdAt
+    },
+    {
+      taskId: expected.taskId,
+      instanceId: expected.instanceId,
+      nodeId: expected.nodeId,
+      assignee: expected.assignee,
+      status: expected.status,
+      createdAt: expected.createdAt
+    },
+    what
+  );
+}
+function assertRows(actual, expected, what) {
+  const got = index(actual);
+  const want = index(expected);
+  assertDeepEqual(
+    [...got.keys()].sort(),
+    [...want.keys()].sort(),
+    `${what}\uFF08\u53EF\u89C1 taskId \u96C6\u5408\uFF09`
+  );
+  for (const t of want.values()) assertSameTask(got.get(t.taskId), t, what);
+}
+async function runProjectionConformance(projection, readback, options = {}) {
+  const prefix = options.idPrefix ?? "floken-conf";
+  const newId = () => uniqueId2(prefix);
+  return runConformanceCases("projection", options.subject, [
+    [
+      "apply \u589E\u884C\uFF1Aadded \u6BCF\u884C\u90FD\u80FD\u6309 taskId \u8BFB\u56DE\uFF0C\u5FC5\u586B\u5B57\u6BB5\u4E00\u81F4",
+      ["\xA77.2"],
+      async () => {
+        const id = newId();
+        const a = task({ instanceId: id, taskId: "T_a", assignee: "u_1" });
+        const b = task({ instanceId: id, taskId: "T_b", assignee: "u_2" });
+        await projection.apply(id, delta(id, { added: [a, b] }));
+        assertRows(await readback(id), [a, b], "apply \u540E\u7684\u5F85\u529E");
+      }
+    ],
+    [
+      "apply \u5E42\u7B49\uFF1A\u540C\u4E00 delta \u8FDE\u7EED\u4E24\u6B21 \u2192 \u5F85\u529E\u96C6\u5408\u4E0D\u53D8\uFF08AC-E12\uFF09",
+      ["AC-E12", "INV-15"],
+      async () => {
+        const id = newId();
+        const a = task({ instanceId: id, taskId: "T_a" });
+        const b = task({ instanceId: id, taskId: "T_b" });
+        const d = delta(id, { added: [a, b] });
+        const before = JSON.stringify(d);
+        await projection.apply(id, d);
+        const once = await readback(id);
+        await projection.apply(id, d);
+        const twice = await readback(id);
+        assertRows(once, [a, b], "\u9996\u6B21 apply");
+        assertRows(twice, [a, b], "\u91CD\u590D apply");
+        assertDeepEqual(twice.length, once.length, "\u91CD\u590D apply \u540E\u7684\u884C\u6570\uFF08\u4E0D\u5F97\u7FFB\u500D\uFF09");
+        assertTrue(JSON.stringify(d) === before, "\u6295\u5F71\u4E0D\u5F97\u4FEE\u6539\u4F20\u5165\u7684 delta\uFF08\u5E94\u89C6\u4E3A\u53EA\u8BFB\uFF09");
+      }
+    ],
+    [
+      "apply \u771F\u5220\uFF1Aremoved \u91CC\u7684 taskId \u5FC5\u987B\u67E5\u4E0D\u5230\uFF08INV-15 \xB7 \u5934\u53F7\u9759\u9ED8\u9519\u8BEF\uFF09",
+      ["INV-15", "AC-E12"],
+      async () => {
+        const id = newId();
+        const a = task({ instanceId: id, taskId: "T_a" });
+        const b = task({ instanceId: id, taskId: "T_b" });
+        await projection.apply(id, delta(id, { added: [a, b] }));
+        await projection.apply(id, delta(id, { rev: 2, removed: ["T_a"] }));
+        const rows = await readback(id);
+        assertTrue(
+          !index(rows).has("T_a"),
+          `removed \u91CC\u7684 taskId \u4ECD\u80FD\u8BFB\u5230 \u2014\u2014 \u6295\u5F71\u6CA1\u5B9E\u73B0\u771F\u5220\uFF08\u8BFB\u56DE ${show(rows.map((t) => t.taskId))}\uFF09`
+        );
+        assertRows(rows, [b], "\u5220\u9664\u540E\u7684\u5F85\u529E");
+      }
+    ],
+    [
+      "\u540C\u4E00 delta \u5185 added \u4E0E removed \u5E76\u5B58\uFF1A\u4E24\u8005\u90FD\u751F\u6548",
+      ["INV-15"],
+      async () => {
+        const id = newId();
+        const oldTask = task({ instanceId: id, taskId: "T_old" });
+        await projection.apply(id, delta(id, { added: [oldTask] }));
+        const fresh = task({ instanceId: id, taskId: "T_new", assignee: "u_9" });
+        await projection.apply(
+          id,
+          delta(id, { rev: 2, added: [fresh], removed: ["T_old"] })
+        );
+        assertRows(await readback(id), [fresh], "\u6DF7\u5408 delta \u540E\u7684\u5F85\u529E");
+      }
+    ],
+    [
+      "changed \u751F\u6548\uFF1A\u72B6\u6001\u88AB\u66F4\u65B0\uFF0C\u800C\u4E0D\u662F\u88AB\u5FFD\u7565",
+      ["\xA77.2", "AC-E12"],
+      async () => {
+        const id = newId();
+        const active = task({ instanceId: id, taskId: "T_a", status: "active" });
+        await projection.apply(id, delta(id, { added: [active] }));
+        const done = { ...active, status: "done" };
+        await projection.apply(id, delta(id, { rev: 2, changed: [done] }));
+        assertRows(await readback(id), [done], "changed \u540E\u7684\u5F85\u529E");
+      }
+    ],
+    [
+      "\u7A7A delta\uFF1A\u4E0D\u5F97\u4EA7\u751F\u4EFB\u4F55\u526F\u4F5C\u7528",
+      ["\xA76.2"],
+      async () => {
+        const id = newId();
+        const a = task({ instanceId: id, taskId: "T_a" });
+        await projection.apply(id, delta(id, { added: [a] }));
+        const before = await readback(id);
+        await projection.apply(id, delta(id, { rev: 2 }));
+        assertRows(await readback(id), before, "\u7A7A delta \u540E\u7684\u5F85\u529E");
+      }
+    ],
+    [
+      "sync \u5168\u91CF\u5BF9\u8D26\uFF1A\u8BFB\u56DE\u4E0E\u4F20\u5165 tasks \u4E00\u81F4\uFF0C\u591A\u4F59\u884C\u88AB\u6E05\u7406\uFF08INV-18\uFF09",
+      ["INV-18"],
+      async () => {
+        const id = newId();
+        await projection.apply(
+          id,
+          delta(id, {
+            added: [
+              task({ instanceId: id, taskId: "T_stale1" }),
+              task({ instanceId: id, taskId: "T_stale2" })
+            ]
+          })
+        );
+        const truth = task({ instanceId: id, taskId: "T_truth", assignee: "u_7" });
+        await projection.sync(id, [truth]);
+        assertRows(
+          await readback(id),
+          [truth],
+          'sync \u540E\u7684\u5F85\u529E\uFF08"\u5168\u91CF\u5BF9\u8D26"= \u4EE5\u4F20\u5165\u5217\u8868\u4E3A\u51C6\uFF1A\u591A\u4F59\u884C\u5FC5\u987B\u6E05\u6389\uFF0C\u5426\u5219\u8865\u505A\u7B49\u4E8E\u6CA1\u505A\uFF09'
+        );
+      }
+    ],
+    [
+      "sync \u4F20\u7A7A\u6570\u7EC4 \u2192 \u8BE5\u5B9E\u4F8B\u5F85\u529E\u6E05\u7A7A",
+      ["INV-18"],
+      async () => {
+        const id = newId();
+        await projection.apply(id, delta(id, { added: [task({ instanceId: id, taskId: "T_a" })] }));
+        await projection.sync(id, []);
+        assertRows(await readback(id), [], "sync \u7A7A\u5217\u8868\u540E\u7684\u5F85\u529E");
+      }
+    ],
+    [
+      "\u8DE8\u5B9E\u4F8B\u9694\u79BB\uFF1Aapply \u4E00\u4E2A\u5B9E\u4F8B\u4E0D\u5F97\u5F71\u54CD\u53E6\u4E00\u4E2A",
+      ["\xA77.2"],
+      async () => {
+        const idA = newId();
+        const idB = newId();
+        const a = task({ instanceId: idA, taskId: "T_a" });
+        const b = task({ instanceId: idB, taskId: "T_b" });
+        await projection.apply(idA, delta(idA, { added: [a] }));
+        await projection.apply(idB, delta(idB, { added: [b] }));
+        assertRows(await readback(idA), [a], "\u5B9E\u4F8B A \u7684\u5F85\u529E");
+        assertRows(await readback(idB), [b], "\u5B9E\u4F8B B \u7684\u5F85\u529E");
+      }
+    ]
+  ]);
+}
+
+// src/conformance/definition.ts
+var UNKNOWN_PROCESS_ID = "__floken_conf_no_such_process__";
+async function runDefinitionConformance(source, fixtures, options = {}) {
+  const byProcess = /* @__PURE__ */ new Map();
+  for (const f of fixtures) {
+    const list = byProcess.get(f.processId);
+    if (list === void 0) byProcess.set(f.processId, [f]);
+    else list.push(f);
+  }
+  const multi = [...byProcess.values()].filter((l) => l.length >= 2);
+  function requirePair() {
+    const first = multi[0];
+    if (first === void 0) {
+      throw new Error(
+        `fixtures \u4E0D\u5408\u6CD5\uFF1A\u987B\u542B\u540C\u4E00 processId \u7684 \u22652 \u4E2A\u7248\u672C\uFF08\u5B9E\u5F97 ${fixtures.length} \u6761 / ${byProcess.size} \u4E2A processId\uFF09`
+      );
+    }
+    return first;
+  }
+  return runConformanceCases("definition", options.subject, [
+    // ── 输入自检（套件不会对自己的输入装瞎） ──
+    [
+      "fixtures \u81EA\u68C0\uFF1A\u987B\u542B\u540C\u4E00 processId \u7684 \u22652 \u4E2A\u7248\u672C\uFF0C\u4E14\u5185\u5BB9\u4E92\u4E0D\u76F8\u540C",
+      ["\xA77.2"],
+      async () => {
+        const first = requirePair();
+        for (let i = 0; i < first.length; i += 1) {
+          for (let j = i + 1; j < first.length; j += 1) {
+            const a = first[i];
+            const b = first[j];
+            assertTrue(
+              a !== void 0 && b !== void 0 && !deepEqual(a.definition, b.definition),
+              `fixtures \u91CC ${a?.processId}@${a?.version} \u4E0E @${b?.version} \u5185\u5BB9\u76F8\u540C \u2014\u2014 \u7248\u672C\u95F4\u5FC5\u987B\u6709\u5DEE\u5F02\uFF0C\u5426\u5219\u300C\u5FFD\u7565 version\u300D\u65E0\u6CD5\u88AB\u89C2\u6D4B`
+            );
+          }
+        }
+      }
+    ],
+    // ── ① 版本精确命中 ──
+    [
+      "\u9010\u7248\u672C\u7CBE\u786E\u547D\u4E2D\uFF1AgetDefinition(pid, v) \u53D6\u56DE\u7684\u5185\u5BB9\u4E0E\u5BBF\u4E3B\u58F0\u660E\u7684\u6DF1\u7B49",
+      ["\xA77.2", "AC-E10"],
+      async () => {
+        for (const f of fixtures) {
+          const got = await source.getDefinition(f.processId, f.version);
+          assertTrue(
+            got !== null,
+            `${f.processId}@${f.version} \u53D6\u56DE null\uFF08\u5BBF\u4E3B\u58F0\u660E\u4E86\u8FD9\u4E00\u683C\uFF0C\u5B9E\u73B0\u5374\u8BF4\u6CA1\u6709\uFF09`
+          );
+          assertDeepEqual(got, f.definition, `${f.processId}@${f.version} \u7684\u5185\u5BB9`);
+        }
+      }
+    ],
+    // ── ★ 头号目标：version 必须真的被用上 ──
+    [
+      "\u2605 \u540C\u4E00 processId \u7684\u4E0D\u540C version \u8FD4\u56DE\u4E0D\u540C\u5185\u5BB9\uFF08\u9632\u300C\u5FFD\u7565 version \u53C2\u6570\u300D\u7684\u9759\u9ED8\u9519\u8BEF\uFF09",
+      ["AC-E10", "INV-19"],
+      async () => {
+        const group = requirePair();
+        for (let i = 0; i < group.length; i += 1) {
+          for (let j = i + 1; j < group.length; j += 1) {
+            const a = group[i];
+            const b = group[j];
+            assertTrue(a !== void 0 && b !== void 0, "fixtures \u7F3A\u5931");
+            const ga = await source.getDefinition(a.processId, a.version);
+            const gb = await source.getDefinition(b.processId, b.version);
+            assertTrue(
+              !deepEqual(ga, gb),
+              `${a.processId}@${a.version} \u4E0E @${b.version} \u53D6\u56DE\u4E86\u76F8\u540C\u5185\u5BB9 \u2014\u2014 getDefinition \u591A\u534A\u5FFD\u7565\u4E86 version \u53C2\u6570\uFF08\u5728\u9014\u5B9E\u4F8B\u4F1A\u8DD1\u5230\u53D1\u8D77\u65F6\u4E0D\u5B58\u5728\u7684\u8282\u70B9\u4E0A\uFF09`
+            );
+          }
+        }
+      }
+    ],
+    // ── ② 不存在 = null（不得抛、不得回退） ──
+    [
+      `\u672A\u77E5 processId \u2192 null\uFF08\u4E0D\u5F97\u629B\u9519\uFF0C\u4E5F\u4E0D\u5F97\u8FD4\u56DE\u4EFB\u4E00\u5DF2\u6709\u7248\u672C\uFF09`,
+      ["\xA77.2"],
+      async () => {
+        const got = await source.getDefinition(UNKNOWN_PROCESS_ID, 1);
+        assertTrue(
+          got === null,
+          `\u672A\u77E5 processId \u671F\u671B null\uFF0C\u5B9E\u5F97 ${show(got)} \u2014\u2014 \u8FD4\u56DE\u4EFB\u4E00\u7248\u672C\u4F1A\u8BA9\u5F15\u64CE\u62FF\u5230\u9519\u8BEF\u7684\u56FE\u7EB8`
+        );
+      }
+    ],
+    [
+      "\u2605 \u672A\u77E5 version \u2192 null\uFF08\u4E0D\u5F97\u56DE\u9000\u5230\u6700\u65B0\u7248 / \u4EFB\u4E00\u5DF2\u6709\u7248\u672C\uFF09",
+      ["AC-E10", "INV-19"],
+      async () => {
+        const group = requirePair();
+        const versions = group.map((f) => f.version);
+        const max = Math.max(...versions);
+        const min = Math.min(...versions);
+        const probes = [max + 1, ...min > 1 ? [min - 1] : []];
+        for (const v of probes) {
+          const got = await source.getDefinition(group[0]?.processId ?? "", v);
+          assertTrue(
+            got === null,
+            `@${v} \u671F\u671B null\uFF08\u8FD9\u4E00\u7248\u4E0D\u5B58\u5728\uFF09\uFF0C\u5B9E\u5F97 ${show(got)} \u2014\u2014 \u56DE\u9000\u5230\u522B\u7684\u7248\u672C = \u5728\u9014\u5B9E\u4F8B\u88AB\u9759\u9ED8\u6362\u6210\u53E6\u4E00\u5957\u56FE\u7EB8`
+          );
+        }
+      }
+    ],
+    // ── ③ 取回不得有副作用 / 不得交共享可变对象 ──
+    [
+      "\u91CD\u590D\u53D6\u56DE\u540C\u4E00 (pid, v) \u5185\u5BB9\u4E0D\u53D8\uFF1B\u53D6\u8FC7\u522B\u7684\u7248\u672C\u540E\u56DE\u6765\u4ECD\u4E0D\u53D8\uFF08\u4E0D\u5F97\u4EA4\u51FA\u4F1A\u88AB\u540E\u7EED\u8C03\u7528\u8986\u76D6\u7684\u5BF9\u8C61\uFF09",
+      ["AC-E10"],
+      async () => {
+        const f = fixtures[0];
+        assertTrue(f !== void 0, "fixtures \u4E3A\u7A7A");
+        const first = await source.getDefinition(f.processId, f.version);
+        assertDeepEqual(first, f.definition, `\u9996\u6B21\u53D6\u56DE ${f.processId}@${f.version}`);
+        const other = fixtures[fixtures.length - 1];
+        if (other !== void 0) await source.getDefinition(other.processId, other.version);
+        const again = await source.getDefinition(f.processId, f.version);
+        assertDeepEqual(
+          again,
+          f.definition,
+          `\u518D\u6B21\u53D6\u56DE ${f.processId}@${f.version}\uFF08\u53D6\u8FC7\u522B\u7684\u7248\u672C\u540E\uFF0C\u5185\u5BB9\u88AB\u6539\u5199\u4E86\uFF09`
+        );
+      }
+    ],
+    // ── ④ 异常入参不得炸（引擎已保证 ≥1 整数，宿主只需返回 null） ──
+    [
+      "\u975E\u6CD5 version\uFF080 / -1 / \u5C0F\u6570 / NaN\uFF09\u2192 null \u4E14\u4E0D\u5F97\u629B\u9519\uFF08\u9632\u300C\u5C31\u8FD1\u53D6\u6574\u300D\uFF09",
+      ["\xA77.2"],
+      async () => {
+        const f = fixtures[0];
+        assertTrue(f !== void 0, "fixtures \u4E3A\u7A7A");
+        for (const bad of [0, -1, 1.5, Number.NaN]) {
+          const got = await source.getDefinition(f.processId, bad);
+          assertTrue(
+            got === null,
+            `version=${bad} \u671F\u671B null\uFF0C\u5B9E\u5F97 ${show(got)} \u2014\u2014 \u5C31\u8FD1\u53D6\u6574\u4F1A\u8BA9 v1.5 \u9759\u9ED8\u8DD1\u6210\u522B\u7684\u7248\u672C`
+          );
+        }
+      }
+    ]
+  ]);
+}
+
+export { formatConformanceReport, runDefinitionConformance, runProjectionConformance, runStoreConformance };