@joekytc/dsh-swarm 0.1.2 → 0.2.0

package/skills/llm-wiki-skill/packages/graph-engine/test/aggregation-fallback-trial-adapter.ts

@@ -0,0 +1,222 @@
+import {
+  buildGraphRendererAdapterData,
+  buildGraphRendererBehaviorContract,
+  type GraphRendererBehaviorContract
+} from "../src/render";
+import type {
+  GraphAggregationMarker,
+  GraphData,
+  GraphFocusInput,
+  GraphTypeFilters,
+  NodeId,
+  PinMap,
+  SelectionInput
+} from "../src/types";
+
+export interface AggregationFallbackTrialOptions {
+  pins?: PinMap;
+  selection?: SelectionInput | null;
+  searchResultIds?: NodeId[];
+  aggregationMarkers?: GraphAggregationMarker[];
+  focus?: GraphFocusInput;
+  typeFilters?: GraphTypeFilters;
+}
+
+export interface AggregationFallbackTrialModel {
+  nodes: AggregationFallbackTrialNode[];
+  edges: AggregationFallbackTrialEdge[];
+  communities: AggregationFallbackTrialCommunity[];
+  containers: AggregationFallbackTrialContainer[];
+  budget: {
+    visibleNodes: number;
+    visibleEdges: number;
+    visibleLabels: number;
+    visibleCards: number;
+    overflowNodes: number;
+    overflowEdges: number;
+    overflowLabels: number;
+    overflowCards: number;
+    maxInteractionUpdates: number;
+    interactionUpdatedObjects: number;
+    interactionHiddenObjects: number;
+    preservedNodeIds: string[];
+  };
+  behavior: GraphRendererBehaviorContract;
+}
+
+export interface AggregationFallbackTrialNode {
+  id: string;
+  label: string;
+  x: number;
+  y: number;
+  color: string;
+  radius: number;
+  communityId: string | null;
+  selected: boolean;
+  searchHit: boolean;
+  pinned: boolean;
+  labelVisible: boolean;
+  cardVisible: boolean;
+  aggregationIds: string[];
+}
+
+export interface AggregationFallbackTrialEdge {
+  id: string;
+  source: string;
+  target: string;
+  strokeWidth: number;
+  opacity: number;
+  skeleton: boolean;
+}
+
+export interface AggregationFallbackTrialCommunity {
+  id: string;
+  label: string;
+  nodeIds: string[];
+  selected: boolean;
+  searchResultIds: string[];
+  pinnedNodeIds: string[];
+}
+
+export interface AggregationFallbackTrialContainer {
+  id: string;
+  label: string;
+  communityId: string | null;
+  x: number;
+  y: number;
+  radius: number;
+  color: string;
+  nodeIds: string[];
+  selectedNodeIds: string[];
+  searchResultIds: string[];
+  pinnedNodeIds: string[];
+  totalCount: number;
+}
+
+const COMMUNITY_COLORS = [
+  "#2563eb",
+  "#059669",
+  "#d97706",
+  "#7c3aed",
+  "#dc2626",
+  "#0891b2",
+  "#4f46e5",
+  "#65a30d"
+];
+
+export function buildAggregationFallbackTrialModel(
+  data: GraphData,
+  options: AggregationFallbackTrialOptions = {}
+): AggregationFallbackTrialModel {
+  const adapter = buildGraphRendererAdapterData(data, {
+    ...options,
+    focus: options.focus ?? { kind: "global" }
+  });
+  const renderable = adapter.renderable;
+  const searchSet = new Set(options.searchResultIds ?? []);
+  const nodeById = new Map(adapter.nodes.map((node) => [node.id, node]));
+
+  const nodes = renderable.nodes.map((node): AggregationFallbackTrialNode => {
+    const adapterNode = nodeById.get(node.id);
+    return {
+      id: node.id,
+      label: node.label,
+      x: node.point.x,
+      y: node.point.y,
+      color: colorForCommunity(adapterNode?.communityId ?? node.community),
+      radius: node.displayMode === "card" ? 7 : node.labelVisible ? 5 : 3,
+      communityId: adapterNode?.communityId ?? node.community ?? null,
+      selected: adapterNode?.selected ?? node.selected,
+      searchHit: adapterNode?.searchHit ?? searchSet.has(node.id),
+      pinned: adapterNode?.pinHint.pinned ?? false,
+      labelVisible: node.labelVisible,
+      cardVisible: node.displayMode === "card" || node.displayMode === "compact-card",
+      aggregationIds: adapterNode?.aggregationIds ?? []
+    };
+  });
+
+  const edges = renderable.edges.map((edge): AggregationFallbackTrialEdge => ({
+    id: edge.id,
+    source: edge.source,
+    target: edge.target,
+    strokeWidth: edge.strokeWidth,
+    opacity: edge.opacity,
+    skeleton: edge.skeleton
+  }));
+
+  const communities = adapter.communities.map((community): AggregationFallbackTrialCommunity => ({
+    id: community.id,
+    label: community.label,
+    nodeIds: community.nodeIds,
+    selected: community.selected,
+    searchResultIds: community.searchResultIds,
+    pinnedNodeIds: community.pinHints.map((hint) => hint.nodeId)
+  }));
+
+  const containers = adapter.aggregations.map((aggregation): AggregationFallbackTrialContainer => {
+    const points = aggregation.nodeIds
+      .map((id) => nodeById.get(id)?.point)
+      .filter((point): point is { x: number; y: number } => Boolean(point));
+    const point = averagePoint(points);
+    return {
+      id: aggregation.id,
+      label: aggregation.label,
+      communityId: aggregation.communityId,
+      x: point.x,
+      y: point.y,
+      radius: aggregationRadius(aggregation.totalCount),
+      color: colorForCommunity(aggregation.communityId),
+      nodeIds: aggregation.nodeIds,
+      selectedNodeIds: aggregation.selectedNodeIds,
+      searchResultIds: aggregation.searchResultIds,
+      pinnedNodeIds: aggregation.pinnedNodeIds,
+      totalCount: aggregation.totalCount
+    };
+  });
+
+  return {
+    nodes,
+    edges,
+    communities,
+    containers,
+    budget: {
+      visibleNodes: renderable.budget.usage.maxVisibleNodes,
+      visibleEdges: renderable.budget.usage.maxVisibleEdges,
+      visibleLabels: renderable.budget.usage.maxLabels,
+      visibleCards: renderable.budget.usage.maxCards,
+      overflowNodes: renderable.overflow.nodes.hidden,
+      overflowEdges: renderable.overflow.edges.hidden,
+      overflowLabels: renderable.overflow.labels.hidden,
+      overflowCards: renderable.overflow.cards.hidden,
+      maxInteractionUpdates: renderable.interaction.maxUpdatedObjects,
+      interactionUpdatedObjects: renderable.interaction.updatedObjects,
+      interactionHiddenObjects: renderable.interaction.hiddenObjects,
+      preservedNodeIds: renderable.interaction.preservedNodeIds
+    },
+    behavior: buildGraphRendererBehaviorContract(adapter, "aggregation-fallback")
+  };
+}
+
+function colorForCommunity(communityId: string | null): string {
+  if (!communityId) return "#64748b";
+  const index = Math.abs(hashString(communityId)) % COMMUNITY_COLORS.length;
+  return COMMUNITY_COLORS[index];
+}
+
+function hashString(value: string): number {
+  let hash = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    hash = ((hash << 5) - hash + value.charCodeAt(index)) | 0;
+  }
+  return hash;
+}
+
+function averagePoint(points: Array<{ x: number; y: number }>): { x: number; y: number } {
+  if (!points.length) return { x: 0, y: 0 };
+  const sum = points.reduce((memo, point) => ({ x: memo.x + point.x, y: memo.y + point.y }), { x: 0, y: 0 });
+  return { x: sum.x / points.length, y: sum.y / points.length };
+}
+
+function aggregationRadius(count: number): number {
+  return Math.max(10, Math.min(42, 8 + Math.sqrt(Math.max(1, count)) * 1.4));
+}

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

@@ -0,0 +1,121 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import { GraphDiffQueue, mergeGraphDiffs } from "../src/anim";
+import type { GraphDiff } from "../src/types";
+
+describe("GraphDiffQueue", () => {
+  it("consumes immediately when graph is visible", () => {
+    const queue = new GraphDiffQueue({ visible: true });
+    const decision = queue.push(diff({ addedNodes: ["n1"] }));
+
+    assert.equal(decision.action, "consume");
+    assert.deepEqual(decision.diff?.addedNodes, ["n1"]);
+    assert.equal(decision.snapshot.isAnimating, true);
+
+    const done = queue.finishAnimation();
+    assert.equal(done.action, "queue");
+    assert.equal(done.snapshot.isAnimating, false);
+  });
+
+  it("queues while hidden and consumes the net diff when shown", () => {
+    const queue = new GraphDiffQueue({ visible: false });
+
+    const queued = queue.push(diff({ addedNodes: ["n1"], addedEdges: ["e1"] }));
+    assert.equal(queued.action, "queue");
+    assert.deepEqual(queued.snapshot.pending?.addedNodes, ["n1"]);
+
+    const shown = queue.setVisible(true);
+    assert.equal(shown.action, "consume");
+    assert.deepEqual(shown.diff?.addedNodes, ["n1"]);
+    assert.deepEqual(shown.diff?.addedEdges, ["e1"]);
+    assert.equal(shown.snapshot.pending, null);
+  });
+
+  it("holds diffs during drag and consumes after release", () => {
+    const queue = new GraphDiffQueue({ visible: true });
+
+    queue.setDragging(true);
+    const queued = queue.push(diff({ addedNodes: ["n1"] }));
+    assert.equal(queued.action, "queue");
+    assert.equal(queued.reason, "dragging");
+
+    const released = queue.setDragging(false);
+    assert.equal(released.action, "consume");
+    assert.deepEqual(released.diff?.addedNodes, ["n1"]);
+  });
+
+  it("does not replay a refresh diff until both drag and animation are idle", () => {
+    const queue = new GraphDiffQueue({ visible: true });
+
+    const first = queue.push(diff({ addedNodes: ["already-playing"] }));
+    assert.equal(first.action, "consume");
+    assert.equal(first.snapshot.isAnimating, true);
+
+    queue.setDragging(true);
+    const queued = queue.push(diff({ addedNodes: ["fresh"] }));
+    assert.equal(queued.action, "queue");
+    assert.equal(queued.reason, "dragging");
+
+    const released = queue.setDragging(false);
+    assert.equal(released.action, "queue");
+    assert.equal(released.snapshot.pending?.addedNodes.includes("fresh"), true);
+
+    const finished = queue.finishAnimation();
+    assert.equal(finished.action, "consume");
+    assert.deepEqual(finished.diff?.addedNodes, ["fresh"]);
+  });
+
+  it("folds multiple pending diffs into one net replay", () => {
+    const queue = new GraphDiffQueue({ visible: false });
+
+    queue.push(diff({
+      addedNodes: ["create-then-delete", "stay-new"],
+      addedEdges: ["edge-create-then-delete"],
+      recoloredNodes: [{ id: "color", from: "old", to: "mid" }],
+      stats: { nodeCount: 3, edgeCount: 1, communityCount: 2 }
+    }));
+    queue.push(diff({
+      removedNodes: ["create-then-delete"],
+      removedEdges: ["edge-create-then-delete"],
+      recoloredNodes: [{ id: "color", from: "mid", to: "new" }],
+      newCommunities: ["fresh"],
+      stats: { nodeCount: 2, edgeCount: 0, communityCount: 3 }
+    }));
+
+    const shown = queue.setVisible(true);
+
+    assert.equal(shown.action, "consume");
+    assert.deepEqual(shown.diff, diff({
+      addedNodes: ["stay-new"],
+      recoloredNodes: [{ id: "color", from: "old", to: "new" }],
+      newCommunities: ["fresh"],
+      stats: { nodeCount: 2, edgeCount: 0, communityCount: 3 }
+    }));
+  });
+});
+
+describe("mergeGraphDiffs", () => {
+  it("cancels add-then-remove nodes and keeps latest stats", () => {
+    const merged = mergeGraphDiffs(
+      diff({ addedNodes: ["a", "b"], stats: { nodeCount: 2, edgeCount: 0, communityCount: 1 } }),
+      diff({ removedNodes: ["a"], stats: { nodeCount: 1, edgeCount: 0, communityCount: 1 } })
+    );
+
+    assert.deepEqual(merged.addedNodes, ["b"]);
+    assert.deepEqual(merged.removedNodes, []);
+    assert.equal(merged.stats.nodeCount, 1);
+  });
+});
+
+function diff(partial: Partial<GraphDiff> = {}): GraphDiff {
+  return {
+    addedNodes: partial.addedNodes ?? [],
+    removedNodes: partial.removedNodes ?? [],
+    recoloredNodes: partial.recoloredNodes ?? [],
+    addedEdges: partial.addedEdges ?? [],
+    removedEdges: partial.removedEdges ?? [],
+    newCommunities: partial.newCommunities ?? [],
+    stats: partial.stats ?? { nodeCount: 0, edgeCount: 0, communityCount: 0 }
+  };
+}

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

@@ -0,0 +1,63 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import { GRAPH_ARCHITECTURE_LAYERS, type GraphArchitectureLayerId } from "../src";
+
+const EXPECTED_LAYER_ORDER: GraphArchitectureLayerId[] = [
+  "data",
+  "layout",
+  "viewport",
+  "controller",
+  "renderer",
+  "gestures",
+  "facade"
+];
+
+describe("graph architecture layer contract", () => {
+  it("declares the seven graph owner layers in one exported contract", () => {
+    assert.deepEqual(GRAPH_ARCHITECTURE_LAYERS.map((layer) => layer.id), EXPECTED_LAYER_ORDER);
+    assert.deepEqual(GRAPH_ARCHITECTURE_LAYERS.map((layer) => layer.name), [
+      "GraphData",
+      "GraphLayout",
+      "GraphViewport",
+      "GraphController",
+      "GraphRenderer",
+      "GraphGestures",
+      "GraphFacade"
+    ]);
+  });
+
+  it("assigns each layer real ownership and entrypoints", () => {
+    for (const layer of GRAPH_ARCHITECTURE_LAYERS) {
+      assert.ok(layer.owns.length >= 3, `${layer.name} should declare owned responsibilities`);
+      assert.ok(layer.entrypoints.length >= 1, `${layer.name} should declare code entrypoints`);
+      assert.ok(layer.mustNotOwn.length >= 3, `${layer.name} should declare forbidden responsibilities`);
+      for (const entrypoint of layer.entrypoints) {
+        assert.match(entrypoint, /^src\//, `${layer.name} entrypoint should stay inside graph-engine src`);
+      }
+    }
+  });
+
+  it("keeps host callbacks only in the facade layer", () => {
+    const hostCallbackOwners = GRAPH_ARCHITECTURE_LAYERS
+      .filter((layer) => layer.owns.some((item) => item.includes("host capability callbacks")))
+      .map((layer) => layer.id);
+    assert.deepEqual(hostCallbackOwners, ["facade"]);
+
+    const forbiddenOutsideFacade = GRAPH_ARCHITECTURE_LAYERS
+      .filter((layer) => layer.id !== "facade")
+      .filter((layer) => !layer.mustNotOwn.includes("host callbacks"))
+      .map((layer) => layer.id);
+    assert.deepEqual(forbiddenOutsideFacade, []);
+  });
+
+  it("keeps browser event policy only in the gestures layer", () => {
+    const eventPolicyOwners = GRAPH_ARCHITECTURE_LAYERS
+      .filter((layer) => layer.owns.some((item) => item.includes("raw wheel")))
+      .map((layer) => layer.id);
+    assert.deepEqual(eventPolicyOwners, ["gestures"]);
+
+    const renderer = GRAPH_ARCHITECTURE_LAYERS.find((layer) => layer.id === "renderer");
+    assert.ok(renderer?.mustNotOwn.includes("browser default policy"));
+  });
+});

package/skills/llm-wiki-skill/packages/graph-engine/test/community-cloud-geometry.test.ts

@@ -0,0 +1,86 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  clampPointToScreenEllipse,
+  clampPointToWorldEllipse,
+  convexHull2d,
+  sigmaCommunityCloud,
+  sigmaCommunityCloudSignature
+} from "../src/render/community-cloud-geometry";
+
+function hasPoint(points: Array<{ x: number; y: number }>, x: number, y: number): boolean {
+  return points.some((p) => p.x === x && p.y === y);
+}
+
+describe("community cloud geometry", () => {
+  it("convexHull2d copies inputs shorter than a triangle", () => {
+    const single = [{ x: 1, y: 2 }];
+    const result = convexHull2d(single);
+    assert.deepEqual(result, single);
+    assert.notEqual(result, single);
+  });
+
+  it("convexHull2d keeps only the outer corners and drops interior points", () => {
+    const hull = convexHull2d([
+      { x: 0, y: 0 },
+      { x: 4, y: 0 },
+      { x: 4, y: 4 },
+      { x: 0, y: 4 },
+      { x: 2, y: 2 }
+    ]);
+    assert.equal(hull.length, 4);
+    assert.ok(hasPoint(hull, 0, 0));
+    assert.ok(hasPoint(hull, 4, 0));
+    assert.ok(hasPoint(hull, 4, 4));
+    assert.ok(hasPoint(hull, 0, 4));
+    assert.ok(!hasPoint(hull, 2, 2));
+  });
+
+  it("clampPointToWorldEllipse leaves interior points untouched", () => {
+    const ellipse = { cx: 0, cy: 0, rx: 10, ry: 10 };
+    assert.deepEqual(clampPointToWorldEllipse({ x: 5, y: 0 }, ellipse), { x: 5, y: 0 });
+  });
+
+  it("clampPointToWorldEllipse projects outside points onto the boundary", () => {
+    const ellipse = { cx: 0, cy: 0, rx: 10, ry: 10 };
+    assert.deepEqual(clampPointToWorldEllipse({ x: 20, y: 0 }, ellipse), { x: 10, y: 0 });
+  });
+
+  it("clampPointToScreenEllipse projects outside points onto the box ellipse", () => {
+    const box = { left: 0, top: 0, width: 20, height: 20 };
+    assert.deepEqual(clampPointToScreenEllipse({ x: 12, y: 10 }, box), { x: 12, y: 10 });
+    assert.deepEqual(clampPointToScreenEllipse({ x: 30, y: 10 }, box), { x: 20, y: 10 });
+  });
+
+  it("sigmaCommunityCloudSignature is stable for equal inputs and changes with the wash", () => {
+    const points = [{ x: 1, y: 2 }, { x: 3, y: 4 }];
+    const wash = { cx: 0, cy: 0, rx: 5, ry: 5 };
+    assert.equal(
+      sigmaCommunityCloudSignature(points, wash),
+      sigmaCommunityCloudSignature(points, wash)
+    );
+    assert.notEqual(
+      sigmaCommunityCloudSignature(points, wash),
+      sigmaCommunityCloudSignature(points, { cx: 1, cy: 0, rx: 5, ry: 5 })
+    );
+    assert.equal(sigmaCommunityCloudSignature([{ x: 1, y: 2 }], undefined), "1,2");
+  });
+
+  it("sigmaCommunityCloud falls back to the box when there is no hull", () => {
+    const fallback = { left: 1, top: 2, width: 3, height: 4 };
+    const cloud = sigmaCommunityCloud([], fallback);
+    assert.deepEqual(cloud.box, fallback);
+    assert.equal(cloud.localPoints, null);
+  });
+
+  it("sigmaCommunityCloud derives local polygon points from a screen hull", () => {
+    const cloud = sigmaCommunityCloud(
+      [{ x: 0, y: 0 }, { x: 100, y: 0 }, { x: 50, y: 100 }],
+      { left: -1000, top: -1000, width: 4000, height: 4000 }
+    );
+    assert.ok(cloud.localPoints);
+    assert.equal(cloud.localPoints?.length, 3);
+    assert.ok(cloud.box.width >= 8 && cloud.box.height >= 8);
+  });
+});

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

@@ -0,0 +1,97 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  DEFAULT_COMMUNITY_WASH_MAX_RADIUS_X,
+  DEFAULT_COMMUNITY_WASH_MAX_RADIUS_Y,
+  computeCommunityWash
+} from "../src/render/community-wash";
+
+function node(x: number, y: number) {
+  return { point: { x, y } };
+}
+
+describe("community wash geometry", () => {
+  it("keeps small communities visibly selectable", () => {
+    const wash = computeCommunityWash([node(240, 220), node(262, 236)]);
+
+    assert.ok(wash);
+    assert.equal(wash.rx, 57);
+    assert.equal(wash.ry, 42);
+    assert.equal(wash.opacity, 0.11);
+  });
+
+  it("responds to one dragged outlier without chasing it across the canvas", () => {
+    const wash = computeCommunityWash([
+      node(200, 240),
+      node(220, 256),
+      node(238, 230),
+      node(252, 248),
+      node(940, 610)
+    ]);
+
+    assert.ok(wash);
+    assert.equal(wash.rx, DEFAULT_COMMUNITY_WASH_MAX_RADIUS_X);
+    assert.equal(wash.ry, DEFAULT_COMMUNITY_WASH_MAX_RADIUS_Y);
+    assert.ok(wash.cx > 300, `wash should move toward the outlier, got cx ${wash.cx}`);
+    assert.ok(wash.cx < 430, `wash should remain anchored near the core, got cx ${wash.cx}`);
+  });
+
+  it("caps response to outliers in multiple directions", () => {
+    const wash = computeCommunityWash([
+      node(440, 310),
+      node(462, 326),
+      node(482, 304),
+      node(506, 330),
+      node(80, 80),
+      node(950, 630)
+    ]);
+
+    assert.ok(wash);
+    assert.ok(wash.rx <= DEFAULT_COMMUNITY_WASH_MAX_RADIUS_X, `rx should stay capped, got ${wash.rx}`);
+    assert.ok(wash.ry <= DEFAULT_COMMUNITY_WASH_MAX_RADIUS_Y, `ry should stay capped, got ${wash.ry}`);
+    assert.equal(wash.rx, DEFAULT_COMMUNITY_WASH_MAX_RADIUS_X);
+    assert.equal(wash.ry, DEFAULT_COMMUNITY_WASH_MAX_RADIUS_Y);
+  });
+
+  it("keeps the cap stable for a single extreme dragged outlier", () => {
+    const nearOutlier = computeCommunityWash([
+      node(200, 240),
+      node(220, 256),
+      node(238, 230),
+      node(252, 248),
+      node(1240, 816)
+    ]);
+    const extremeOutlier = computeCommunityWash([
+      node(200, 240),
+      node(220, 256),
+      node(238, 230),
+      node(252, 248),
+      node(10000, 5000)
+    ]);
+
+    assert.ok(nearOutlier);
+    assert.ok(extremeOutlier);
+    assert.equal(nearOutlier.rx, DEFAULT_COMMUNITY_WASH_MAX_RADIUS_X);
+    assert.equal(nearOutlier.ry, DEFAULT_COMMUNITY_WASH_MAX_RADIUS_Y);
+    assert.equal(extremeOutlier.rx, DEFAULT_COMMUNITY_WASH_MAX_RADIUS_X);
+    assert.equal(extremeOutlier.ry, DEFAULT_COMMUNITY_WASH_MAX_RADIUS_Y);
+    assert.ok(extremeOutlier.cx < 440, `wash should stay visually anchored, got cx ${extremeOutlier.cx}`);
+    assert.ok(extremeOutlier.cy < 390, `wash should stay visually anchored, got cy ${extremeOutlier.cy}`);
+  });
+
+  it("keeps oversized community wash calculation bounded", () => {
+    const nodes = Array.from({ length: 1800 }, (_, index) => node(
+      120 + (index % 60) * 9,
+      90 + Math.floor(index / 60) * 11
+    ));
+    const started = performance.now();
+    const wash = computeCommunityWash(nodes);
+    const duration = performance.now() - started;
+
+    assert.ok(wash);
+    assert.ok(wash.rx <= DEFAULT_COMMUNITY_WASH_MAX_RADIUS_X, `rx should stay capped, got ${wash.rx}`);
+    assert.ok(wash.ry <= DEFAULT_COMMUNITY_WASH_MAX_RADIUS_Y, `ry should stay capped, got ${wash.ry}`);
+    assert.ok(duration < 80, `oversized wash should be bounded, took ${duration}ms`);
+  });
+});