pi-weave 0.1.8 → 0.1.9

package/src/web/client/graph/Graph.tsx

@@ -29,31 +29,28 @@
  * `Shell.tsx` uses for its drag handlers, for the same reason.
  */
 
-import { useEffect, useMemo, useRef, useState } from "preact/hooks";
+import { useEffect, useMemo, useRef, useState, useCallback } from "preact/hooks";
 import type { GraphPayload } from "../../shared/wire";
 import type { GraphViewState } from "./column.model";
 import {
-  DEPTHS,
   FIT_HINT,
   FIT_LABEL,
   LEGEND,
   allExpanded,
-  depthHint,
-  depthLabel,
   effectiveView,
   expandHint,
   expandLabel,
   graphClick,
   graphColumnModel,
   graphCountLabel,
-  parseDepth,
-  setDepth,
   toggleExpandAll,
 } from "./column.model";
 import type { PositionStorage } from "./positions";
 import type { GraphRenderer, RendererFactory } from "./renderer";
 import { schemeOf } from "./scheme";
 import type { SchemeHost } from "./scheme";
+import { createGraphSimulation } from "./dynamics";
+import type { GraphSimulation } from "./dynamics";
 
 export interface GraphProps {
   graph: GraphPayload | null;
@@ -81,6 +78,30 @@ export interface GraphProps {
 export function Graph(props: GraphProps) {
   const canvas = useRef<HTMLDivElement | null>(null);
   const renderer = useRef<GraphRenderer | null>(null);
+  const dynamics = useRef<GraphSimulation | null>(null);
+  const clock = useRef<number | null>(null);
+  /**
+   * Arm the simulation clock — idempotent.
+   *
+   * The layout is always live; the clock still sleeps whenever the engine's
+   * alpha reaches its floor (a graph that is holding still costs zero frames)
+   * and re-arms when a drag pins a node or a re-layout hands over a new
+   * engine.
+   */
+  const armClock = useCallback(() => {
+    if (clock.current !== null) return;
+    const step = () => {
+      clock.current = null;
+      const engine = dynamics.current;
+      if (engine === null) return;
+      engine.tick();
+      // Asleep: let the clock die. The next pin re-arms it.
+      if (!engine.awake()) return;
+      renderer.current?.setPositions(engine.positions());
+      clock.current = requestAnimationFrame(step);
+    };
+    clock.current = requestAnimationFrame(step);
+  }, []);
   // `null` means "the user has not touched the expansion" — not "nothing is
   // expanded". `effectiveView` resolves the difference; see its doc comment.
   const [state, setState] = useState<GraphViewState | null>(null);
@@ -101,6 +122,20 @@ export function Graph(props: GraphProps) {
       setState(next.state);
       live.current.onSelect(next.selectedId);
     });
+    instance.onDragStart((id) => {
+      const at = renderer.current?.positions().get(id);
+      if (at) {
+        dynamics.current?.pin(id, at);
+        // The pin re-heats the engine; if the clock was asleep, wake it.
+        armClock();
+      }
+    });
+    instance.onDragMove((id, at) => {
+      dynamics.current?.pin(id, at);
+    });
+    instance.onDragEnd((id) => {
+      dynamics.current?.release(id);
+    });
     instance.mount(canvas.current ?? { clientWidth: 0, clientHeight: 0 });
     renderer.current = instance;
     props.fit.current = () => instance.fit();
@@ -117,6 +152,35 @@ export function Graph(props: GraphProps) {
     renderer.current?.setGraph(model.graph);
   }, [model.key]);
 
+  // Live layout, in two effects so pause/resume and re-layout are independent.
+  //
+  // Effect 1 (keyed on `model.key`) owns the *simulation*: it is created once
+  // per graph shape, warm-started from the renderer's current positions so a
+  // drag or an expand does not make the graph jump, and disposed when the shape
+  // changes. A fresh engine starts at settle alpha — the "alive" answer to an
+  // expand — so the clock must arm here if it had gone to sleep.
+  useEffect(() => {
+    const engine = createGraphSimulation(model.graph, renderer.current?.positions());
+    dynamics.current = engine;
+    if (engine !== null) armClock();
+    return () => {
+      dynamics.current = null;
+    };
+  }, [model.key, armClock]);
+
+  // Effect 2 owns the clock's unmount cleanup: the engine's own lifecycle is
+  // effect 1's, and the step self-terminates whenever the engine settles, so
+  // the only teardown left here is a frame that could outlive the component.
+  useEffect(
+    () => () => {
+      if (clock.current !== null) {
+        cancelAnimationFrame(clock.current);
+        clock.current = null;
+      }
+    },
+    [],
+  );
+
   useEffect(() => {
     renderer.current?.setHighlight(model.highlight);
   }, [model.highlight]);
@@ -134,19 +198,6 @@ export function Graph(props: GraphProps) {
         <button type="button" class="weave-chip" title={expandHint(everything)} onClick={() => setState(toggleExpandAll(view, model.clusters))}>
           {expandLabel(everything)}
         </button>
-        <select
-          class="weave-chip weave-depth"
-          title={depthHint(view.depth)}
-          aria-label="Highlight depth"
-          value={String(view.depth)}
-          onChange={(event) => setState(setDepth(view, parseDepth(event.currentTarget.value, view.depth)))}
-        >
-          {DEPTHS.map((depth) => (
-            <option key={depth} value={String(depth)}>
-              {depthLabel(depth)}
-            </option>
-          ))}
-        </select>
         <span class="weave-graph-legend">
           <span class="weave-legend-on">◉ {LEGEND.selected}</span>
           <span class="weave-legend-near">● {LEGEND.neighborhood}</span>

package/src/web/client/graph/column.model.ts

@@ -51,25 +51,6 @@ import { resolveLayout } from "./positions";
 
 // --- the view state ------------------------------------------------------------------
 
-/**
- * How many hops of neighbourhood the highlight covers.
- *
- * The `[depth 1 ▾]` control from the §1.2 mock. 1 is core's
- * `focusNeighborhood` verbatim; 2 and 3 are that set expanded by re-applying
- * it, which is the only definition that cannot disagree with the context
- * rail's at depth 1.
- *
- * Capped at 3 deliberately. On this repository's shape the 60-child hub is two
- * hops from most of the graph, so depth 4 highlights nearly everything and a
- * highlight that covers everything conveys nothing. A number rather than a
- * boolean because "just the neighbours" and "the neighbourhood around this
- * module" are genuinely different questions.
- */
-export type Depth = 1 | 2 | 3;
-
-/** Every depth the control offers, in order. */
-export const DEPTHS: readonly Depth[] = [1, 2, 3];
-
 /** The graph column's state. Owned by the column; never on the context bus. */
 export interface GraphViewState {
   /**
@@ -83,8 +64,6 @@ export interface GraphViewState {
    * {@link initialGraphView}.
    */
   readonly expanded: ReadonlySet<string>;
-  /** How far the highlight reaches. */
-  readonly depth: Depth;
 }
 
 /**
@@ -112,7 +91,7 @@ export const AUTO_COLLAPSE_ABOVE = 120;
 export function initialGraphView(model: ViewGraphModel): GraphViewState {
   const expanded =
     model.nodes.length > AUTO_COLLAPSE_ABOVE ? new Set<string>() : new Set(clusterAggregate(model, new Set()).clusters.keys());
-  return { expanded, depth: 1 };
+  return { expanded };
 }
 
 /**
@@ -127,7 +106,7 @@ export function initialGraphView(model: ViewGraphModel): GraphViewState {
  */
 export function effectiveView(payload: GraphPayload | null, state: GraphViewState | null): GraphViewState {
   if (state !== null) return state;
-  if (payload === null) return { expanded: new Set(), depth: 1 };
+  if (payload === null) return { expanded: new Set() };
   return initialGraphView(viewModel(payload));
 }
 
@@ -156,21 +135,17 @@ export function collapseAll(state: GraphViewState): GraphViewState {
   return { ...state, expanded: new Set() };
 }
 
-/** Set the highlight depth. */
-export function setDepth(state: GraphViewState, depth: Depth): GraphViewState {
-  return state.depth === depth ? state : { ...state, depth };
-}
-
 // --- the highlight (§1.3, §7.4) ---------------------------------------------------------
 
 /**
  * The set of ids that stay lit when `selectedId` is selected.
  *
- * Depth 1 is `focusNeighborhood` **exactly** — core's function, the same one
- * the context rail's "Related" is built from, reached through the §2.1.1 door
- * rather than reimplemented. Deeper is that operation applied again, which is
- * the only definition of "2 hops" that cannot disagree with "1 hop" at the
- * boundary.
+ * `focusNeighborhood` **verbatim** — core's function, the same one the
+ * context rail's "Related" is built from, reached through the §2.1.1 door
+ * rather than reimplemented. (The `[depth 1 ▾]` control once let the user
+ * widen this to two and three hops; it read as decoration next to the rail's
+ * fixed-depth "Related" and is gone — one definition of "related", one
+ * behaviour everywhere.)
  *
  * `null` in, `null` out: nothing selected means no highlight at all, which the
  * reducers treat as "render everything normally" — deliberately not the same
@@ -182,34 +157,13 @@ export function setDepth(state: GraphViewState, depth: Depth): GraphViewState {
  * highlighting the hidden id would light nothing while leaving the cluster
  * that actually represents it dimmed.
  */
-export function highlightFor(edges: readonly WireGraphEdge[], selectedId: string | null, depth: Depth): Set<string> | null {
+export function highlightFor(edges: readonly WireGraphEdge[], selectedId: string | null): Set<string> | null {
   if (selectedId === null) return null;
-  let frontier = focusNeighborhood(selectedId, edges);
-  for (let hop = 1; hop < depth; hop++) {
-    const next = new Set(frontier);
-    for (const id of frontier) for (const neighbour of focusNeighborhood(id, edges)) next.add(neighbour);
-    // A neighbourhood that stopped growing has reached its whole connected
-    // component, so further hops cannot add anything and the loop is waste.
-    if (next.size === frontier.size) break;
-    frontier = next;
-  }
-  return frontier;
+  return focusNeighborhood(selectedId, edges);
 }
 
 // --- the control strip (§1.2) ---------------------------------------------------------------
 
-/** The `[depth 1 ▾]` control's label. */
-export function depthLabel(depth: Depth): string {
-  return `depth ${depth}`;
-}
-
-/** Its tooltip — says what the number means, not what it is. */
-export function depthHint(depth: Depth): string {
-  return depth === 1
-    ? "highlighting direct neighbours of the selection"
-    : `highlighting everything within ${depth} hops of the selection`;
-}
-
 /** The `[expand]` control's label, which is really a toggle. */
 export function expandLabel(allExpanded: boolean): string {
   return allExpanded ? "collapse" : "expand";
@@ -240,19 +194,6 @@ export function toggleExpandAll(state: GraphViewState, clusters: ReadonlyMap<str
   return allExpanded(state, clusters) ? collapseAll(state) : expandAll(state, clusters);
 }
 
-/**
- * Parse the depth `<select>`'s value.
- *
- * A `<select>` yields a string and the component must not cast it — an
- * `as Depth` on unvalidated input is exactly how a `depth 7` ends up in state
- * and the highlight silently covers the whole graph. Anything unrecognised
- * falls back to the current depth, so a malformed event changes nothing.
- */
-export function parseDepth(value: string, fallback: Depth): Depth {
-  const parsed = Number(value);
-  return (DEPTHS as readonly number[]).includes(parsed) ? (parsed as Depth) : fallback;
-}
-
 /** The `[fit]` control. Constant, but named here so the component holds no copy. */
 export const FIT_LABEL = "fit";
 export const FIT_HINT = "frame the whole graph";
@@ -354,7 +295,7 @@ export function graphColumnModel(
 
   return {
     graph: renderGraph(reduced.nodes, reduced.edges, layout.positions, scheme),
-    highlight: highlightFor(reduced.edges, selectedId, state.depth),
+    highlight: highlightFor(reduced.edges, selectedId),
     key: layout.key,
     cached: layout.cached,
     clusters: reduced.clusters,

package/src/web/client/graph/dynamics.ts

@@ -0,0 +1,176 @@
+/**
+ * Live force dynamics for the graph's current shape — the Obsidian-style
+ * "the graph is alive" feel while the user drags.
+ *
+ * ## One physics, two drivers
+ *
+ * The static layout (`shared/layout.ts`) and this module now share ONE force
+ * configuration: {@link createForceSimulation}. They used to be two
+ * independent physics — the static path ring-sized its link distances per
+ * fan-out and anchored every node to its seed; this one pulled at a flat 90
+ * units toward its own equilibrium. Every graph therefore *visibly re-laid
+ * itself* after mount (a 215-node repo graph migrated from a ~1200-unit ring
+ * to the bespoke sim's ~300-unit cloud over about thirty seconds), and the
+ * constant-alpha loop ticked at 60 fps forever, because a bespoke integrator
+ * has no alpha to decay. Sharing the factory fixes both by construction: the
+ * warm start is already at the shared equilibrium, so there is nothing to
+ * migrate to, and d3's alpha decay is what says "settled".
+ *
+ * ## The lifecycle
+ *
+ * A new engine starts at {@link SETTLE_ALPHA} (an expand/collapse lands new
+ * nodes already laid out; the brief settle is the "alive" response, not a
+ * re-layout) and decays to d3's alpha floor, at which point {@link awake}
+ * turns false and the component's clock puts itself to sleep — no frames are
+ * spent on a graph that is holding still. `pin` re-heats to
+ * {@link DRAG_ALPHA_TARGET} (d3's own drag pattern), so neighbours make room
+ * while the user drags; `release` clears the pin AND retargets the node's
+ * anchor to its drop point, so a dragged node stays where it was dropped
+ * instead of springing back to its seed.
+ *
+ * ## The §7.2 vertical-line freeze
+ *
+ * Inherited from d3 itself: `manyBody`, `collide` and `link` all inject a
+ * seeded `jiggle` into a zero axis component, so coincident or collinear
+ * nodes always acquire a direction. The seeded LCG (`seed: 1`) keeps the
+ * whole thing deterministic — the same graph, the same gestures, byte-identical
+ * positions — which is what the test gate asserts.
+ */
+
+import type { Point } from "../../shared/layout";
+import { createForceSimulation, isContainment } from "../../shared/layout";
+import type { WireEdgeKind } from "../../shared/graph";
+import type { RenderGraph } from "./graph.model";
+
+interface SimNode {
+  id: string;
+  x?: number;
+  y?: number;
+  vx?: number;
+  vy?: number;
+  index?: number;
+  fx?: number | null;
+  fy?: number | null;
+}
+
+interface SimLink {
+  source: string | SimNode;
+  target: string | SimNode;
+  kind: WireEdgeKind;
+}
+
+export interface GraphSimulation {
+  tick(): void;
+  positions(): Map<string, Point>;
+  pin(id: string, at: Point): void;
+  release(id: string): void;
+  /** `false` once the alpha floor is reached — the graph is holding still, and the clock can sleep. */
+  awake(): boolean;
+}
+
+/** Re-heat on creation (mount, expand, collapse): brief and local, never a re-layout. */
+const SETTLE_ALPHA = 0.06;
+/**
+ * The drag alpha target. The balance the user feels: too low and the
+ * neighbours read as stiff and lazy while the node moves; too high and the
+ * whole tree thrashes (measured: the hub drag peaks at ~950px/s of per-node
+ * ripple at 0.3 with rigid links, ~174px/s at 0.2 with the soft springs —
+ * lively, and an order of magnitude inside the crazy regime).
+ */
+const DRAG_ALPHA_TARGET = 0.2;
+/** d3-force's alpha floor. */
+const ALPHA_MIN = 0.001;
+
+/**
+ * Build a live simulation over a {@link RenderGraph}.
+ *
+ * `initial`, when given, is the warm start: existing ids keep their current
+ * positions (so a drag or an expand does not make the graph jump), and ids it
+ * does not name fall back to the graph's own laid-out positions. Those warm
+ * positions are also the anchor targets, so the graph rests exactly where the
+ * layout left it.
+ *
+ * Returns `null` for an empty graph — there is nothing to simulate, and an
+ * empty `Map` every frame is work for nothing.
+ */
+export function createGraphSimulation(graph: RenderGraph, initial?: ReadonlyMap<string, Point>): GraphSimulation | null {
+  if (graph.nodes.length === 0) return null;
+
+  const nodes: SimNode[] = graph.nodes.map((node) => {
+    const at = initial?.get(node.id);
+    return {
+      id: node.id,
+      x: at !== undefined && Number.isFinite(at.x) ? at.x : node.x,
+      y: at !== undefined && Number.isFinite(at.y) ? at.y : node.y,
+      vx: 0,
+      vy: 0,
+    };
+  });
+  const byId = new Map(nodes.map((node) => [node.id, node]));
+
+  // Dangling endpoints and self-edges are a degenerate *input*; forceLink
+  // would throw on them, so they are dropped here and the layout's own
+  // `pathologicalGraph` fixture remains the gate for degenerate *outputs*.
+  const seen = new Set<string>();
+  const links: SimLink[] = [];
+  for (const edge of graph.edges) {
+    if (edge.source === edge.target) continue;
+    if (!byId.has(edge.source) || !byId.has(edge.target)) continue;
+    const key = `${edge.source}\u0000${edge.target}\u0000${edge.kind}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    links.push({ source: edge.source, target: edge.target, kind: edge.kind });
+  }
+
+  // No invented seeding; centre gravity lives in the factory (`forceX()`/
+  // `forceY()`). `anchors` starts empty — every node targets the origin — and
+  // grows on release: a dropped node's anchor is retargeted to its drop point,
+  // so placement sticks (the anchor is five times stronger than the leaf
+  // spring, so the node rests where the user left it).
+  const anchors = new Map<string, Point>();
+  const sim = createForceSimulation({ nodes, links, anchors, seed: 1 })
+    .alpha(SETTLE_ALPHA)
+    .alphaMin(ALPHA_MIN);
+
+  return {
+    tick() {
+      sim.tick();
+    },
+
+    awake() {
+      // A held alpha target is motion about to happen — the clock must stay
+      // armed even while alpha itself is still converging up to the target.
+      return sim.alphaTarget() > ALPHA_MIN || sim.alpha() > ALPHA_MIN;
+    },
+
+    positions() {
+      return new Map(nodes.map((node) => [node.id, { x: node.x ?? 0, y: node.y ?? 0 }]));
+    },
+
+    pin(id, at) {
+      const node = byId.get(id);
+      if (!node) return;
+      // d3's canonical drag, from the force-directed graph example: fix the
+      // subject at the pointer and hold the alpha target up so the neighbours
+      // make room, then cool on release. A pinned node is immune to every
+      // force — the drag must not fight the sim, or the node would shudder
+      // under its own neighbours.
+      node.fx = at.x;
+      node.fy = at.y;
+      sim.alphaTarget(DRAG_ALPHA_TARGET);
+    },
+
+    release(id) {
+      const node = byId.get(id);
+      if (!node) return;
+      // Unfix, like d3's `dragended` — and retarget the node's centre-gravity
+      // anchor to the drop point, so the graph reads the drop as a placement:
+      // the node rests where the user left it instead of gliding back into
+      // the tree.
+      anchors.set(id, { x: node.x ?? 0, y: node.y ?? 0 });
+      node.fx = null;
+      node.fy = null;
+      sim.alphaTarget(0);
+    },
+  };
+}

package/src/web/client/graph/graph.model.ts

@@ -131,9 +131,13 @@ export function edgeColor(kind: WireEdgeKind, scheme: ColorScheme): string {
 /**
  * The smallest a node is ever drawn, in layout units.
  *
- * A leaf still has to be clickable, and sigma's hit test is the drawn radius.
+ * A leaf still has to be clickable, and sigma's hit test is the drawn radius —
+ * at fit zoom a leaf renders at `MIN_NODE_SIZE · cameraCorrection`, so a floor
+ * of 6 is what keeps every node inside a pointer's reach at overview zoom.
+ * (The d3 gallery's force-directed graphs draw every node the same radius for
+ * exactly this reason; size still varies by degree up to the ceiling.)
  */
-export const MIN_NODE_SIZE = 3;
+export const MIN_NODE_SIZE = 6;
 
 /**
  * The degree at which a node reaches {@link NODE_RADIUS}.
@@ -455,6 +459,7 @@ export function edgeReducer(
  */
 export interface GraphSettings {
   readonly hideEdgesOnMove: boolean;
+  readonly enableCameraPanning: boolean;
   readonly renderEdgeLabels: boolean;
   readonly labelDensity: number;
   readonly labelGridCellSize: number;
@@ -505,6 +510,9 @@ export function graphSettings(scheme: ColorScheme): GraphSettings {
     // §7.4. A pan over a few thousand edges is the one interaction that drops
     // frames, and the edges are the part nobody is reading mid-gesture.
     hideEdgesOnMove: true,
+    // The renderer toggles this off while a node is being dragged, so the
+    // gesture pins the node to the cursor instead of panning the camera.
+    enableCameraPanning: true,
     renderEdgeLabels: false,
     labelDensity: LABEL_DENSITY,
     labelGridCellSize: LABEL_GRID_CELL_SIZE,

package/src/web/client/graph/positions.ts

@@ -34,10 +34,34 @@
  * the root `tsconfig.json` project compiles the tests.
  */
 
-import { computeLayout, hashId } from "../../shared/layout";
+import { computeLayout } from "../../shared/layout";
 import type { LayoutOptions, Point } from "../../shared/layout";
 import type { WireGraphEdge, WireGraphNode } from "../../shared/wire";
 
+/**
+ * FNV-1a (32-bit) followed by MurmurHash3's `fmix32` avalanche.
+ *
+ * The finalizer is not optional: FNV-1a mixes its *low* bits well but its high
+ * bits poorly for short, near-identical inputs — and the digest folds the hash
+ * into a bounded key, so the high bits are the significant part. Raw FNV-1a
+ * over `leaf001…leaf199` put 199 ids into six of twelve sectors; `fmix32`
+ * costs four lines and makes every bit depend on every input bit.
+ */
+export function hashId(id: string): number {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < id.length; i++) {
+    h ^= id.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  h ^= h >>> 16;
+  h = Math.imul(h, 0x85ebca6b);
+  h ^= h >>> 13;
+  h = Math.imul(h, 0xc2b2ae35);
+  h ^= h >>> 16;
+  return h >>> 0;
+}
+
+
 // --- computing ----------------------------------------------------------------------
 
 /**
@@ -64,22 +88,39 @@ export const LAYOUT_SEED = 1;
  * re-running from a settled state is a near-fixed-point, which is the property
  * that makes an expand feel like an expand.
  *
- * The viewport is **not** a parameter, deliberately. `computeLayout` centres
- * its output on the width and height it is given, and sigma's camera fits
- * whatever extent it is handed — so feeding the real column width in would
- * re-run the simulation on every divider drag to produce a picture the camera
- * immediately normalises away. A fixed nominal viewport keeps the layout a
- * function of the *graph*, which is what makes it cacheable at all.
+ * **New containment children start at their parent** (d3's own collapse/
+ * expand pattern): a newly visible node without a stored position enters the
+ * simulation at its parent's warm position, so the relaxation it needs is
+ * local — the collide force makes it step out among its siblings — instead of
+ * d3's phyllotaxis spiral dropping it across the graph and dragging the whole
+ * arrangement along.
+ *
+ * The viewport is **not** a parameter, deliberately. The layout is centred on
+ * the origin by `forceX()`/`forceY()`, and sigma's camera fits whatever extent
+ * it is handed — so feeding the real column width in would re-run the
+ * simulation on every divider drag to produce a picture the camera
+ * immediately normalises away. Keeping the layout a function of the *graph*
+ * alone is what makes it cacheable at all.
  */
 export function layoutFor(
   nodes: readonly WireGraphNode[],
   edges: readonly WireGraphEdge[],
   warm?: ReadonlyMap<string, Point>,
 ): Map<string, Point> {
-  const options: LayoutOptions = { ticks: LAYOUT_TICKS, seed: LAYOUT_SEED };
+  const seeded = new Map<string, Point>(warm ?? []);
+  if (seeded.size > 0) {
+    for (const e of edges) {
+      if (e.kind !== "contains" && e.kind !== "anchored-at") continue;
+      if (seeded.has(e.target)) continue;
+      const at = seeded.get(e.source);
+      if (at !== undefined) seeded.set(e.target, { x: at.x, y: at.y });
+    }
+  }
+  const options: LayoutOptions = { ticks: LAYOUT_TICKS, seed: LAYOUT_SEED, pinWarm: true };
+  if (seeded.size > 0) options.initial = seeded;
   return computeLayout(
-    { generatedAt: "", staleness: null, nodes: [...nodes], edges: [...edges] },
-    warm === undefined ? options : { ...options, initial: warm },
+    { generatedAt: "", staleness: null, nodes: [...nodes], edges: [...edges], contentDigest: "" },
+    options,
   );
 }