Neighborhood
-
-
Primary
-
Children
-
Edge
+
+ Focus
+ Outgoing
+ Incoming
@@ -1329,6 +1368,79 @@ _GRAPH_BROWSER_HTML = r"""
dialogDrag: null,
leaseTimer: null,
};
+ const relationStyles = Object.freeze({
+ contains: {
+ family: "Structure", color: "#60a5fa", dash: "", marker: "diamond-arrow",
+ flow: null,
+ },
+ defines: {
+ family: "Structure", color: "#38bdf8", dash: "7 3", marker: "diamond-arrow",
+ flow: null,
+ },
+ defined_in: {
+ family: "Structure", color: "#7dd3fc", dash: "3 3", marker: "open-arrow",
+ flow: null,
+ },
+ implemented_by: {
+ family: "Structure", color: "#818cf8", dash: "8 3", marker: "open-arrow",
+ flow: null,
+ },
+ calls: {
+ family: "Execution", color: "#34d399", dash: "", marker: "arrow",
+ flow: "forward",
+ },
+ dispatches_to: {
+ family: "Execution", color: "#2dd4bf", dash: "9 3", marker: "double-arrow",
+ flow: "forward",
+ },
+ launches: {
+ family: "Execution", color: "#a3e635", dash: "11 4", marker: "arrow",
+ flow: "forward",
+ },
+ activates: {
+ family: "Execution", color: "#facc15", dash: "4 3", marker: "double-arrow",
+ flow: "forward",
+ },
+ reads: {
+ family: "Data", color: "#22d3ee", dash: "3 4", marker: "circle-arrow",
+ flow: "reverse",
+ },
+ writes: {
+ family: "Data", color: "#fb7185", dash: "", marker: "square-arrow",
+ flow: "forward",
+ },
+ imports: {
+ family: "Dependency", color: "#fbbf24", dash: "3 3", marker: "open-arrow",
+ flow: "reverse",
+ },
+ depends_on: {
+ family: "Dependency", color: "#f59e0b", dash: "9 4", marker: "open-arrow",
+ flow: "reverse",
+ },
+ tested_by: {
+ family: "Evidence", color: "#c084fc", dash: "2 4", marker: "circle-arrow",
+ flow: null,
+ },
+ verifies: {
+ family: "Evidence", color: "#a78bfa", dash: "2 4", marker: "open-arrow",
+ flow: null,
+ },
+ documents: {
+ family: "Evidence", color: "#e879f9", dash: "2 5", marker: "open-arrow",
+ flow: null,
+ },
+ governs: {
+ family: "Evidence", color: "#f472b6", dash: "8 3 2 3", marker: "diamond-arrow",
+ flow: null,
+ },
+ relates_to: {
+ family: "Context", color: "#94a3b8", dash: "5 5", marker: "open-arrow",
+ flow: null,
+ },
+ });
+ const fallbackRelationColors = Object.freeze([
+ "#67e8f9", "#86efac", "#fde047", "#fdba74", "#f0abfc", "#a5b4fc",
+ ]);
const $ = (id) => document.getElementById(id);
const api = async (path) => {
let response;
@@ -1350,6 +1462,134 @@ _GRAPH_BROWSER_HTML = r"""
const text = escapeText(value);
return text.length > length ? `${text.slice(0, length - 1)}…` : text;
};
+ function relationHash(relation) {
+ let value = 2166136261;
+ for (const character of relation) {
+ value ^= character.codePointAt(0);
+ value = Math.imul(value, 16777619);
+ }
+ return value >>> 0;
+ }
+ function relationStyle(relation) {
+ if (relationStyles[relation]) return relationStyles[relation];
+ return {
+ family: "Other",
+ color: fallbackRelationColors[relationHash(relation) % fallbackRelationColors.length],
+ dash: "6 4",
+ marker: "open-arrow",
+ flow: null,
+ };
+ }
+ function relationLabel(relation) {
+ return relation.replaceAll("_", " ");
+ }
+ function relationMarkerId(relation) {
+ return `relation-marker-${relationHash(relation).toString(36)}`;
+ }
+ function markerArtwork(marker, color) {
+ const group = svgElement("g", {"aria-hidden": "true"});
+ const path = (data, attributes = {}) => group.append(svgElement("path", {
+ d: data,
+ ...attributes,
+ }));
+ if (marker === "open-arrow") {
+ path("M1 1 L9 5 L1 9", {
+ fill: "none", stroke: color, "stroke-width": "1.8",
+ "stroke-linecap": "round", "stroke-linejoin": "round",
+ });
+ } else if (marker === "double-arrow") {
+ path("M1 1 L5 5 L1 9 M5 1 L9 5 L5 9", {
+ fill: "none", stroke: color, "stroke-width": "1.6",
+ "stroke-linecap": "round", "stroke-linejoin": "round",
+ });
+ } else if (marker === "diamond-arrow") {
+ path("M0 5 L3 2 L6 5 L3 8 Z", {fill: color});
+ path("M6 1 L10 5 L6 9 Z", {fill: color});
+ } else if (marker === "circle-arrow") {
+ group.append(svgElement("circle", {
+ cx: "3.5", cy: "5", r: "2.3", fill: "none", stroke: color,
+ "stroke-width": "1.4",
+ }));
+ path("M6 1 L10 5 L6 9 Z", {fill: color});
+ } else if (marker === "square-arrow") {
+ group.append(svgElement("rect", {
+ x: "1", y: "2.5", width: "5", height: "5", rx: ".7", fill: color,
+ }));
+ path("M6 1 L10 5 L6 9 Z", {fill: color});
+ } else {
+ path("M1 1 L10 5 L1 9 Z", {fill: color});
+ }
+ return group;
+ }
+ function appendRelationMarker(defs, relation) {
+ const style = relationStyle(relation);
+ const marker = svgElement("marker", {
+ id: relationMarkerId(relation),
+ viewBox: "0 0 11 10",
+ refX: "10",
+ refY: "5",
+ markerWidth: "11",
+ markerHeight: "10",
+ orient: "auto",
+ markerUnits: "userSpaceOnUse",
+ });
+ marker.append(markerArtwork(style.marker, style.color));
+ defs.append(marker);
+ }
+ function relationSymbol(relation) {
+ const style = relationStyle(relation);
+ const svg = svgElement("svg", {
+ viewBox: "0 0 58 14",
+ class: "relationship-symbol",
+ role: "img",
+ "aria-label": `${relationLabel(relation)} relationship symbol`,
+ });
+ const line = svgElement("line", {
+ x1: "2", y1: "7", x2: "43", y2: "7",
+ stroke: style.color, "stroke-width": "2",
+ });
+ if (style.dash) line.setAttribute("stroke-dasharray", style.dash);
+ const marker = svgElement("g", {transform: "translate(45 2) scale(.9)"});
+ marker.append(markerArtwork(style.marker, style.color));
+ svg.append(line, marker);
+ return svg;
+ }
+ function renderRelationshipKey(edges) {
+ const counts = new Map();
+ for (const edge of edges) {
+ counts.set(edge.relation, (counts.get(edge.relation) || 0) + 1);
+ }
+ const entries = [...counts.entries()].sort((first, second) => {
+ const firstStyle = relationStyle(first[0]);
+ const secondStyle = relationStyle(second[0]);
+ return firstStyle.family.localeCompare(secondStyle.family)
+ || first[0].localeCompare(second[0]);
+ });
+ const container = $("relationship-key-list");
+ container.replaceChildren();
+ $("relationship-key-count").textContent = `${entries.length} visible`;
+ if (!entries.length) {
+ const empty = document.createElement("p");
+ empty.className = "relationship-key-empty";
+ empty.textContent = state.mode === "flow"
+ ? "No flow-capable relationships reach this focus."
+ : "No relationships in this neighborhood.";
+ container.append(empty);
+ return;
+ }
+ for (const [relation, count] of entries) {
+ const style = relationStyle(relation);
+ const item = document.createElement("li");
+ item.className = "relationship-key-item";
+ const label = document.createElement("span");
+ label.textContent = relationLabel(relation);
+ label.title = `${style.family} relationship`;
+ const total = document.createElement("small");
+ total.textContent = String(count);
+ item.append(relationSymbol(relation), label, total);
+ container.append(item);
+ }
+ }
function applyViewport() {
const view = state.viewport;
$("graph").setAttribute("viewBox", `${view.x} ${view.y} ${view.width} ${view.height}`);
@@ -1540,6 +1780,58 @@ _GRAPH_BROWSER_HTML = r"""
},
]));
}
+ function semanticFlowEdge(edge) {
+ const direction = relationStyle(edge.relation).flow;
+ if (direction === null) return null;
+ if (direction === "reverse") {
+ return {
+ ...edge,
+ source_id: edge.target_id,
+ target_id: edge.source_id,
+ stored_source_id: edge.source_id,
+ stored_target_id: edge.target_id,
+ };
+ }
+ return {
+ ...edge,
+ stored_source_id: edge.source_id,
+ stored_target_id: edge.target_id,
+ };
+ }
+ function buildFlowGraph(data) {
+ const semanticEdges = data.edges.map(semanticFlowEdge).filter(Boolean);
+ const upstreamHops = new Map([[data.root, 0]]);
+ let frontier = [data.root];
+ while (frontier.length) {
+ const next = [];
+ for (const targetId of frontier) {
+ for (const edge of semanticEdges) {
+ if (edge.target_id !== targetId || upstreamHops.has(edge.source_id)) continue;
+ upstreamHops.set(edge.source_id, upstreamHops.get(targetId) + 1);
+ next.push(edge.source_id);
+ }
+ }
+ frontier = next;
+ }
+ const nodes = data.nodes.filter((node) => upstreamHops.has(node.node_id));
+ const nodeIds = new Set(nodes.map((node) => node.node_id));
+ const edges = semanticEdges.filter(
+ (edge) => nodeIds.has(edge.source_id) && nodeIds.has(edge.target_id),
+ );
+ const topology = new Map(nodes.map((node) => [
+ node.node_id,
+ {
+ hop: upstreamHops.get(node.node_id),
+ role: node.node_id === data.root ? "primary" : "child",
+ },
+ ]));
+ return {
+ ...data,
+ nodes,
+ edges,
+ topology,
+ };
+ }
function layoutNodes(nodes, rootId, topology) {
const ordered = [...nodes].sort((a, b) => {
const first = topology.get(a.node_id);
@@ -1570,6 +1862,27 @@ _GRAPH_BROWSER_HTML = r"""
}
return positions;
}
+ function layoutFlow(nodes, rootId, topology) {
+ const layers = new Map();
+ for (const node of nodes) {
+ const hop = topology.get(node.node_id).hop;
+ if (!layers.has(hop)) layers.set(hop, []);
+ layers.get(hop).push(node);
+ }
+ const positions = new Map();
+ for (const [hop, layer] of [...layers.entries()].sort((a, b) => a[0] - b[0])) {
+ layer.sort((first, second) => first.node_id.localeCompare(second.node_id));
+ const spacing = 118;
+ const top = -((layer.length - 1) * spacing) / 2;
+ layer.forEach((node, index) => {
+ positions.set(node.node_id, {
+ x: node.node_id === rootId ? 0 : -hop * 230,
+ y: top + index * spacing,
+ });
+ });
+ }
+ return positions;
+ }
function darken(hex, amount) {
const value = Number.parseInt(hex.slice(1), 16);
const factor = 1 - Math.min(.5, Math.max(0, amount));
@@ -1593,11 +1906,23 @@ _GRAPH_BROWSER_HTML = r"""
};
}
function renderNeighborhood(data, topology) {
- const sections = [
- {role: "primary", label: "Primary focus"},
- {role: "child", label: "Children"},
- {role: "edge", label: "Edge & context"},
- ];
+ const sections = state.mode === "flow"
+ ? [
+ {role: "primary", label: "Flow destination"},
+ {role: "child", label: "Upstream lineage"},
+ ]
+ : [
+ {role: "primary", label: "Focus node"},
+ {role: "child", label: "Outgoing paths"},
+ {role: "edge", label: "Incoming & lateral"},
+ ];
+ $("neighborhood").querySelector(".neighborhood-title").textContent = state.mode === "flow"
+ ? "Upstream flow"
+ : "Neighborhood";
+ $("primary-role-label").textContent = state.mode === "flow" ? "Destination" : "Focus";
+ $("child-role-label").textContent = state.mode === "flow" ? "Upstream" : "Outgoing";
+ $("edge-role-label").textContent = "Incoming";
+ $("edge-role-label").closest("span").hidden = state.mode === "flow";
const container = $("neighborhood-sections");
container.replaceChildren();
for (const section of sections) {
@@ -1645,45 +1970,81 @@ _GRAPH_BROWSER_HTML = r"""
for (const [key, value] of Object.entries(attributes)) element.setAttribute(key, value);
return element;
}
- function renderGraph(data) {
+ function edgeEndpoints(source, target, sourceRadius, targetRadius) {
+ const deltaX = target.x - source.x;
+ const deltaY = target.y - source.y;
+ const distance = Math.hypot(deltaX, deltaY) || 1;
+ const unitX = deltaX / distance;
+ const unitY = deltaY / distance;
+ return {
+ x1: source.x + unitX * (sourceRadius + 4),
+ y1: source.y + unitY * (sourceRadius + 4),
+ x2: target.x - unitX * (targetRadius + 13),
+ y2: target.y - unitY * (targetRadius + 13),
+ };
+ }
+ function topologyRoleLabel(role) {
+ if (role === "primary") return state.mode === "flow" ? "flow destination" : "focus node";
+ if (role === "child") return state.mode === "flow" ? "upstream node" : "outgoing node";
+ return "incoming or lateral node";
+ }
+ function renderGraph(data, preserveSelection = false) {
state.graph = data;
state.root = data.root;
+ const selectedCandidate = preserveSelection
+ && data.nodes.some((node) => node.node_id === state.selectedNode)
+ ? state.selectedNode
+ : data.root;
+ const view = state.mode === "flow" ? buildFlowGraph(data) : data;
+ state.selectedNode = view.nodes.some((node) => node.node_id === selectedCandidate)
+ ? selectedCandidate
+ : view.root;
const svg = $("graph");
svg.replaceChildren();
- $("empty").hidden = data.nodes.length > 0;
- const topology = analyzeTopology(data);
- const positions = layoutNodes(data.nodes, data.root, topology);
+ $("empty").hidden = view.nodes.length > 0;
+ const topology = view.topology || analyzeTopology(view);
+ const positions = state.mode === "flow"
+ ? layoutFlow(view.nodes, view.root, topology)
+ : layoutNodes(view.nodes, view.root, topology);
state.positions = positions;
- state.selectedNode = data.root;
state.homeViewport = viewportForPositions(positions);
resetViewport();
- renderNeighborhood(data, topology);
+ renderNeighborhood(view, topology);
+ renderRelationshipKey(view.edges);
+ const definitions = svgElement("defs");
+ for (const relation of new Set(view.edges.map((edge) => edge.relation))) {
+ appendRelationMarker(definitions, relation);
+ }
const edgeLayer = svgElement("g");
const nodeLayer = svgElement("g");
- for (const edge of data.edges) {
+ for (const edge of view.edges) {
const source = positions.get(edge.source_id);
const target = positions.get(edge.target_id);
if (!source || !target) continue;
- const targetRole = topology.get(edge.target_id)?.role || "edge";
- const edgeRole = edge.source_id === data.root && targetRole === "child"
- ? "child-edge"
- : edge.target_id === data.root || targetRole === "edge"
- ? "context-edge"
- : "boundary-edge";
- edgeLayer.append(svgElement("line", {
- x1: source.x, y1: source.y, x2: target.x, y2: target.y,
- class: `edge ${edgeRole}`
- }));
- const label = svgElement("text", {
- x: (source.x + target.x) / 2,
- y: (source.y + target.y) / 2,
- class: "edge-label",
- "text-anchor": "middle"
+ const style = relationStyle(edge.relation);
+ const sourceRadius = edge.source_id === view.root ? 25 : 18;
+ const targetRadius = edge.target_id === view.root ? 25 : 18;
+ const points = edgeEndpoints(source, target, sourceRadius, targetRadius);
+ const line = svgElement("line", {
+ ...points,
+ class: "relationship-edge",
+ stroke: style.color,
+ "marker-end": `url(#${relationMarkerId(edge.relation)})`,
+ "data-relation": edge.relation,
});
- label.textContent = edge.relation;
+ if (style.dash) line.setAttribute("stroke-dasharray", style.dash);
+ edgeLayer.append(line);
+ const label = svgElement("text", {
+ x: (points.x1 + points.x2) / 2,
+ y: (points.y1 + points.y2) / 2 - 5,
+ class: "edge-label",
+ fill: style.color,
+ "text-anchor": "middle",
+ });
+ label.textContent = relationLabel(edge.relation);
edgeLayer.append(label);
}
- for (const node of data.nodes) {
+ for (const node of view.nodes) {
const point = positions.get(node.node_id);
if (!point) continue;
const topologyNode = topology.get(node.node_id);
@@ -1692,7 +2053,7 @@ _GRAPH_BROWSER_HTML = r"""
class: [
"node",
topologyNode.role,
- node.node_id === data.root ? "root" : "",
+ node.node_id === view.root ? "root" : "",
node.node_id === state.selectedNode ? "selected" : "",
].filter(Boolean).join(" "),
transform: `translate(${point.x} ${point.y})`,
@@ -1702,16 +2063,17 @@ _GRAPH_BROWSER_HTML = r"""
role: "button",
"aria-pressed": String(node.node_id === state.selectedNode),
"aria-label": [
- node.title, node.family, topologyNode.role, `${topologyNode.hop} hops`
+ node.title, node.family, topologyRoleLabel(topologyNode.role),
+ `${topologyNode.hop} hops`,
].join(", ")
});
group.append(svgElement("circle", {
- r: node.node_id === data.root ? 25 : 18,
+ r: node.node_id === view.root ? 25 : 18,
fill: palette.fill,
stroke: palette.stroke,
}));
group.append(svgElement("circle", {
- r: node.node_id === data.root ? 32 : 25,
+ r: node.node_id === view.root ? 32 : 25,
class: "selection-ring",
}));
const title = svgElement("text", {y: 35, "text-anchor": "middle"});
@@ -1740,7 +2102,7 @@ _GRAPH_BROWSER_HTML = r"""
});
nodeLayer.append(group);
}
- svg.append(edgeLayer, nodeLayer);
+ svg.append(definitions, edgeLayer, nodeLayer);
}
function renderDetails(details, node, data, interactiveBadges = false) {
details.replaceChildren();
@@ -1885,16 +2247,31 @@ _GRAPH_BROWSER_HTML = r"""
const data = await api(`node?${params}`);
renderGraph(data);
setStatus(`${data.nodes.length} nodes · ${data.edges.length} edges in neighborhood`);
- history.replaceState(null, "", `?node=${encodeURIComponent(nodeId)}&depth=${state.depth}`);
+ history.replaceState(
+ null,
+ "",
+ `?node=${encodeURIComponent(nodeId)}&depth=${state.depth}&view=${state.mode}`,
+ );
} catch (error) {
setStatus(error.message, true);
}
}
function setViewMode(mode) {
+ if (mode !== "nodes" && mode !== "flow") return;
state.mode = mode;
$("view-switch").dataset.mode = mode;
$("view-nodes").setAttribute("aria-pressed", String(mode === "nodes"));
$("view-flow").setAttribute("aria-pressed", String(mode === "flow"));
+ if (state.graph) {
+ renderGraph(state.graph, true);
+ const suffix = mode === "flow" ? "upstream flow" : "node neighborhood";
+ setStatus(`Showing ${suffix} for ${state.root}`);
+ history.replaceState(
+ null,
+ "",
+ `?node=${encodeURIComponent(state.root)}&depth=${state.depth}&view=${state.mode}`,
+ );
+ }
}
function clamp(value, minimum, maximum) {
return Math.min(maximum, Math.max(minimum, value));
@@ -2108,6 +2485,7 @@ _GRAPH_BROWSER_HTML = r"""
try {
const params = new URLSearchParams(location.search);
state.depth = Math.max(1, Number(params.get("depth")) || 1);
+ setViewMode(params.get("view") === "flow" ? "flow" : "nodes");
const overview = await api("overview");
renderOverview(overview);
startViewerLease();
diff --git a/tests/test_mcp_server.py b/tests/test_mcp_server.py
index c085608..1b28e8a 100644
--- a/tests/test_mcp_server.py
+++ b/tests/test_mcp_server.py
@@ -101,7 +101,7 @@ class DocForgeMcpTests(unittest.IsolatedAsyncioTestCase):
visualization = results[11].structuredContent["visualization"]
self.assertTrue(visualization["read_only"])
self.assertTrue(visualization["project_bound"])
- self.assertEqual("graph-browser@7", visualization["template"])
+ self.assertEqual("graph-browser@8", visualization["template"])
self.assertEqual("browser_lease", visualization["lifetime"]["policy"])
self.assertTrue(visualization["url"].startswith("http://127.0.0.1:"))
context = results[8].structuredContent
diff --git a/tests/test_visualization.py b/tests/test_visualization.py
index 80a1c6f..a20c874 100644
--- a/tests/test_visualization.py
+++ b/tests/test_visualization.py
@@ -91,12 +91,20 @@ class VisualizationTests(unittest.TestCase):
viewport_logic = script.split("function viewportForPositions", 1)[1].split(
"function selectNode", 1
)[0]
+ relation_constants = script.split("const relationStyles", 1)[1].split("const $", 1)[0]
+ relation_logic = script.split("function relationHash", 1)[1].split(
+ "function applyViewport", 1
+ )[0]
topology_logic = script.split("function analyzeTopology", 1)[1].split(
"function renderNeighborhood", 1
)[0]
harness = (
"const defaultViewport = Object.freeze({x: -600, y: -410, width: 1200, height: 820});\n"
- "function viewportForPositions"
+ "const relationStyles"
+ + relation_constants
+ + "function relationHash"
+ + relation_logic
+ + "function viewportForPositions"
+ viewport_logic
+ "function analyzeTopology"
+ topology_logic
@@ -141,6 +149,42 @@ const centered = viewportCenteredOn(
if (centered.width !== 500 || centered.height !== 300) fail("center preserves zoom");
if (centered.x !== positions.get("child-two").x - 250) fail("center x");
if (centered.y !== positions.get("child-two").y - 150) fail("center y");
+if (relationStyle("calls").family !== "Execution") fail("calls family");
+if (relationStyle("reads").flow !== "reverse") fail("reads flow direction");
+if (relationStyle("documents").flow !== null) fail("documents excluded from flow");
+if (relationStyle("unknown_relation").family !== "Other") fail("fallback relation family");
+const flowData = {
+ root: "primary",
+ depth: 2,
+ nodes: [
+ {node_id: "primary"},
+ {node_id: "caller"},
+ {node_id: "dependency"},
+ {node_id: "reader"},
+ {node_id: "document"},
+ ],
+ edges: [
+ {source_id: "caller", relation: "calls", target_id: "primary"},
+ {source_id: "primary", relation: "depends_on", target_id: "dependency"},
+ {source_id: "primary", relation: "reads", target_id: "reader"},
+ {source_id: "document", relation: "documents", target_id: "primary"},
+ ],
+};
+const flow = buildFlowGraph(flowData);
+const flowIds = new Set(flow.nodes.map((node) => node.node_id));
+if (!flowIds.has("caller") || !flowIds.has("dependency") || !flowIds.has("reader")) {
+ fail("upstream flow membership");
+}
+if (flowIds.has("document")) fail("evidence leaked into flow");
+const flowPositions = layoutFlow(flow.nodes, flow.root, flow.topology);
+if (flowPositions.get("primary").x !== 0) fail("flow destination position");
+if (flowPositions.get("caller").x >= flowPositions.get("primary").x) {
+ fail("flow upstream direction");
+}
+const dependencyEdge = flow.edges.find((edge) => edge.relation === "depends_on");
+if (dependencyEdge.source_id !== "dependency" || dependencyEdge.target_id !== "primary") {
+ fail("dependency semantic reversal");
+}
"""
)
result = subprocess.run(
@@ -188,6 +232,8 @@ if (centered.y !== positions.get("child-two").y - 150) fail("center y");
self.assertIn('id="view-nodes"', html)
self.assertIn('id="view-flow"', html)
self.assertIn('id="neighborhood-sections"', html)
+ self.assertIn('id="relationship-key"', html)
+ self.assertIn('id="relationship-key-list"', html)
self.assertNotIn('id="details"', html)
self.assertIn(".empty[hidden] { display: none; }", html)
self.assertIn("html, body { height: 100%; overflow: hidden; }", html)
@@ -204,11 +250,19 @@ if (centered.y !== positions.get("child-two").y - 150) fail("center y");
self.assertIn("beginDialogDrag", html)
self.assertIn('setupPanelResizer("left")', html)
self.assertIn('setupPanelResizer("right")', html)
- self.assertIn("Primary focus", html)
- self.assertIn("Edge & context", html)
+ self.assertIn("Focus node", html)
+ self.assertIn("Outgoing paths", html)
+ self.assertIn("Incoming & lateral", html)
+ self.assertNotIn(">Children<", html)
self.assertIn("distanceShade", html)
self.assertIn("viewportForPositions", html)
self.assertIn("centerSelectedNode", html)
+ self.assertIn("relationStyles", html)
+ self.assertIn("appendRelationMarker", html)
+ self.assertIn("renderRelationshipKey", html)
+ self.assertIn("semanticFlowEdge", html)
+ self.assertIn("buildFlowGraph", html)
+ self.assertIn("layoutFlow", html)
self.assertIn("filterByDescriptor", html)
self.assertIn("api(`filter?${params}`)", html)
self.assertIn('setViewMode("flow")', html)
diff --git a/uv.lock b/uv.lock
index adb2554..74ea04c 100644
--- a/uv.lock
+++ b/uv.lock
@@ -206,7 +206,7 @@ wheels = [
[[package]]
name = "docforge"
-version = "0.9.0"
+version = "0.10.0"
source = { editable = "." }
dependencies = [
{ name = "markdown-it-py" },