@exellix/graphs-studio-data-flow 0.1.0

package/src/informationFlow.js

@@ -0,0 +1,225 @@
+/**
+ * Design-time Information Flow view model — built on graph + buildGraphAnalysis output.
+ */
+import { getGraphNodes } from '@exellix/graph-engine/dist/src/inspection/index.js';
+import {
+  resolveMemorixItemDescriptorIdFromNode,
+} from './lib/memorixScopedConfig.js';
+import { getEntryRequestViewState, getResponseViewState } from './graphContractMetadata.js';
+import { downstreamReaders } from './ioLinking.js';
+import { classifyExecutionPath } from './pathClassification.js';
+import {
+  buildWebScopeCardSummary,
+  getPlanningSourceFamily,
+  webScopeSortKey,
+} from './planningSourceFamily.js';
+import {
+  formatWebScopingPlanningLabel,
+  getResolvedWebScopingPlanning,
+  isWebScopingPlanningIntentMode,
+  supportsWebScopingPlanning,
+} from './webScopingPlanning.js';
+
+/**
+ * @param {import('@exellix-refs').Graph} graph
+ * @param {import('./types.js').GraphAnalysisResult|null|undefined} graphAnalysis
+ */
+export function buildPlanningInformationFlow(graph, graphAnalysis) {
+  if (!graph || !graphAnalysis || graphAnalysis.status !== 'ok') return null;
+  const nodes = getGraphNodes(graph);
+  const ioLinks = graphAnalysis.ioLinks || [];
+  const nodeIO = graphAnalysis.nodeIO || {};
+  const virtualIO = graphAnalysis.graphInspection?.virtualIO;
+
+  const entryState = getEntryRequestViewState(graph.metadata);
+  const firstConsumers = Array.isArray(virtualIO?.firstWaveNodeIds)
+    ? [...virtualIO.firstWaveNodeIds]
+    : [];
+
+  const responseState = getResponseViewState(graph.metadata);
+  const canonicalFinalizerId = virtualIO?.canonicalFinalizerId ?? null;
+
+  /** @type {Map<string, { writtenBy: Set<string>, readBy: Set<string> }>} */
+  const pathIndex = new Map();
+
+  function touchPath(path) {
+    if (!pathIndex.has(path)) {
+      pathIndex.set(path, { writtenBy: new Set(), readBy: new Set() });
+    }
+    return pathIndex.get(path);
+  }
+
+  for (const link of ioLinks) {
+    touchPath(link.writePath).writtenBy.add(link.writtenBy);
+    touchPath(link.readPath).readBy.add(link.readBy);
+  }
+
+  const danglingByPath = new Map();
+  for (const d of graphAnalysis.danglingReads || []) {
+    const list = danglingByPath.get(d.path) || [];
+    list.push(d);
+    danglingByPath.set(d.path, list);
+  }
+  const orphanedByPath = new Map();
+  for (const o of graphAnalysis.orphanedWrites || []) {
+    const list = orphanedByPath.get(o.path) || [];
+    list.push(o);
+    orphanedByPath.set(o.path, list);
+  }
+
+  const seenPaths = new Set(pathIndex.keys());
+  for (const n of nodes) {
+    const io = nodeIO[n.id];
+    if (!io) continue;
+    for (const wr of io.writes || []) {
+      if (wr._inspectorOnly) continue;
+      seenPaths.add(wr.path);
+      touchPath(wr.path).writtenBy.add(n.id);
+    }
+    for (const rd of io.reads || []) {
+      if (rd._inspectorOnly) continue;
+      seenPaths.add(rd.path);
+      touchPath(rd.path).readBy.add(n.id);
+    }
+  }
+
+  const memoryObjects = [...seenPaths].sort().map((path) => {
+    const { namespace, classification, displayPath } = classifyExecutionPath(path);
+    const agg = pathIndex.get(path) || { writtenBy: new Set(), readBy: new Set() };
+    return {
+      path,
+      namespace,
+      classification,
+      displayPath,
+      writtenBy: [...agg.writtenBy],
+      readBy: [...agg.readBy],
+      dangling: (danglingByPath.get(path) || []).length > 0,
+      orphaned: (orphanedByPath.get(path) || []).length > 0,
+    };
+  });
+
+  const flowNodes = nodes.map((n) => {
+    const gr = n.metadata?.graphReadability || {};
+    const meta = n.metadata || {};
+    const tc =
+      n.taskConfiguration && typeof n.taskConfiguration === 'object' && !Array.isArray(n.taskConfiguration)
+        ? n.taskConfiguration
+        : {};
+    const bag = { ...meta, ...tc };
+    const role = inferInformationRole(n);
+    const io = nodeIO[n.id];
+    const downstreamConsumers = downstreamReaders(ioLinks, n.id);
+
+    let expectedReads = [];
+    if (Array.isArray(gr.reads)) {
+      expectedReads = gr.reads.map((x) => String(x).trim()).filter(Boolean);
+    } else if (typeof gr.reads === 'string') {
+      expectedReads = gr.reads
+        .split('\n')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    }
+
+    const title = typeof gr.title === 'string' ? gr.title : n.id;
+    const planningSourceFamily = getPlanningSourceFamily(n);
+    const webSummary =
+      planningSourceFamily === 'web-scope' ? buildWebScopeCardSummary(n) : null;
+    const webPlan = supportsWebScopingPlanning(n) ? getResolvedWebScopingPlanning(n) : null;
+    const webScopingPlanning = webPlan?.mode ?? null;
+    const webScopingPlanningSource = webPlan?.source ?? null;
+    const webScopingPlanningSearchText =
+      webScopingPlanning && isWebScopingPlanningIntentMode(webScopingPlanning)
+        ? `${formatWebScopingPlanningLabel(webScopingPlanning)} ${webScopingPlanning}`
+        : '';
+
+    return {
+      id: n.id,
+      role,
+      planningSourceFamily,
+      webScopeSummary: webSummary,
+      webScopeSortKey:
+        planningSourceFamily === 'web-scope' ? webScopeSortKey(n, title) : undefined,
+      webScopingPlanning,
+      webScopingPlanningSource,
+      webScopingPlanningSearchText,
+      title,
+      asks: typeof gr.asks === 'string' ? gr.asks : undefined,
+      kind: typeof gr.kind === 'string' ? gr.kind : undefined,
+      skillKey: n.skillKey,
+      nodeType: n.type,
+      scopingMapId: bag.scopingMapId,
+      memorixItemDescriptorId: resolveMemorixItemDescriptorIdFromNode(n),
+      entityIdPath: bag.entityIdPath,
+      expectedReads,
+      sourceContracts: (io?.reads || [])
+        .filter((r) => !r._inspectorOnly)
+        .map((r) => ({ path: r.path, source: r.source, tier: r.tier })),
+      writes: (io?.writes || [])
+        .filter((w) => !w._inspectorOnly)
+        .map((w) => ({ path: w.path, source: w.source, tier: w.tier })),
+      downstreamConsumers,
+      layer: io?.layer,
+    };
+  });
+
+  flowNodes.sort((a, b) => {
+    const order = {
+      'scoped-read': 0,
+      inference: 1,
+      routing: 2,
+      assembly: 3,
+      'write-back': 4,
+      finalizer: 5,
+    };
+    const da = order[a.role] ?? 9;
+    const db = order[b.role] ?? 9;
+    if (da !== db) return da - db;
+    if (a.role === 'scoped-read' && b.role === 'scoped-read') {
+      const ma = a.memorixItemDescriptorId || a.scopingMapId || '';
+      const mb = b.memorixItemDescriptorId || b.scopingMapId || '';
+      if (ma !== mb) return ma.localeCompare(mb);
+    }
+    if (a.planningSourceFamily === 'web-scope' && b.planningSourceFamily === 'web-scope') {
+      const wa = a.webScopeSortKey || '';
+      const wb = b.webScopeSortKey || '';
+      if (wa !== wb) return wa.localeCompare(wb);
+    }
+    return a.title.localeCompare(b.title);
+  });
+
+  return {
+    entry: {
+      summary: entryState.summary,
+      inputs: entryState.inputs,
+      exampleInput: entryState.exampleInput,
+      requiredPaths: entryState.requiredRequestPaths,
+      firstConsumers,
+    },
+    nodes: flowNodes,
+    memoryObjects,
+    response: {
+      summary: responseState.summary,
+      primaryPaths: responseState.primaryResponsePaths,
+      debugPaths: responseState.debugResponsePaths,
+      canonicalFinalizerId,
+    },
+  };
+}
+
+/**
+ * @returns {'scoped-read'|'inference'|'routing'|'assembly'|'write-back'|'finalizer'}
+ */
+function inferInformationRole(node) {
+  if (node.type === 'finalizer') return 'finalizer';
+  const sk = node.skillKey;
+  if (sk === 'scoped-data-reader') return 'scoped-read';
+  if (sk === 'scoped-answer-assembler') return 'assembly';
+  if (sk === 'scoped-answer-writer') return 'write-back';
+  if (sk === 'professional-answer') return 'inference';
+  if (sk === 'deterministic-rule') {
+    const k = String(node.metadata?.graphReadability?.kind || '').toLowerCase();
+    if (k.includes('rout')) return 'routing';
+    return 'inference';
+  }
+  return 'inference';
+}

package/src/informationFlowFocus.js

@@ -0,0 +1,332 @@
+/**
+ * Focus filters for the design-time Information Flow view model.
+ */
+import { getGraphNodes } from '@exellix/graph-engine/dist/src/inspection/index.js';
+import { downstreamReaders, upstreamWriters } from './ioLinking.js';
+import {
+  getResolvedWebScopingPlanning,
+  hasWebScopingPlanningIntent,
+  supportsWebScopingPlanning,
+} from './webScopingPlanning.js';
+import {
+  readNodeInputSynthesisEnabled,
+  readNodeWebScopeEnabled,
+} from './lib/nodeMetadataAccessors.js';
+
+/**
+ * @typedef {'graph' | 'scoping' | 'discovery' | 'selected-node'} InformationFlowFocus
+ */
+
+/**
+ * @param {string} a
+ * @param {string} b
+ */
+function pathsOverlap(a, b) {
+  if (a === b) return true;
+  const ad = a + '.';
+  const bd = b + '.';
+  return a.startsWith(bd) || b.startsWith(ad);
+}
+
+/**
+ * @param {string} path
+ * @param {Set<string>} memoryPaths
+ */
+function pathTouchesMemory(path, memoryPaths) {
+  for (const m of memoryPaths) {
+    if (pathsOverlap(path, m)) return true;
+  }
+  return false;
+}
+
+/** Focused flows use `informationFlowOutputSurface` for the output column — keep `response` inert. */
+function emptyFocusedResponse() {
+  return {
+    summary: '',
+    primaryPaths: [],
+    debugPaths: [],
+    canonicalFinalizerId: null,
+  };
+}
+
+/**
+ * @param {string} path
+ */
+function pathIsDiscoveryRelated(path) {
+  const p = String(path || '');
+  if (p.includes('_narrix')) return true;
+  if (p.includes('webContext')) return true;
+  if (p.includes('synthesizedContext')) return true;
+  if (p.includes('jobContext.webContext')) return true;
+  return false;
+}
+
+/**
+ * @param {object} rawNode
+ * @param {import('./types.js').ResolvedNodeIO|undefined} io
+ */
+function nodeIsDiscoverySeed(rawNode, io) {
+  if (supportsWebScopingPlanning(rawNode)) {
+    const { mode } = getResolvedWebScopingPlanning(rawNode);
+    if (mode === 'ai-decision' || mode === 'always') return true;
+  }
+  const m = rawNode.metadata?.narrix;
+  if (m && typeof m === 'object') {
+    if (m.datasetId || m.questionId || m.layer != null) return true;
+  }
+  if (readNodeWebScopeEnabled(rawNode)) return true;
+  if (readNodeInputSynthesisEnabled(rawNode)) return true;
+  if (!io) return false;
+  for (const r of io.reads || []) {
+    if (r._inspectorOnly) continue;
+    if (pathIsDiscoveryRelated(r.path)) return true;
+  }
+  for (const w of io.writes || []) {
+    if (w._inspectorOnly) continue;
+    if (pathIsDiscoveryRelated(w.path)) return true;
+  }
+  return false;
+}
+
+/**
+ * @param {Set<string>} nodeIds
+ * @param {Record<string, import('./types.js').ResolvedNodeIO>} nodeIO
+ * @param {object[]} ioLinks
+ */
+function collectPathsForNodeSet(nodeIds, nodeIO, ioLinks) {
+  /** @type {Set<string>} */
+  const paths = new Set();
+  for (const id of nodeIds) {
+    const io = nodeIO[id];
+    if (!io) continue;
+    for (const r of io.reads || []) {
+      if (!r._inspectorOnly) paths.add(r.path);
+    }
+    for (const w of io.writes || []) {
+      if (!w._inspectorOnly) paths.add(w.path);
+    }
+  }
+  for (const l of ioLinks) {
+    if (nodeIds.has(l.writtenBy) && nodeIds.has(l.readBy)) {
+      paths.add(l.writePath);
+      paths.add(l.readPath);
+    }
+  }
+  return paths;
+}
+
+/**
+ * @param {import('./types.js').GraphAnalysisResult|null|undefined} graphAnalysis
+ */
+function analysisOk(graphAnalysis) {
+  return graphAnalysis && graphAnalysis.status === 'ok';
+}
+
+/**
+ * Expand node id set by one hop upstream/downstream (excluding self-links counted as neighbors).
+ * @param {Set<string>} seeds
+ * @param {object[]} ioLinks
+ */
+function expandOneHop(seeds, ioLinks) {
+  const out = new Set(seeds);
+  for (const id of seeds) {
+    for (const w of upstreamWriters(ioLinks, id)) out.add(w);
+    for (const r of downstreamReaders(ioLinks, id)) out.add(r);
+  }
+  return out;
+}
+
+/**
+ * Add downstreamConsumers from flow nodes for ids in set.
+ * @param {Set<string>} ids
+ * @param {object[]} flowNodes
+ */
+function addDownstreamConsumers(ids, flowNodes) {
+  const flowById = new Map(flowNodes.map((n) => [n.id, n]));
+  for (const id of [...ids]) {
+    const fn = flowById.get(id);
+    const dc = fn?.downstreamConsumers || [];
+    for (const c of dc) ids.add(c);
+  }
+}
+
+/**
+ * @param {string[]} requiredPaths
+ * @param {Set<string>} nodeIds
+ * @param {Record<string, import('./types.js').ResolvedNodeIO>} nodeIO
+ */
+function filterEntryRequiredPaths(requiredPaths, nodeIds, nodeIO) {
+  /** @type {Set<string>} */
+  const referenced = new Set();
+  for (const id of nodeIds) {
+    const io = nodeIO[id];
+    if (!io) continue;
+    for (const r of io.reads || []) {
+      if (!r._inspectorOnly && r.path.startsWith('execution.input.')) referenced.add(r.path);
+    }
+  }
+  const list = Array.isArray(requiredPaths) ? requiredPaths : [];
+  const filtered = list.filter((p) => referenced.has(p) || pathTouchesMemory(p, referenced));
+  return filtered.length > 0 ? filtered : list.filter((p) => p.startsWith('execution.input.'));
+}
+
+/**
+ * @param {object} full - from buildPlanningInformationFlow
+ * @param {{ graph: import('@exellix-refs').Graph, graphAnalysis: import('./types.js').GraphAnalysisResult }} ctx
+ * @param {{ focus: InformationFlowFocus, selectedNodeId?: string }} options
+ */
+export function buildFocusedInformationFlow(full, ctx, options) {
+  const { graph, graphAnalysis } = ctx;
+  const { focus, selectedNodeId } = options;
+
+  if (!full || !analysisOk(graphAnalysis)) return full;
+
+  if (focus === 'graph') return full;
+
+  const nodeIO = graphAnalysis.nodeIO || {};
+  const ioLinks = graphAnalysis.ioLinks || [];
+  const rawNodes = getGraphNodes(graph);
+  const rawById = new Map(rawNodes.map((n) => [n.id, n]));
+  const flowNodes = full.nodes || [];
+
+  if (focus === 'selected-node') {
+    if (!selectedNodeId || !rawById.has(selectedNodeId)) return full;
+    /** @type {Set<string>} */
+    let ids = new Set([selectedNodeId]);
+    for (const w of upstreamWriters(ioLinks, selectedNodeId)) ids.add(w);
+    for (const r of downstreamReaders(ioLinks, selectedNodeId)) ids.add(r);
+    const memoryPaths = collectPathsForNodeSet(ids, nodeIO, ioLinks);
+    const nodes = flowNodes.filter((n) => ids.has(n.id));
+    const memoryObjects = (full.memoryObjects || []).filter((mo) => memoryPaths.has(mo.path));
+
+    const firstConsumers = (full.entry?.firstConsumers || []).filter((id) => ids.has(id));
+    let requiredPaths = full.entry?.requiredPaths || [];
+    if (firstConsumers.includes(selectedNodeId) || [...memoryPaths].some((p) => p.startsWith('execution.input.'))) {
+      requiredPaths = filterEntryRequiredPaths(requiredPaths, ids, nodeIO);
+    } else {
+      requiredPaths = [];
+    }
+
+    return {
+      entry: {
+        summary: full.entry?.summary ?? '',
+        inputs: full.entry?.inputs ?? [],
+        exampleInput: full.entry?.exampleInput ?? { format: 'json', value: '' },
+        requiredPaths,
+        firstConsumers,
+      },
+      nodes,
+      memoryObjects,
+      response: emptyFocusedResponse(),
+    };
+  }
+
+  if (focus === 'scoping') {
+    /** @type {Set<string>} */
+    const seeds = new Set();
+    for (const fn of flowNodes) {
+      if (fn.planningSourceFamily === 'scoped-read' || fn.planningSourceFamily === 'web-scope') {
+        seeds.add(fn.id);
+      }
+    }
+    for (const n of rawNodes) {
+      if (hasWebScopingPlanningIntent(n)) seeds.add(n.id);
+    }
+    if (seeds.size === 0) {
+      return {
+        entry: {
+          summary: full.entry?.summary
+            ? `${full.entry.summary}\n\n(No scoped reads, web-scoping sources, or design-time web-scoping intent in this graph.)`
+            : 'No scoped reads, web-scoping sources, or design-time web-scoping intent in this graph.',
+          inputs: full.entry?.inputs ?? [],
+          exampleInput: full.entry?.exampleInput ?? { format: 'json', value: '' },
+          requiredPaths: [],
+          firstConsumers: [],
+        },
+        nodes: [],
+        memoryObjects: [],
+        response: emptyFocusedResponse(),
+      };
+    }
+    const ids = expandOneHop(seeds, ioLinks);
+    addDownstreamConsumers(ids, flowNodes);
+
+    const memoryPaths = collectPathsForNodeSet(ids, nodeIO, ioLinks);
+    const nodes = flowNodes.filter((n) => ids.has(n.id));
+    const memoryObjects = (full.memoryObjects || []).filter((mo) => memoryPaths.has(mo.path));
+
+    const firstConsumers = (full.entry?.firstConsumers || []).filter(
+      (id) => ids.has(id) || seeds.has(id)
+    );
+    let requiredPaths = filterEntryRequiredPaths(full.entry?.requiredPaths || [], ids, nodeIO);
+    if (requiredPaths.length === 0) {
+      requiredPaths = (full.entry?.requiredPaths || []).filter((p) => p.startsWith('execution.input.'));
+    }
+
+    return {
+      entry: {
+        summary: full.entry?.summary ?? '',
+        inputs: full.entry?.inputs ?? [],
+        exampleInput: full.entry?.exampleInput ?? { format: 'json', value: '' },
+        requiredPaths,
+        firstConsumers,
+      },
+      nodes,
+      memoryObjects,
+      response: emptyFocusedResponse(),
+    };
+  }
+
+  if (focus === 'discovery') {
+    /** @type {Set<string>} */
+    const seeds = new Set();
+    for (const n of rawNodes) {
+      if (nodeIsDiscoverySeed(n, nodeIO[n.id])) seeds.add(n.id);
+    }
+    if (seeds.size === 0) {
+      return {
+        entry: {
+          summary: full.entry?.summary
+            ? `${full.entry.summary}\n\n(No discovery signals — add taskConfiguration.narrix or discovery-related I/O.)`
+            : 'No discovery signals in this graph yet.',
+          inputs: full.entry?.inputs ?? [],
+          exampleInput: full.entry?.exampleInput ?? { format: 'json', value: '' },
+          requiredPaths: (full.entry?.requiredPaths || []).filter((p) => p === 'execution.input.raw' || p.includes('raw')),
+          firstConsumers: [],
+        },
+        nodes: [],
+        memoryObjects: [],
+        response: emptyFocusedResponse(),
+      };
+    }
+    const ids = expandOneHop(seeds, ioLinks);
+    addDownstreamConsumers(ids, flowNodes);
+
+    const memoryPaths = collectPathsForNodeSet(ids, nodeIO, ioLinks);
+    const nodes = flowNodes.filter((n) => ids.has(n.id));
+    const memoryObjects = (full.memoryObjects || []).filter((mo) => memoryPaths.has(mo.path));
+
+    const firstConsumers = (full.entry?.firstConsumers || []).filter((id) => ids.has(id));
+    let requiredPaths = (full.entry?.requiredPaths || []).filter(
+      (p) => p === 'execution.input.raw' || p.startsWith('execution.input.') && memoryPaths.has(p)
+    );
+    if (requiredPaths.length === 0) {
+      requiredPaths = (full.entry?.requiredPaths || []).filter((p) => p.startsWith('execution.input.'));
+    }
+
+    return {
+      entry: {
+        summary: full.entry?.summary ?? '',
+        inputs: full.entry?.inputs ?? [],
+        exampleInput: full.entry?.exampleInput ?? { format: 'json', value: '' },
+        requiredPaths,
+        firstConsumers,
+      },
+      nodes,
+      memoryObjects,
+      response: emptyFocusedResponse(),
+    };
+  }
+
+  return full;
+}

package/src/informationFlowLayerDocument.js

@@ -0,0 +1,69 @@
+/** Editable Information Flow layer document schema helpers. */
+
+export const DATA_FLOW_LAYER_FORMAT = 'graphs-studio.data-flow-layer/v1';
+
+/**
+ * @param {object} input
+ * @param {string} input.graphId
+ * @param {string} input.graphVersionHash
+ * @param {Record<string, unknown>} input.informationFlow
+ * @param {Record<string, unknown>} [input.overrides]
+ */
+export function buildInformationFlowLayerDocument(input) {
+  return {
+    layerKey: `${input.graphId}::${input.graphVersionHash}`,
+    graphId: input.graphId,
+    graphVersionHash: input.graphVersionHash,
+    formatVersion: DATA_FLOW_LAYER_FORMAT,
+    informationFlow: input.informationFlow,
+    overrides: input.overrides ?? {},
+    focusState: 'graph',
+    syncState: 'clean',
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+/**
+ * Apply editable data-flow layer fields back to graph document (entry/response metadata).
+ * @param {Record<string, unknown>} layer
+ * @param {Record<string, unknown>} graphDoc
+ * @returns {Record<string, unknown>}
+ */
+export function applyInformationFlowLayerToGraph(layer, graphDoc) {
+  const next = structuredClone(graphDoc);
+  const overrides = layer?.overrides && typeof layer.overrides === 'object' ? layer.overrides : {};
+  const graph = next.graph && typeof next.graph === 'object' ? next.graph : next;
+  if (!graph.metadata || typeof graph.metadata !== 'object') graph.metadata = {};
+
+  if (overrides.entryRequest && typeof overrides.entryRequest === 'object') {
+    graph.metadata.entryRequest = {
+      ...(graph.metadata.entryRequest && typeof graph.metadata.entryRequest === 'object'
+        ? graph.metadata.entryRequest
+        : {}),
+      ...overrides.entryRequest,
+    };
+  }
+  if (overrides.graphResponse && typeof overrides.graphResponse === 'object') {
+    graph.metadata.graphResponse = {
+      ...(graph.metadata.graphResponse && typeof graph.metadata.graphResponse === 'object'
+        ? graph.metadata.graphResponse
+        : {}),
+      ...overrides.graphResponse,
+    };
+  }
+  if (Array.isArray(overrides.nodePlanningPatches)) {
+    const nodes = Array.isArray(graph.nodes) ? graph.nodes : [];
+    for (const patch of overrides.nodePlanningPatches) {
+      if (!patch || typeof patch !== 'object' || typeof patch.nodeId !== 'string') continue;
+      const node = nodes.find((n) => n && n.id === patch.nodeId);
+      if (!node) continue;
+      if (!node.metadata || typeof node.metadata !== 'object') node.metadata = {};
+      if (patch.planning && typeof patch.planning === 'object') {
+        node.metadata.planning = { ...(node.metadata.planning ?? {}), ...patch.planning };
+      }
+    }
+    graph.nodes = nodes;
+  }
+  if (next.graph) next.graph = graph;
+  return next;
+}