@rokkit/graph 1.6.0 → 1.8.0

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)
@@ -156,9 +202,23 @@ function buildEdge(source, fields, byId, seen) {
         relation,
         cardinality: str(pick(source, fields.cardinality, 'cardinality')),
         action: str(pick(source, fields.action, 'action')),
-        unplaced
+        unplaced,
+        ...edgeExtras(source, fields)
     };
 }
+/**
+ * `overlay` and `weight`, added only when present so every edge a v1 consumer already has
+ * stays key-for-key identical — `toEqual` on an edge is a contract downstream specs rely on.
+ */
+function edgeExtras(source, fields) {
+    const extras = {};
+    if (pick(source, fields.overlay, 'overlay'))
+        extras.overlay = true;
+    const weight = num(pick(source, fields.edgeWeight, 'weight'));
+    if (weight !== undefined)
+        extras.weight = weight;
+    return extras;
+}
 /**
  * The source row an edge makes a foreign key, if any.
  *
@@ -210,6 +270,8 @@ export function normalizeGraph(nodes, edges, fields = {}) {
     const resolved = edges
         .map((source) => buildEdge(source, fields, byId, seen))
         .filter((edge) => edge !== null);
-    markForeignKeys(byId, resolved);
-    return { nodes: built, edges: resolved, byId, neighbors: buildNeighbors(resolved) };
+    const structural = resolved.filter((edge) => !edge.overlay);
+    const overlays = resolved.filter((edge) => edge.overlay);
+    markForeignKeys(byId, structural);
+    return { nodes: built, edges: structural, overlays, byId, neighbors: buildNeighbors(structural) };
 }

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;
+}

package/dist/types.d.ts

@@ -21,6 +21,41 @@ export type GraphNode = {
     group?: string;
     /** Closed vocabulary — table | view | matview | function | procedure | enum. */
     kind?: string;
+    /**
+     * A quantity this node carries — declarations in a module, rows in a table, bytes in a
+     * bundle. Drives size in `points` (`sizeBy: 'weight'`) and the sequential colour channel.
+     *
+     * Optional because most graphs have no such number, and degree stays the default so no
+     * existing caller changes. A node without one sizes at the floor rather than vanishing.
+     */
+    weight?: number;
+    /**
+     * Named quantities this node carries — `{ declarations: 900, unresolved: 0.9 }`.
+     *
+     * A bag rather than more fields because size and shade are INDEPENDENT measures with
+     * different ranges, and the control that motivates them switches between several at
+     * runtime: naming a key re-runs the layout, where re-mapping `fields` would re-normalize
+     * the whole model on every toggle. `weight` remains the named default for size.
+     */
+    measures?: Record<string, number>;
+    /**
+     * This node's OWN full path, outermost first and INCLUDING itself —
+     * `['dbd', 'core', 'lexer', 'parse']`.
+     *
+     * `group` is one flat key and a codebase is containment six deep: project › repository ›
+     * folder › module › file › symbol. A path needs nothing to exist that does not, and cannot
+     * dangle the way a `parent` id can. A node without one sits at the root.
+     *
+     * **Containment is PREFIX**, which is what makes a container an ordinary node: anything
+     * whose path extends past this one is inside it. A container therefore keeps its own id,
+     * label, note, measures and edges — there is no id convention to satisfy and no second
+     * kind of node. A prefix nothing declares is synthesised, so the easy case still needs
+     * only leaves.
+     *
+     * Accepts a delimited STRING too (`'dbd/core/lexer/parse'`), since that is how a file path
+     * arrives. See `GraphFields.pathDelimiter`.
+     */
+    path?: string[];
     rows: GraphRow[];
     note?: string;
     /** Source fields the map did not claim, passed through untouched. */
@@ -59,10 +94,26 @@ export type GraphEdge = {
      * edge is kept and marked, and it is the renderer's job to dim it.
      */
     unplaced?: 'source' | 'target' | 'both';
+    /**
+     * Drawn over the picture but never allowed to shape it — a co-change pair, a layering
+     * rule broken, a suggested dependency.
+     *
+     * Such an edge is exactly what the reader wants to see and exactly what must not re-rank a
+     * layered layout or pull a cluster ordering: files that change together with no import
+     * between them would otherwise be drawn next to each other, hiding the very coupling the
+     * overlay exists to expose. So they never enter `GraphModel.edges`; they live in
+     * `GraphModel.overlays` and are routed after the layout has run.
+     */
+    overlay?: boolean;
+    /** A strength this edge carries — co-change count, call frequency. Drives stroke width. */
+    weight?: number;
 };
 export type GraphModel = {
     nodes: GraphNode[];
+    /** Structural edges — the ones layouts, neighbours and relationships see. */
     edges: GraphEdge[];
+    /** Overlay edges (`GraphEdge.overlay`) — routed after layout, never shaping it. */
+    overlays: GraphEdge[];
     byId: Map<string, GraphNode>;
     /** Undirected adjacency, self-edges excluded. */
     neighbors: Map<string, Set<string>>;
@@ -85,8 +136,17 @@ export type GraphProps = {
     arrange?: import('./layout/types.js').Arrange;
     /** Outer grouping axis — `group` (default) or `kind`. */
     groupBy?: import('./layout/types.js').NodeAxis;
+    /** Paint each card with its group's ramp — schema stays visible in a clusterless layout. */
+    groupTint?: boolean;
     /** Subdivide each cluster by a second axis. Omit for one level. */
     nestBy?: import('./layout/types.js').NodeAxis;
+    /**
+     * `points` only — what a node's size encodes. `degree` (default) counts edges, `weight`
+     * reads `GraphNode.weight`, and any other string names a key in `GraphNode.measures`.
+     */
+    sizeBy?: string;
+    /** How the measure maps onto area — `linear` (default) or `log`. */
+    sizeScale?: 'linear' | 'log';
     edgeStyle?: import('./layout/types.js').EdgeStyle;
     /** `neighborhood` only — the node the view centres on. Defaults to the selection. */
     focus?: string | null;
@@ -99,16 +159,16 @@ export type GraphProps = {
      */
     zoom?: number;
     /** Built-in zoom controls, ctrl/pinch-wheel zoom and drag-to-pan. Default true. */
+    /** Ctrl/pinch-wheel zoom and drag-to-pan. The BUTTON bar is `ZoomControl`, placed by you. */
     zoomable?: boolean;
-    /** Built-in names/keys/all detail toggle on the canvas. Default true. */
-    densityToggle?: boolean;
     /**
      * Draw an arrowhead at each edge's target instead of a plain anchor dot. Default true —
      * an edge is directed, and two identical dots discard that.
      */
     arrows?: boolean;
     label?: string;
-    onselect?: (id: string) => void;
+    /** Fires on selection AND on clear, where it receives `null`. */
+    onselect?: (id: string | null) => void;
     /** Icon class per node kind and row badge, merged over the built-in map. */
     icons?: Record<string, string>;
     class?: string;
@@ -123,6 +183,14 @@ export type GraphFields = {
     label?: string;
     group?: string;
     kind?: string;
+    /** Path to a per-node quantity — see `GraphNode.weight`. */
+    weight?: string;
+    /** Path to a containment chain — see `GraphNode.path`. */
+    path?: string;
+    /** Separator when `path` resolves to a STRING rather than an array. Defaults to `/`. */
+    pathDelimiter?: string;
+    /** Path to an object of named quantities — see `GraphNode.measures`. */
+    measures?: string;
     rows?: string;
     note?: string;
     /** Row-level paths, read against each entry of the `rows` array. */
@@ -155,6 +223,10 @@ export type GraphFields = {
     defaultEdgeKind?: EdgeKind;
     /** Path to the consumer's own relationship word — see `GraphEdge.relation`. */
     relation?: string;
+    /** Path to a truthy flag marking an overlay edge — see `GraphEdge.overlay`. */
+    overlay?: string;
+    /** Path to an edge's strength — see `GraphEdge.weight`. */
+    edgeWeight?: string;
     cardinality?: string;
     action?: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rokkit/graph",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "Node-link diagram components — pluggable layouts, ER/schema views",
   "repository": {
     "type": "git",
@@ -20,6 +20,11 @@
       "svelte": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./icons": {
+      "types": "./dist/icons.d.ts",
+      "svelte": "./dist/icons.js",
+      "default": "./dist/icons.js"
+    },
     "./schema": {
       "types": "./dist/schema/index.d.ts",
       "svelte": "./dist/schema/index.js",
@@ -41,10 +46,10 @@
     "check:types": "tsc --noEmit"
   },
   "dependencies": {
-    "@rokkit/core": "1.6.0"
+    "@rokkit/core": "1.8.0"
   },
   "peerDependencies": {
-    "@rokkit/ui": "1.6.0",
+    "@rokkit/ui": "1.8.0",
     "svelte": "^5.0.0"
   },
   "peerDependenciesMeta": {
@@ -53,7 +58,7 @@
     }
   },
   "devDependencies": {
-    "@rokkit/ui": "1.6.0",
+    "@rokkit/ui": "1.8.0",
     "@sveltejs/package": "^2.5.8",
     "@sveltejs/vite-plugin-svelte": "^6.2.4",
     "svelte": "^5.55.7",