@joekytc/dsh-swarm 0.1.2 → 0.3.0

package/skills/llm-wiki-skill/packages/graph-engine/test/graph-layout.test.ts

@@ -0,0 +1,110 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import { normalizeGraphLayoutFile, normalizeGraphPinMap } from "../src";
+import * as graphEngine from "../src";
+
+describe("graph layout normalization", () => {
+  it("marks unlabelled version 1 pins as legacy percent coordinates", () => {
+    assert.deepEqual(normalizeGraphLayoutFile({
+      version: 1,
+      pins: {
+        "wiki/old.md": { x: 80, y: 50 },
+        "wiki/world.md": { x: 8, y: -12, coordinateSpace: "world" },
+        "../unsafe.md": { x: 1, y: 2 }
+      },
+      updatedAt: "2026-06-16T00:00:00.000Z"
+    }), {
+      version: 2,
+      pins: {
+        "wiki/old.md": { x: 80, y: 50, coordinateSpace: "legacy-percent" },
+        "wiki/world.md": { x: 8, y: -12, coordinateSpace: "world" }
+      },
+      updatedAt: "2026-06-16T00:00:00.000Z"
+    });
+  });
+
+  it("treats unlabelled current pins as world coordinates", () => {
+    assert.deepEqual(normalizeGraphLayoutFile({
+      version: 2,
+      pins: {
+        "wiki/current.md": { x: 8, y: 12 },
+        "wiki/bad-space.md": { x: 1, y: 2, coordinateSpace: "screen" },
+        "/absolute.md": { x: 3, y: 4 },
+        "wiki/invalid.md": { x: "nope", y: 4 }
+      }
+    }), {
+      version: 2,
+      pins: {
+        "wiki/current.md": { x: 8, y: 12, coordinateSpace: "world" },
+        "wiki/bad-space.md": { x: 1, y: 2, coordinateSpace: "world" }
+      },
+      updatedAt: ""
+    });
+  });
+
+  it("preserves explicit world pins far outside the current viewport", () => {
+    assert.deepEqual(normalizeGraphLayoutFile({
+      version: 2,
+      pins: {
+        "wiki/valid.md": { x: 412.5, y: -88.2, coordinateSpace: "world" },
+        "wiki/far-away.md": { x: 284015.9548304589, y: 47155.27885437255, coordinateSpace: "world" },
+        "wiki/legacy-percent.md": { x: 80, y: 50, coordinateSpace: "legacy-percent" }
+      }
+    }), {
+      version: 2,
+      pins: {
+        "wiki/valid.md": { x: 412.5, y: -88.2, coordinateSpace: "world" },
+        "wiki/far-away.md": { x: 284015.9548304589, y: 47155.27885437255, coordinateSpace: "world" },
+        "wiki/legacy-percent.md": { x: 80, y: 50, coordinateSpace: "legacy-percent" }
+      },
+      updatedAt: ""
+    });
+  });
+
+  it("drops implausibly distant explicit world pins only at broken-data scale", () => {
+    assert.deepEqual(normalizeGraphLayoutFile({
+      version: 2,
+      pins: {
+        "wiki/valid-world.md": { x: 284015.9548304589, y: 47155.27885437255, coordinateSpace: "world" },
+        "wiki/broken-world.md": { x: 1000001, y: 42, coordinateSpace: "world" }
+      }
+    }), {
+      version: 2,
+      pins: {
+        "wiki/valid-world.md": { x: 284015.9548304589, y: 47155.27885437255, coordinateSpace: "world" }
+      },
+      updatedAt: ""
+    });
+  });
+
+  it("drops implausibly distant legacy percent pins before migration", () => {
+    assert.deepEqual(normalizeGraphLayoutFile({
+      version: 1,
+      pins: {
+        "wiki/valid-percent.md": { x: 80, y: 50 },
+        "wiki/far-percent.md": { x: 284015.9548304589, y: 47155.27885437255 }
+      }
+    }), {
+      version: 2,
+      pins: {
+        "wiki/valid-percent.md": { x: 80, y: 50, coordinateSpace: "legacy-percent" }
+      },
+      updatedAt: ""
+    });
+  });
+
+  it("normalizes stored pins without applying layout-key safety", () => {
+    assert.deepEqual(normalizeGraphPinMap({
+      "/fake/wiki/entities/A.md": { x: 332.5, y: 240.25 },
+      "wiki/legacy.md": { x: 13, y: 50, coordinateSpace: "legacy-percent" }
+    }), {
+      "/fake/wiki/entities/A.md": { x: 332.5, y: 240.25, coordinateSpace: "world" },
+      "wiki/legacy.md": { x: 13, y: 50, coordinateSpace: "legacy-percent" }
+    });
+  });
+
+  it("does not expose layout key policy as part of the public root API", () => {
+    assert.equal("isSafeGraphLayoutPinKey" in graphEngine, false);
+  });
+});

package/skills/llm-wiki-skill/packages/graph-engine/test/helpers.test.ts

@@ -0,0 +1,287 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+  splitLabelGraphemes,
+  labelCharWidth,
+  measureLabelWidth,
+  truncateLabel,
+  cardDims,
+  createSafeStorage
+} from "../src/model";
+
+const LABEL_CJK_WIDTH = 15;
+const LABEL_LATIN_WIDTH = 8.5;
+const LABEL_MIN_WIDTH = 72;
+const LABEL_MAX_WIDTH = 180;
+const LABEL_ELLIPSIS = "…";
+async function loadHelpersWithoutSegmenter() {
+  const originalIntl = globalThis.Intl;
+  Object.defineProperty(globalThis, "Intl", { value: {}, configurable: true });
+  try {
+    return await import(`../src/model/legacy-helpers.ts?fallback=${Date.now()}`);
+  } finally {
+    Object.defineProperty(globalThis, "Intl", { value: originalIntl, configurable: true });
+  }
+}
+
+// --- splitLabelGraphemes ---
+
+describe("splitLabelGraphemes", () => {
+  it("splits empty string", () => {
+    assert.deepEqual(splitLabelGraphemes(""), []);
+  });
+
+  it("splits ASCII", () => {
+    assert.deepEqual(splitLabelGraphemes("abc"), ["a", "b", "c"]);
+  });
+
+  it("splits CJK characters", () => {
+    assert.deepEqual(splitLabelGraphemes("中文"), ["中", "文"]);
+  });
+
+  it("does not corrupt emoji with surrogate pairs", () => {
+    const result = splitLabelGraphemes("a👨‍👩‍👧‍👦b");
+    assert.ok(result.includes("👨‍👩‍👧‍👦"), "family emoji kept as single grapheme");
+    assert.equal(result[0], "a");
+    assert.equal(result[result.length - 1], "b");
+  });
+
+  it("does not corrupt surrogate pairs", () => {
+    const result = splitLabelGraphemes("𠮷");
+    // Whether it's 1 grapheme (with Intl.Segmenter) or split into code points,
+    // the result must not contain unmatched surrogate halves
+    assert.ok(!/[\uD800-\uDBFF](?![\uDC00-\uDFFF])/.test(result.join("")));
+  });
+
+  it("falls back when Intl.Segmenter is unavailable", async () => {
+    const fallbackHelpers = await loadHelpersWithoutSegmenter();
+
+    assert.deepEqual(Array.from(fallbackHelpers.splitLabelGraphemes("abc")), ["a", "b", "c"]);
+    assert.deepEqual(Array.from(fallbackHelpers.splitLabelGraphemes("中文")), ["中", "文"]);
+    assert.deepEqual(Array.from(fallbackHelpers.splitLabelGraphemes("👨‍👩‍👧‍👦")), ["👨‍👩‍👧‍👦"]);
+
+    const truncated = fallbackHelpers.truncateLabel("节点A👨‍👩‍👧‍👦AlphaBeta超长标签" + "超".repeat(20), 120);
+    assert.equal(truncated.truncated, true);
+    assert.ok(truncated.text.endsWith(LABEL_ELLIPSIS));
+    assert.ok(
+      !/\uD800(?![\uDC00-\uDFFF])|(?:^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(truncated.text),
+      "fallback path keeps surrogate pairs intact"
+    );
+
+    const emojiBoundary = fallbackHelpers.truncateLabel("节点A👨‍👩‍👧‍👦AlphaBeta超长标签" + "超".repeat(20), 90);
+    assert.ok(emojiBoundary.text.endsWith(LABEL_ELLIPSIS));
+    assert.ok(
+      !emojiBoundary.text.startsWith("‍") && !emojiBoundary.text.includes("‍" + LABEL_ELLIPSIS),
+      "fallback path should not cut through a ZWJ sequence"
+    );
+    assert.ok(
+      !emojiBoundary.text.includes("👨‍") || emojiBoundary.text.includes("👨‍👩‍👧‍👦"),
+      "fallback path should keep the family emoji intact if it is included"
+    );
+  });
+});
+
+// --- labelCharWidth ---
+
+describe("labelCharWidth", () => {
+  it("returns CJK width for CJK character", () => {
+    assert.equal(labelCharWidth("中"), LABEL_CJK_WIDTH);
+  });
+
+  it("returns Latin width for Latin character", () => {
+    assert.equal(labelCharWidth("a"), LABEL_LATIN_WIDTH);
+  });
+
+  it("returns Latin width for digit", () => {
+    assert.equal(labelCharWidth("5"), LABEL_LATIN_WIDTH);
+  });
+
+  it("returns Latin width for punctuation", () => {
+    assert.equal(labelCharWidth("-"), LABEL_LATIN_WIDTH);
+  });
+});
+
+// --- measureLabelWidth ---
+
+describe("measureLabelWidth", () => {
+  it("returns 0 for empty array", () => {
+    assert.equal(measureLabelWidth([]), 0);
+  });
+
+  it("returns correct width for single grapheme", () => {
+    assert.equal(measureLabelWidth(["a"]), LABEL_LATIN_WIDTH);
+  });
+
+  it("sums mixed CJK and Latin widths", () => {
+    const width = measureLabelWidth(["中", "a", "文"]);
+    assert.equal(width, LABEL_CJK_WIDTH * 2 + LABEL_LATIN_WIDTH);
+  });
+});
+
+// --- truncateLabel ---
+
+describe("truncateLabel", () => {
+  it("handles empty string", () => {
+    const r = truncateLabel("", 100);
+    assert.equal(r.text, "");
+    assert.equal(r.truncated, false);
+  });
+
+  it("handles null", () => {
+    const r = truncateLabel(null, 100);
+    assert.equal(r.text, "");
+    assert.equal(r.truncated, false);
+  });
+
+  it("handles undefined", () => {
+    const r = truncateLabel(undefined, 100);
+    assert.equal(r.text, "");
+    assert.equal(r.truncated, false);
+  });
+
+  it("does not truncate short label", () => {
+    const r = truncateLabel("短标签", 120);
+    assert.equal(r.truncated, false);
+    assert.equal(r.text, "短标签");
+  });
+
+  it("truncates long label with ellipsis", () => {
+    const longLabel = "超".repeat(30);
+    const r = truncateLabel(longLabel, 100);
+    assert.equal(r.truncated, true);
+    assert.ok(r.text.endsWith(LABEL_ELLIPSIS));
+  });
+
+  it("does not corrupt emoji when truncating", () => {
+    const r = truncateLabel("节点A👨‍👩‍👧‍👦AlphaBeta超长标签" + "超".repeat(20), 120);
+    assert.equal(r.truncated, true);
+    assert.ok(!r.text.includes("undefined"));
+    assert.ok(
+      !/\uD800(?![\uDC00-\uDFFF])|(?:^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(r.text),
+      "no unmatched surrogate halves"
+    );
+  });
+
+  it("handles CJK + Latin mix", () => {
+    const r = truncateLabel("中文English混合标签" + "超".repeat(20), 120);
+    assert.equal(r.truncated, true);
+    assert.ok(r.text.endsWith(LABEL_ELLIPSIS));
+  });
+
+  it("respects maxWidth exactly at boundary", () => {
+    const label = "a".repeat(10);
+    const r = truncateLabel(label, 1000);
+    assert.equal(r.truncated, false);
+    assert.equal(r.text, label);
+  });
+});
+
+// --- cardDims ---
+
+describe("cardDims", () => {
+  it("returns dimensions for short label", () => {
+    const r = cardDims({ id: "1", label: "短", type: "entity" });
+    assert.ok(r.w >= LABEL_MIN_WIDTH);
+    assert.ok(r.w <= LABEL_MAX_WIDTH);
+    assert.equal(r.h, 36);
+  });
+
+  it("caps width at LABEL_MAX_WIDTH for long label", () => {
+    const r = cardDims({ id: "1", label: "超".repeat(30), type: "entity" });
+    assert.equal(r.w, LABEL_MAX_WIDTH);
+  });
+
+  it("enforces LABEL_MIN_WIDTH for empty label", () => {
+    const r = cardDims({ id: "1", label: "", type: "entity" });
+    assert.equal(r.w, LABEL_MIN_WIDTH);
+  });
+
+  it("taller for topic type", () => {
+    const r = cardDims({ id: "1", label: "T", type: "topic" });
+    assert.equal(r.h, 40);
+  });
+
+  it("shorter for source type", () => {
+    const r = cardDims({ id: "1", label: "S", type: "source" });
+    assert.equal(r.h, 32);
+  });
+
+  it("returns dimensions for generic entity", () => {
+    const r = cardDims({ id: "1", label: "X", type: "entity" });
+    assert.ok(r.w > 0);
+    assert.ok(r.h > 0);
+  });
+});
+
+// --- module export ---
+
+describe("module export", () => {
+  it("exports helpers from the model entry", async () => {
+    const model = await import("../src/model");
+
+    assert.equal(typeof model.truncateLabel, "function");
+    assert.equal(typeof model.cardDims, "function");
+    assert.equal(typeof model.createSafeStorage, "function");
+  });
+
+  it("keeps legacy renderer exports available from the package entry", async () => {
+    const entry = await import("../src");
+    const render = await import("../src/render");
+
+    assert.equal(typeof entry.createGraphRenderer, "function");
+    assert.equal(entry.createStaticGraphRenderer, entry.createGraphRenderer);
+    assert.equal(typeof entry.createStaticGraphRenderer, "function");
+    assert.equal(typeof render.createGraphRenderer, "function");
+    assert.equal(render.createStaticGraphRenderer, render.createGraphRenderer);
+    assert.equal(typeof render.createStaticGraphRenderer, "function");
+  });
+});
+
+// --- createSafeStorage ---
+
+describe("createSafeStorage", () => {
+  it("gets and sets normally", () => {
+    const store = {};
+    const storage = createSafeStorage({
+      getItem: (k) => store[k],
+      setItem: (k, v) => { store[k] = v; }
+    });
+    storage.set("k", "v");
+    assert.equal(storage.get("k"), "v");
+  });
+
+  it("returns null when get throws", () => {
+    const logs = [];
+    const storage = createSafeStorage({
+      getItem: () => { throw new Error("boom"); },
+      setItem: () => {}
+    }, (...args) => logs.push(args));
+    assert.equal(storage.get("k"), null);
+    assert.equal(logs.length, 1);
+  });
+
+  it("swallows set errors", () => {
+    const logs = [];
+    const storage = createSafeStorage({
+      getItem: () => null,
+      setItem: () => { throw new Error("boom"); }
+    }, (...args) => logs.push(args));
+    storage.set("k", "v");
+    assert.equal(logs.length, 1);
+  });
+
+  it("handles null logger", () => {
+    const storage = createSafeStorage({
+      getItem: () => { throw new Error("boom"); },
+      setItem: () => { throw new Error("boom"); }
+    }, null);
+    assert.equal(storage.get("k"), null);
+    storage.set("k", "v");
+  });
+
+  it("handles null storage", () => {
+    const storage = createSafeStorage(null, null);
+    assert.equal(storage.get("k"), null);
+    storage.set("k", "v");
+  });
+});

package/skills/llm-wiki-skill/packages/graph-engine/test/interaction-contract.test.ts

@@ -0,0 +1,106 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  classifyGraphEventTarget,
+  classifyGraphPointerDownTarget,
+  classifyGraphPointerDownTargetFromGraphTarget,
+  classifyGraphWheelTargetFromGraphTarget,
+  createGraphSpatialIndex,
+  graphSpatialHitToGestureTarget,
+  type GraphGestureTargetLike
+} from "../src";
+
+class FakeTarget implements GraphGestureTargetLike {
+  readonly dataset: Record<string, string | undefined>;
+  private readonly matchesBySelector = new Map<string, FakeTarget | null>();
+
+  constructor(options: { dataset?: Record<string, string | undefined>; closest?: Record<string, FakeTarget | null> } = {}) {
+    this.dataset = options.dataset || {};
+    for (const [selector, target] of Object.entries(options.closest || {})) {
+      this.matchesBySelector.set(selector, target);
+    }
+  }
+
+  closest(selector: string): GraphGestureTargetLike | null {
+    return this.matchesBySelector.get(selector) || null;
+  }
+}
+
+describe("graph interaction contract", () => {
+  it("lets SpatialIndex, not DOM stacking order, choose the graph object intent", () => {
+    const index = createGraphSpatialIndex({
+      nodes: [
+        { id: "node-a", point: { x: 200, y: 200 }, hitBounds: { x: 175, y: 180, width: 50, height: 40 } },
+        { id: "left", point: { x: 120, y: 200 }, hitBounds: { x: 110, y: 190, width: 20, height: 20 } },
+        { id: "right", point: { x: 280, y: 200 }, hitBounds: { x: 270, y: 190, width: 20, height: 20 } }
+      ],
+      edges: [{ id: "left-right", source: "left", target: "right", curveOffset: 0 }],
+      communities: [{ id: "community-a", wash: { cx: 200, cy: 200, rx: 120, ry: 80 } }]
+    });
+    const stackedCommunityDomTarget = communityWashDomTarget("community-a");
+
+    assert.deepEqual(classifyGraphEventTarget(stackedCommunityDomTarget), { kind: "community-wash", id: "community-a" });
+
+    const spatialTarget = graphSpatialHitToGestureTarget(index.hitTest({ x: 200, y: 200 }));
+    assert.deepEqual(spatialTarget, { kind: "node", id: "node-a" });
+    assert.deepEqual(classifyGraphPointerDownTargetFromGraphTarget(spatialTarget), {
+      intent: "node-drag-candidate",
+      target: { kind: "node", id: "node-a" }
+    });
+    assert.deepEqual(classifyGraphWheelTargetFromGraphTarget(spatialTarget), {
+      intent: "zoom",
+      target: { kind: "node", id: "node-a" }
+    });
+  });
+
+  it("keeps edge, community, and blank intents available through the same spatial target path", () => {
+    const index = createGraphSpatialIndex({
+      nodes: [
+        { id: "node-a", point: { x: 100, y: 100 }, hitBounds: { x: 80, y: 80, width: 40, height: 40 } },
+        { id: "node-b", point: { x: 220, y: 100 }, hitBounds: { x: 200, y: 80, width: 40, height: 40 } }
+      ],
+      edges: [{ id: "edge-a", source: "node-a", target: "node-b" }],
+      communities: [{ id: "community-a", wash: { cx: 260, cy: 180, rx: 80, ry: 44 } }]
+    });
+
+    assert.deepEqual(
+      classifyGraphPointerDownTargetFromGraphTarget(graphSpatialHitToGestureTarget(index.hitTest({ x: 160, y: 90 }))),
+      {
+        intent: "blank-pan-candidate",
+        target: { kind: "edge", id: "edge-a" }
+      }
+    );
+    assert.deepEqual(
+      classifyGraphPointerDownTargetFromGraphTarget(graphSpatialHitToGestureTarget(index.hitTest({ x: 260, y: 180 }))),
+      {
+        intent: "community-click-candidate",
+        target: { kind: "community-wash", id: "community-a" }
+      }
+    );
+    assert.deepEqual(
+      classifyGraphPointerDownTargetFromGraphTarget(graphSpatialHitToGestureTarget(index.hitTest({ x: 500, y: 500 }))),
+      {
+        intent: "blank-pan-candidate",
+        target: { kind: "graph-blank" }
+      }
+    );
+  });
+
+  it("keeps UI blockers as the DOM boundary before graph-object hit testing", () => {
+    assert.deepEqual(classifyGraphPointerDownTarget(toolbarDomTarget()), {
+      intent: "blocked",
+      target: { kind: "toolbar" }
+    });
+  });
+});
+
+function communityWashDomTarget(id: string): FakeTarget {
+  const community = new FakeTarget({ dataset: { communityId: id } });
+  return new FakeTarget({ closest: { ".community-wash": community } });
+}
+
+function toolbarDomTarget(): FakeTarget {
+  const toolbar = new FakeTarget();
+  return new FakeTarget({ closest: { ".graph-toolbar": toolbar } });
+}

package/skills/llm-wiki-skill/packages/graph-engine/test/keyboard.test.ts

@@ -0,0 +1,59 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import { classifyGraphKeyboardIntent, type GraphKeyboardIntentInput } from "../src/render/keyboard";
+
+describe("graph keyboard ownership", () => {
+  it("opens graph search only when the graph owns focus", () => {
+    assert.equal(intent({ key: "f", metaKey: true, graphFocused: true }), "open-search");
+    assert.equal(intent({ key: "f", ctrlKey: true, graphFocused: true }), "open-search");
+    assert.equal(intent({ key: "f", metaKey: true, graphFocused: false }), "blocked");
+  });
+
+  it("does not steal browser find from text editing targets", () => {
+    assert.equal(intent({
+      key: "f",
+      metaKey: true,
+      graphFocused: true,
+      textEditingTarget: true
+    }), "blocked");
+  });
+
+  it("routes Escape to the graph state only inside graph focus", () => {
+    assert.equal(intent({ key: "Escape", graphFocused: true, searchActive: true }), "close-search");
+    assert.equal(intent({ key: "Escape", graphFocused: true, toolbarOpen: true }), "close-toolbar");
+    assert.equal(intent({ key: "Escape", graphFocused: true, interactionActive: true }), "clear-interaction");
+    assert.equal(intent({ key: "Escape", graphFocused: false, searchActive: true }), "blocked");
+    assert.equal(intent({ key: "Escape", graphFocused: false, toolbarOpen: true }), "blocked");
+    assert.equal(intent({ key: "Escape", graphFocused: false, interactionActive: true }), "blocked");
+  });
+
+  it("lets active gestures own Escape even if focus moved outside the graph", () => {
+    assert.equal(intent({ key: "Escape", graphFocused: false, activeGesture: true }), "cancel-active-gesture");
+    assert.equal(intent({
+      key: "Escape",
+      graphFocused: true,
+      activeGesture: true,
+      searchActive: true
+    }), "close-search");
+  });
+
+  it("blocks unrelated keys", () => {
+    assert.equal(intent({ key: "a", graphFocused: true }), "blocked");
+    assert.equal(intent({ key: "Enter", graphFocused: true, interactionActive: true }), "blocked");
+  });
+});
+
+function intent(input: Partial<GraphKeyboardIntentInput>) {
+  return classifyGraphKeyboardIntent({
+    key: input.key || "",
+    ctrlKey: input.ctrlKey === true,
+    metaKey: input.metaKey === true,
+    graphFocused: input.graphFocused === true,
+    activeGesture: input.activeGesture === true,
+    textEditingTarget: input.textEditingTarget === true,
+    searchActive: input.searchActive === true,
+    toolbarOpen: input.toolbarOpen === true,
+    interactionActive: input.interactionActive === true
+  });
+}

package/skills/llm-wiki-skill/packages/graph-engine/test/large-fixtures.test.ts

@@ -0,0 +1,47 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+  generateLargeGraphFixture,
+  LARGE_GRAPH_FIXTURE_SPECS,
+  summarizeLargeGraphFixture
+} from "./large-graph-fixtures";
+
+describe("large graph fixture generation", () => {
+  it("generates every required graph shape with deterministic metadata", () => {
+    for (const spec of LARGE_GRAPH_FIXTURE_SPECS) {
+      const fixture = generateLargeGraphFixture(spec.id);
+      assert.equal(fixture.metadata.id, spec.id);
+      assert.equal(fixture.metadata.nodes, spec.nodes, `${spec.id} node count`);
+      assert.equal(fixture.metadata.edges, spec.edges, `${spec.id} edge count`);
+      assert.equal(fixture.metadata.communities, spec.communities, `${spec.id} community count`);
+      assert.equal(fixture.metadata.largest_community, spec.largestCommunity, `${spec.id} largest community`);
+      assert.equal(fixture.metadata.search_hits, spec.searchHits, `${spec.id} search-hit count`);
+      assert.equal(fixture.metadata.pin_count, spec.pinCount, `${spec.id} Pin count`);
+      assert.equal(fixture.metadata.oversized_community, spec.oversizedCommunity, `${spec.id} oversized flag`);
+      assert.deepEqual(
+        summarizeLargeGraphFixture(spec.id, fixture.data, fixture.pins),
+        fixture.metadata,
+        `${spec.id} metadata should be reproducible from graph data`
+      );
+    }
+  });
+
+  it("keeps generated output stable for the same fixture id", () => {
+    const first = generateLargeGraphFixture("nodes-1000-sparse");
+    const second = generateLargeGraphFixture("nodes-1000-sparse");
+
+    assert.deepEqual(second.metadata, first.metadata);
+    assert.deepEqual(second.data.nodes.slice(0, 20), first.data.nodes.slice(0, 20));
+    assert.deepEqual(second.data.edges.slice(0, 40), first.data.edges.slice(0, 40));
+    assert.deepEqual(second.pins, first.pins);
+  });
+
+  it("does not require committed generated graph artifacts", () => {
+    const fixture = generateLargeGraphFixture("nodes-10000-high-edge");
+
+    assert.equal(fixture.data.nodes.length, 10000);
+    assert.equal(fixture.data.edges.length, 90000);
+    assert.ok(fixture.data.meta.degraded, "large generated fixtures should be marked degraded for current DOM/SVG baseline");
+    assert.equal(Object.keys(fixture.pins).length, 300);
+  });
+});