@rokkit/graph 1.6.0 → 1.7.0

package/dist/layout/types.d.ts

@@ -21,6 +21,17 @@ export type Card = {
      * hardcoded oklch angle baked into the layout.
      */
     groupIndex?: number;
+    /**
+     * Degrees to rotate this node's label so it reads outward from a rim, already flipped on
+     * the left half so nothing is upside down.
+     *
+     * The layout knows the angle it placed the node at; the renderer would have to re-derive
+     * it from x/y and the canvas centre, which is the kind of geometry a component should not
+     * be doing. Absent on every layout that is not radial.
+     */
+    labelAngle?: number;
+    /** Which way the label runs from the dot — `end` on the left half of the circle. */
+    labelSide?: 'start' | 'end';
 };
 export type Cluster = {
     name: string;
@@ -47,6 +58,51 @@ export type Cluster = {
     depth?: number;
     /** Name of the enclosing cluster, for a depth-1 box. */
     parent?: string;
+    /**
+     * What to show after the name, when the layout has something better than a child count.
+     *
+     * A number beside a box reads as the thing driving its size, so in a layout where AREA
+     * encodes a measure the count is actively misleading — `components · 63` was 63 files in a
+     * box sized by 63 declarations, and the two being equal was a coincidence. A layout that
+     * sizes by a measure says so here; one that does not leaves it unset and the count stands.
+     */
+    caption?: string;
+    /**
+     * The node this box IS, when it is one. Set on a childless box in a containment layout;
+     * absent on a region, which is not selectable because it is not a thing.
+     *
+     * A treemap is a hierarchy of ONE shape — a box with a label and an area — so a leaf is a
+     * cluster too rather than a node card. Emitting the card put two structures in one nesting
+     * and dragged the card's furniture in with it: a codebase module has no rows, so every leaf
+     * rendered a literal `0` beside its name. Identity survives here instead.
+     */
+    nodeId?: string;
+    /** The node's kind, for colour, when this box is a node. */
+    kind?: string;
+    /**
+     * Which entry of the group ramp this box takes its colour from, when that is not its own
+     * name.
+     *
+     * A containment layout nests boxes many levels deep, and only the outermost ones are group
+     * names the ramp knows. Looked up by its own name, every descendant falls through to the
+     * default — which is how a sunburst's outer ring came out uniformly grey while the inner
+     * ring was correctly coloured. Inheriting the outermost ancestor's key makes a whole
+     * subtree read as one region, which is the thing the reader is tracing.
+     */
+    ramp?: string;
+    /**
+     * Polar geometry, when the layout draws this box as a WEDGE rather than a rectangle.
+     *
+     * Angles are radians from 3 o'clock, radii are from the canvas centre. Kept as numbers
+     * rather than a path string so the layout stays DOM-free and unit-testable to exact
+     * radians — building the arc is the renderer's job.
+     */
+    wedge?: {
+        r0: number;
+        r1: number;
+        a0: number;
+        a1: number;
+    };
 };
 /**
  * Which node property a layout groups on. Both already exist on `GraphNode`, so nesting
@@ -63,6 +119,13 @@ export type RoutedEdge = {
     /** GraphEdge.relation — the consumer's own verb, carried through for theming. */
     relation?: string;
     self: boolean;
+    /**
+     * Set when a layered layout had to reverse this edge to rank the graph — a mutual foreign
+     * key, which a real schema has. It is still drawn, and still leaves right and enters left,
+     * so it is the one connector that visibly doubles back. A theme distinguishes it rather
+     * than the reader wondering why one link behaves differently.
+     */
+    back?: boolean;
     x1: number;
     y1: number;
     x2: number;
@@ -70,6 +133,30 @@ export type RoutedEdge = {
     /** 1 = right side of the card, -1 = left. */
     s1: number;
     s2: number;
+    /**
+     * A ready-made path, when the shape depends on more than the two endpoints.
+     *
+     * `edgePath` only ever sees the ends, which is enough for a curve or a right-angle route.
+     * A bundled edge follows the whole chain of ancestors between its endpoints, so the layout
+     * that knows that chain builds the path and the renderer draws what it is given.
+     */
+    path?: string;
+};
+/**
+ * One column of a multi-column layout, with the heading it needs to be readable.
+ *
+ * Three columns get away with none — the focus is visibly central, so the sides are obvious.
+ * Five do not: without headings a depth-2 portrait is ambiguous about which direction is
+ * which, and the reader has to trace an arrow to find out.
+ */
+export type Column = {
+    x: number;
+    /** Carried here so the view needs no layout constant to size a heading. */
+    w: number;
+    depth: number;
+    /** `in` = things that reach the focus, `out` = things it reaches, `focus` = the centre. */
+    side: 'in' | 'out' | 'focus';
+    label: string;
 };
 export type Cards = Record<string, Card>;
 export type Size = {
@@ -100,11 +187,65 @@ export type LayoutOptions = {
      * and the layout runs its original single-level path untouched.
      */
     nestBy?: NodeAxis;
+    /**
+     * What `points` sizes a node by. `degree` (the default) counts edges; `weight` reads
+     * `GraphNode.weight`.
+     *
+     * Degree is a good default and is not always the measure the reader is asking about — a
+     * 40-file module with few cross-edges should not render smaller than a 2-file one that
+     * happens to be chatty.
+     */
+    sizeBy?: string;
+    /**
+     * How the measure maps onto area. `linear` (the default), or `log` for a measure spanning
+     * orders of magnitude — declaration counts across a real repo span three or four, and
+     * linear flattens everything below the top few onto the minimum.
+     */
+    sizeScale?: 'linear' | 'log';
+    /**
+     * `neighborhood` only — how many hops out from the focus. Defaults to 1.
+     *
+     * One hop answers "what touches this". Two answers "what does changing this reach", which
+     * is the question a reader has before editing something.
+     */
+    depth?: number;
+    /**
+     * `world` only — the subtree to render as the whole canvas. `[]` is the root.
+     *
+     * This is DRILLING, not zooming: it re-runs the layout with a new root so the subtree gets
+     * the full canvas and its own children become visible. Zoom magnifies what is already
+     * there, which at world scale is a field of sub-pixel boxes.
+     */
+    focusPath?: string[];
+    /** `world` only — how many levels below the focus to MATERIALISE. Defaults to 2. */
+    levels?: number;
+    /**
+     * `radial` only — `tree` (the default) reads radius as DEPTH; `dendrogram` pins every
+     * leaf to the rim so leaves are compared against each other.
+     */
+    radialMode?: 'tree' | 'dendrogram';
+    /**
+     * `structure` only — how hard edges are pulled onto the tree, 0..1.
+     *
+     * 0 is a straight chord and 1 is the full route through the hierarchy. The default of 0.85
+     * is Holten's, and what the Sensei board's Straight/Bundled toggle switches between.
+     */
+    bundleTension?: number;
+    /**
+     * `radial` only — the node to treat as the centre, which is what drilling into a crate
+     * does. Its subtree becomes the whole picture.
+     *
+     * Deliberately NOT `focus`: that one defaults to the SELECTION, so clicking a node to
+     * highlight it would silently re-root the diagram.
+     */
+    root?: string | null;
 };
 export type LayoutResult = {
     clusters: Cluster[];
     cards: Cards;
     edges: RoutedEdge[];
+    /** Column headings, when the layout has columns. Empty for the grid layouts. */
+    columns?: Column[];
     size: Size;
 };
 /**

package/dist/layout/world.d.ts

@@ -0,0 +1,9 @@
+import type { LayoutFn } from './types.js';
+/**
+ * Containment as area.
+ *
+ * `focusPath` scopes the canvas to a subtree — the drill-down operation — and `levels` caps
+ * how far below it is built. Every box is a cluster whatever its depth, so the outermost
+ * materialised level is what a reader clicks.
+ */
+export declare const world: LayoutFn;

package/dist/layout/world.js

@@ -0,0 +1,144 @@
+/* The world view: containment as nested rectangles, area ∝ measure.
+ *
+ * Two rules do the work, and the second is the one that makes it survive real data.
+ *
+ * 1. A box's area is what it CONTAINS. That is the question the view answers — where is the
+ *    mass — and it is why the tree sums subtrees rather than counting nodes.
+ *
+ * 2. Only `levels` are MATERIALISED. The cost of 1.18M nodes is in building them, not in
+ *    packing them, so the layout refuses to build what it is not showing. Descending is a
+ *    re-layout with a new root, not a zoom: `Graph`'s zoom is a scale transform over the whole
+ *    canvas, and at that size every box is sub-pixel — the exact failure `points.ts` documents
+ *    for cards.
+ *
+ * Rectangles rather than circles, decided in docs/design/24-world-view.md: a circular container
+ * discards 1 - pi/4 = 21% of its bounding box before anything is placed in it, nesting
+ * multiplies that per level, and a rect holds a legible label where a circle does not. You
+ * have to be able to read what you are about to click.
+ */
+import { buildTree, findNode } from '../model/tree.js';
+import { squarify } from './squarify.js';
+import { warnUnknownOptions } from './options.js';
+/** Canvas the layout lays out into. Fit-to-container scales it; the ratios are what matter. */
+const CANVAS = { w: 1200, h: 800 };
+/** Inset of a container's children, leaving room for its own border. */
+const PAD = 4;
+/** Room above a container's children for its label. */
+const TITLE = 16;
+/**
+ * Area floor, as a share of one child's EQUAL slice of its parent.
+ *
+ * Exact proportion gives a zero-measure node no box at all, which reads as missing rather than
+ * as unmeasured — and "unmeasured" is a normal state in a partially-indexed graph: 79 of
+ * rokkit's own 470 modules have degree 0.
+ *
+ * Measured against the equal slice rather than against the TOTAL, because the floor is applied
+ * per child and so sums with the child count. A flat `total * k` is therefore self-defeating
+ * exactly where it is needed: at two children it costs 2k of the canvas and leaves a 2px
+ * hairline, and at 470 it claims 470k — nearly the whole canvas — and proportion stops reading
+ * altogether. Against the equal slice the total floor is at most `k` whatever n is.
+ */
+const MIN_EQUAL_SHARE = 0.12;
+/** Walk the materialised levels, squarifying each container's children into its own rect. */
+function place(node, rect, ctx) {
+    const { levels, out, parent, origin, ramp } = ctx;
+    if (levels <= 0 || node.children.length === 0)
+        return;
+    // Children are inset for the parent's border and label strip. Below that the box is all
+    // chrome and no content, so it stops rather than rendering a frame around nothing.
+    const inner = {
+        x: rect.x + PAD,
+        y: rect.y + PAD + TITLE,
+        w: rect.w - PAD * 2,
+        h: rect.h - PAD * 2 - TITLE
+    };
+    if (inner.w <= 0 || inner.h <= 0)
+        return;
+    const total = node.children.reduce((sum, c) => sum + Math.max(c.value, 0), 0);
+    const equal = total / node.children.length;
+    const placed = squarify(node.children, inner, equal * MIN_EQUAL_SHARE);
+    for (const { item, rect: box } of placed) {
+        // Depth is RELATIVE to the focus, so the outermost rendered box is always 0 whatever
+        // the reader has drilled into. A renderer styles by "how deep in this view", not by
+        // "how deep in the whole tree", and the same convention holds in `nested.ts`.
+        // The outermost box names the ramp entry; everything under it inherits, so a whole
+        // subtree reads as one region instead of every descendant falling through to the
+        // default colour.
+        const key = ramp ?? item.label;
+        out.push({ tree: item, rect: box, depth: node.path.length - origin, parent, ramp: key });
+        place(item, box, { levels: levels - 1, out, parent: item.id, origin, ramp: key });
+    }
+}
+/** Compact enough to sit in a label strip: 1200 reads as 1.2k. */
+function compact(value) {
+    if (value >= 1_000_000)
+        return `${(value / 1_000_000).toFixed(1)}M`;
+    if (value >= 1000)
+        return `${(value / 1000).toFixed(1)}k`;
+    return String(Math.round(value));
+}
+/**
+ * Every placed box, leaf or region, as the SAME shape.
+ *
+ * A treemap is a hierarchy of one thing: a box with a label and an area. Emitting a leaf as a
+ * node card and a region as a label box put two visual structures inside one nesting, which
+ * reads as two unrelated kinds of object rather than as depth — and it dragged the card's
+ * furniture along: icon, kind tag and a row count, where a codebase module has no rows and so
+ * showed a literal `0` beside its name.
+ *
+ * A childless box keeps its node's id and kind, so uniform structure costs no identity: the
+ * box is still selectable and still colours by what it is.
+ */
+function clusterOf(entry, groupIndex) {
+    const leaf = entry.tree.children.length === 0 ? entry.tree.node : undefined;
+    return {
+        name: entry.tree.label,
+        // The measure, not the child count: this box's area IS its value, so that is the
+        // number a reader should see beside it.
+        caption: compact(entry.tree.value),
+        parent: entry.parent,
+        depth: entry.depth,
+        ramp: entry.ramp,
+        nodeId: leaf?.id,
+        kind: leaf?.kind,
+        list: entry.tree.children.map((c) => c.node).filter((n) => n !== undefined),
+        count: entry.tree.children.length,
+        groupIndex,
+        x: entry.rect.x,
+        y: entry.rect.y,
+        w: entry.rect.w,
+        h: entry.rect.h
+    };
+}
+/**
+ * Containment as area.
+ *
+ * `focusPath` scopes the canvas to a subtree — the drill-down operation — and `levels` caps
+ * how far below it is built. Every box is a cluster whatever its depth, so the outermost
+ * materialised level is what a reader clicks.
+ */
+export const world = (model, options) => {
+    warnUnknownOptions(options, 'world');
+    const tree = buildTree(model, { measure: options.sizeBy ?? 'weight' });
+    const root = findNode(tree, options.focusPath ?? []);
+    if (!root || root.children.length === 0) {
+        return { clusters: [], cards: {}, edges: [], size: { w: 0, h: 0 } };
+    }
+    const placed = [];
+    place(root, { x: 0, y: 0, w: CANVAS.w, h: CANVAS.h }, {
+        levels: options.levels ?? 2,
+        out: placed,
+        origin: root.path.length
+    });
+    // Edges are deliberately absent: containment IS the relationship here, and at world scale
+    // the adjacency graph cannot be drawn. Cross-container aggregation is its own design.
+    //
+    // `cards` is empty by construction rather than by filtering — there is no box in this
+    // layout that a card could represent.
+    return {
+        clusters: placed.map(clusterOf),
+        cards: {},
+        edges: [],
+        size: CANVAS
+    };
+};

package/dist/model/normalize.js

@@ -3,6 +3,39 @@ const BADGE_ORDER = ['pk', 'fk', 'uq', 'nn'];
 function str(value) {
     return typeof value === 'string' ? value : undefined;
 }
+/**
+ * Named quantities, keeping only the finite numbers — a measure is a quantity, and a string
+ * or a NaN reaching a size calculation produces a card with no width at all.
+ */
+function measures(value) {
+    if (value === null || typeof value !== 'object')
+        return undefined;
+    const out = {};
+    for (const [key, raw] of Object.entries(value)) {
+        const n = num(raw);
+        if (n !== undefined)
+            out[key] = n;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+/**
+ * A containment path, from either an array or a delimited string.
+ *
+ * A file path arrives as `'src/lib/parse.ts'`; requiring every consumer to split it is asking
+ * for the same three lines everywhere. Empty segments are dropped, so a leading, trailing or
+ * doubled separator is harmless rather than producing a nameless container.
+ */
+function segments(value, delimiter) {
+    const raw = typeof value === 'string' ? value.split(delimiter) : value;
+    if (!Array.isArray(raw))
+        return undefined;
+    const parts = raw.filter((v) => typeof v === 'string' && v.length > 0);
+    return parts.length > 0 ? parts : undefined;
+}
+/** A finite number, or nothing. NaN and Infinity are not measures. */
+function num(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
 function pick(row, path, fallbackKey) {
     return readPath(row, path ?? fallbackKey);
 }
@@ -26,7 +59,17 @@ function buildRows(source, fields) {
 }
 // Every node-level field the canonical model reads. A claimed key must NOT also
 // land in `meta`, or the same value sits in two places and the two can drift.
-const CLAIMED_NODE_KEYS = ['id', 'label', 'group', 'kind', 'rows', 'note'];
+const CLAIMED_NODE_KEYS = [
+    'id',
+    'label',
+    'group',
+    'kind',
+    'weight',
+    'path',
+    'measures',
+    'rows',
+    'note'
+];
 function buildMeta(source, fields) {
     if (source === null || typeof source !== 'object')
         return {};
@@ -51,6 +94,9 @@ function buildNode(source, fields) {
         label,
         group,
         kind: str(pick(source, fields.kind, 'kind')),
+        weight: num(pick(source, fields.weight, 'weight')),
+        path: segments(pick(source, fields.path, 'path'), fields.pathDelimiter ?? '/'),
+        measures: measures(pick(source, fields.measures, 'measures')),
         rows: buildRows(source, fields),
         note: str(pick(source, fields.note, 'note')),
         meta: buildMeta(source, fields)

package/dist/model/tree.d.ts

@@ -0,0 +1,27 @@
+import type { GraphModel, GraphNode } from '../types.js';
+export type TreeNode = {
+    /** Path joined by `/`. The root is `''`. */
+    id: string;
+    label: string;
+    /** Full path to this node, outermost first. Empty at the root. */
+    path: string[];
+    /** 0 at the root. A layout materialising N levels reads this. */
+    depth: number;
+    /** The real node behind this box. Absent only on a container nothing declared. */
+    node?: GraphNode;
+    children: TreeNode[];
+    /** This subtree's summed measure, including its own leaves. */
+    value: number;
+};
+/**
+ * The containment tree for a model.
+ *
+ * Containment is PREFIX: a node whose path extends past another's is inside it. That is what
+ * makes a container an ordinary node — it keeps its own id, label, note and edges, and there
+ * is no convention to satisfy. A prefix nothing declares is synthesised.
+ */
+export declare function buildTree(model: GraphModel, options?: {
+    measure?: string;
+}): TreeNode;
+/** The node at `path`, or undefined. */
+export declare function findNode(root: TreeNode, path: string[]): TreeNode | undefined;

package/dist/model/tree.js

@@ -0,0 +1,182 @@
+/* The containment tree, derived from `GraphNode.path`.
+ *
+ * Three jobs, none of them geometry:
+ *
+ *   1. SYNTHESISE the containers the data implies but never states. A codebase indexes files
+ *      and symbols; the folders between them are implied by the path, and requiring a node per
+ *      folder would make the model refuse data that is perfectly well-formed.
+ *   2. FOLD a container that adds no level. `src › lib › index.ts` with nothing else at either
+ *      level is three boxes for one file — that is punctuation, not a hierarchy.
+ *   3. SUM each subtree's measure, so a container's area can be what it CONTAINS rather than
+ *      what it is.
+ *
+ * Pure and deterministic like every layout here, and deliberately separate from
+ * `normalizeGraph`: most graphs are flat, and building a tree they never read would be waste
+ * on every re-render.
+ */
+const ROOT = '';
+/** A synthesised box's id is its path joined. A declared node replaces it with its own. */
+const idOf = (path) => path.join('/');
+function container(path) {
+    return {
+        id: idOf(path),
+        label: path[path.length - 1] ?? ROOT,
+        path,
+        depth: path.length,
+        children: [],
+        value: 0
+    };
+}
+/**
+ * Walk to `path`, synthesising any box along the way that nothing has declared yet.
+ *
+ * Matched on the path SEGMENT, not on the label: a declared node may label its box anything
+ * ('Lexer' for the segment 'lexer'), and matching on label would then fail to find the box it
+ * had already created.
+ */
+function ensure(root, path) {
+    let current = root;
+    for (let i = 0; i < path.length; i++) {
+        const segment = path[i];
+        let next = current.children.find((c) => c.path[c.path.length - 1] === segment);
+        if (!next) {
+            next = container(path.slice(0, i + 1));
+            current.children.push(next);
+        }
+        current = next;
+    }
+    return current;
+}
+/**
+ * The number a node contributes to its subtree.
+ *
+ * `weight` is the named default, so a caller that shipped against #161 is unaffected; any
+ * other name reads the measures bag. Absent is 0 rather than a break — "unknown" is a normal
+ * state in a partially-indexed graph.
+ */
+function measureOf(node, measure, degree) {
+    if (measure === 'degree')
+        return degree.get(node.id) ?? 0;
+    if (measure === 'weight')
+        return node.weight ?? 0;
+    return node.measures?.[measure] ?? 0;
+}
+/**
+ * Edges touching each node.
+ *
+ * `degree` is the package-wide default for `sizeBy`, so the tree has to understand it or a
+ * caller that never set a measure gets a silent zero for every node — and a tree of zeroes
+ * falls through to an even split, which renders a 27:1 ratio as 1:1 with no error anywhere.
+ */
+function degreesIn(model) {
+    const degree = new Map();
+    for (const edge of model.edges) {
+        if (edge.unplaced)
+            continue;
+        degree.set(edge.source, (degree.get(edge.source) ?? 0) + 1);
+        if (edge.target !== edge.source) {
+            degree.set(edge.target, (degree.get(edge.target) ?? 0) + 1);
+        }
+    }
+    return degree;
+}
+/**
+ * Attach a real node to the box at its own path.
+ *
+ * The box may already exist — synthesised by a descendant that arrived first — in which case
+ * this fills in its identity rather than creating a sibling. That is the whole of "a container
+ * is an ordinary node": no claiming, no id convention, just the same walk.
+ */
+function attach(root, node, measure, degree) {
+    const box = ensure(root, node.path ?? []);
+    if (box === root) {
+        // No path: a root-level leaf, not a redefinition of the root itself.
+        root.children.push({
+            id: node.id,
+            label: node.label,
+            path: [],
+            depth: 1,
+            node,
+            children: [],
+            value: measureOf(node, measure, degree)
+        });
+        return;
+    }
+    box.id = node.id;
+    box.label = node.label;
+    box.node = node;
+    // A container can hold declarations of its OWN — a file has top-level code as well as the
+    // functions in it — so this is added to the subtree rather than replaced by it.
+    box.value += measureOf(node, measure, degree);
+}
+/**
+ * Sum every subtree bottom-up, and re-derive depth after folding has shortened paths.
+ *
+ * A leaf's value is its own measure; a container's is what it holds. That is what lets a box's
+ * area mean "how much is in here" rather than "how big is this one thing".
+ */
+function summarise(node, depth) {
+    node.depth = depth;
+    if (node.children.length === 0)
+        return node.value;
+    // `node.value` starts as the container's OWN measure, if it declared one — a module can
+    // hold top-level declarations as well as the functions inside it.
+    node.value += node.children.reduce((total, child) => total + summarise(child, depth + 1), 0);
+    return node.value;
+}
+/**
+ * Collapse a container that holds exactly one child and nothing of its own.
+ *
+ * NOT applied to a DECLARED container: a node that exists carries its own label, note and
+ * edges, and folding it would silently drop them. The rule is "a wrapper is not a level", and
+ * a thing the data names is not a wrapper.
+ */
+function fold(node) {
+    node.children = node.children.map(fold);
+    if (node.children.length === 1 && node.node === undefined && node.depth > 0) {
+        const only = node.children[0];
+        // The child takes this box's PLACE, so the segment this box contributed is spliced out
+        // of its path — not merely trimmed from the end, which would leave a leaf sitting at
+        // the very path that was just removed.
+        const cut = node.path.length - 1;
+        return { ...only, path: [...only.path.slice(0, cut), ...only.path.slice(cut + 1)] };
+    }
+    return node;
+}
+/** Depth-first, alphabetical: a re-render must never reshuffle the picture. */
+function sort(node) {
+    node.children.sort((a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id));
+    for (const child of node.children)
+        sort(child);
+}
+/**
+ * The containment tree for a model.
+ *
+ * Containment is PREFIX: a node whose path extends past another's is inside it. That is what
+ * makes a container an ordinary node — it keeps its own id, label, note and edges, and there
+ * is no convention to satisfy. A prefix nothing declares is synthesised.
+ */
+export function buildTree(model, options = {}) {
+    const measure = options.measure ?? 'weight';
+    const degree = measure === 'degree' ? degreesIn(model) : new Map();
+    const root = container([]);
+    root.depth = 0;
+    // One pass, one rule: every node is the box at its own path. Order does not matter —
+    // a descendant arriving first synthesises the box, and its owner fills in the identity.
+    for (const node of model.nodes)
+        attach(root, node, measure, degree);
+    const folded = fold(root);
+    sort(folded);
+    summarise(folded, 0);
+    return folded;
+}
+/** The node at `path`, or undefined. */
+export function findNode(root, path) {
+    let current = root;
+    for (const segment of path) {
+        current = current?.children.find((c) => c.path[c.path.length - 1] === segment);
+        if (!current)
+            return undefined;
+    }
+    return current;
+}