@erd-studio/renderer 0.1.4 → 0.4.0

package/dist/types/lib/edgeRouting/routers/orthogonal/search.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Route-around router — A* over the routing grid.
+ *
+ * A state is (grid node, heading): bends cost BEND and a line may never
+ * double back on itself, so the search needs to know which way it is going.
+ * Many sources and many targets: every allowed anchor slot on every free
+ * side of the two cards is a seed / a goal (`Port`), each carrying its own
+ * cost (how far the anchor sits off the side's centre, plus the straight leg
+ * to the grid). The search stops at the cheapest complete route: a goal
+ * reached travelling along its leg towards the card, or turning onto it (one
+ * more bend).
+ *
+ * Costs: length, BEND per bend, CROSS per line routed earlier that this one
+ * crosses, SHARE per px of grid edge that earlier lines already use, and
+ * ZONE_COST per px run inside another card side's anchor zone. The
+ * heuristic is scaled by HEURISTIC_WEIGHT (bounded-suboptimal A*).
+ *
+ * The heuristic is the classic orthogonal-routing lower bound (as libavoid
+ * uses): for each side of the target, the Manhattan distance to its port
+ * line plus BEND × the fewest bends that can still arrive on it square-on
+ * from the current heading. Without the bend count a Z-shaped route (two
+ * bends) leaves every one-bend state between the cards cheaper than the
+ * answer, and A* floods the whole rectangle between them.
+ *
+ * Typed arrays are reused across searches with a stamp, so a search costs
+ * only what it touches.
+ */
+import type { Point, Side } from "../../types.js";
+import type { Grid } from "./grid.js";
+import type { Orient } from "./geom.js";
+export interface Port {
+    side: Side;
+    /** The anchor's coordinate along the side. */
+    c: number;
+    /** The stub point (PATH_GAP off the card), where the drawn line starts / ends. */
+    point: Point;
+    /** The grid node at the far end of the straight leg (≥ MIN_LEG from the stub). */
+    node: number;
+    /** Orientation of the leg. */
+    orient: Orient;
+    /** Direction of travel along the leg: away from the card for a seed, towards it for a goal. */
+    dir: 1 | -1;
+    /** Anchor penalty + leg length (+ crossings of lines already routed across the leg). */
+    cost: number;
+    /** The slot's grid line (row for a horizontal leg, column for a vertical one). */
+    lane: number;
+    /** Elementary grid edges the leg covers along its lane: [legLo, legHi]. */
+    legLo: number;
+    legHi: number;
+}
+export interface Found {
+    /** Grid nodes from the seed's node to the goal's node. */
+    nodes: number[];
+    src: Port;
+    tgt: Port;
+    cost: number;
+}
+export declare class Searcher {
+    private cap;
+    private gScore;
+    private stamp;
+    private parent;
+    private seedOf;
+    private goalStamp;
+    private goalOf;
+    private id;
+    private readonly heap;
+    /** Expansions in the last search (for perf tests). */
+    lastPops: number;
+    /** Target sides for the heuristic: [ux, sgn, up, lo, hi] × up to 4. */
+    private readonly targetBuf;
+    private zeroBuf;
+    private zeros;
+    private ensure;
+    /**
+     * `zones`: keep out of the anchor zones in front of card sides other lines
+     * attach to (off for a last-ditch retry).
+     */
+    search(grid: Grid, seeds: readonly Port[], goals: readonly Port[], maxPops: number, zones?: boolean, weight?: number, cross?: number): Found | null;
+    private build;
+}

package/dist/types/lib/edgeRouting/routers/orthogonalAvoid.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Edge routing — the router: orthogonal routing around every table card, with
+ * parallel lines in a shared corridor nudged apart.
+ *
+ * Every line is routed on a sparse orthogonal grid around the padded cards
+ * (A*, length + bends + crossings), may leave or enter whichever side of its
+ * card is best, and is then nudged so lines that share a channel or a card
+ * side read as separate wires and never cross right at a card. See
+ * `orthogonal/router.ts` for the pass and `orthogonal/params.ts` for the knobs.
+ */
+export { createAvoidRouter, type AvoidRouter, type AvoidResult } from './orthogonal/router.js';

package/dist/types/lib/edgeRouting/types.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Edge routing — shared types.
+ *
+ * Every FK line on the canvas is routed in one pass over the whole graph
+ * (`routeAll`), so the router can see every table (obstacles) and every other
+ * line (crossings, shared channels). An `FkEdge` reads its routed path from
+ * the canvas store and falls back to the smooth-step path when there is none.
+ *
+ * Coordinates are React Flow flow coordinates (the same space as node
+ * `positionAbsolute`).
+ */
+export type Side = 'top' | 'right' | 'bottom' | 'left';
+export interface Point {
+    x: number;
+    y: number;
+}
+/** A node's box on the canvas. Tables and sticky notes are both obstacles. */
+export interface Rect {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** 'model' for a table card, 'annotation' for a sticky note. */
+    kind: 'model' | 'annotation';
+}
+/** Where a line meets a table: the point on the card's border and which side. */
+export interface Anchor extends Point {
+    side: Side;
+}
+/** How far (px) the drawn line stops short of the card, leaving room for the `*` / `1`. */
+export declare const PATH_GAP = 20;
+/** How far (px) from the card border the `*` / `1` label sits. */
+export declare const LABEL_OFFSET = 8;
+/** One FK line to route, as the graph transformer + edge distribution placed it. */
+export interface EdgeSpec {
+    id: string;
+    source: string;
+    target: string;
+    /** The current (smooth-step) anchors: handle side + distributed slot. */
+    sourceAnchor: Anchor;
+    targetAnchor: Anchor;
+    isSelfLoop: boolean;
+    loopIndex: number;
+    /** 'many-to-one' | 'one-to-one' | 'one-to-many' | 'many-to-many'. */
+    cardinality: string;
+}
+export interface RoutingInput {
+    obstacles: Rect[];
+    edges: EdgeSpec[];
+}
+/**
+ * A router's answer for one line. `points` is an orthogonal-or-not polyline
+ * from the source stub to the target stub (each stub is the anchor pushed
+ * out by PATH_GAP along its side); the first and last segments should leave
+ * / enter perpendicular to the side. A router may move the anchors (choose
+ * another side or slot); the `*` / `1` labels follow the anchors.
+ */
+export interface RoutedLine {
+    sourceAnchor: Anchor;
+    targetAnchor: Anchor;
+    points: Point[];
+}
+/** What the canvas draws for one line, after crossings and tunnels are worked out. */
+export interface RoutedEdge extends RoutedLine {
+    /** The SVG path. */
+    d: string;
+    /** Midpoint along the drawn path (role label, swap button, badges). */
+    mid: Point;
+    /** Draw a background-coloured casing under the line (crossings = 'halo'). */
+    halo?: boolean;
+    /**
+     * crossings = 'halo', on a line that passes under another: `d` with the
+     * breaks cut out. FkEdge draws the visible stroke and its casing with it;
+     * `d` stays whole for the moving arrows and the hit area.
+     */
+    strokeD?: string;
+    /**
+     * Stretches of the line that pass under a table card (not its own two
+     * ends): polylines, drawn above the cards as a faint "x-ray" dashed line.
+     */
+    tunnels?: Point[][];
+}
+export type CrossingMode = 'none'
+/** A small semicircle bridge where one line hops over another. */
+ | 'hops'
+/** Every line has a canvas-coloured casing, and the line underneath is cut where it passes under another. */
+ | 'halo';
+export type UnderTablesMode = 
+/** The card hides the line. */
+'hidden'
+/** The hidden stretch is drawn faintly over the card, with portal rings where it enters and leaves. */
+ | 'xray';
+export type CornerMode = 'rounded' | 'curved' | 'sharp';
+/** How the router's polylines are drawn: one line style's settings. */
+export interface LineStyleOptions {
+    crossings: CrossingMode;
+    underTables: UnderTablesMode;
+    corners: CornerMode;
+}
+/** What `routeAll` needs of a router (the route-around router is the one the canvas uses). */
+export interface LineRouter {
+    route(input: RoutingInput): {
+        lines: Map<string, RoutedLine>;
+    };
+    /** Drop anything kept from earlier passes. */
+    reset(): void;
+}
+export interface RouteResult {
+    edges: Map<string, RoutedEdge>;
+    /** How long the pass took (ms), for the performance guard. */
+    millis: number;
+}

package/dist/types/lib/edgeRouting/worker/client.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Starts a canvas's line-routing worker, or says it cannot (returns null) so
+ * the canvas routes on the main thread with a lower cap instead.
+ *
+ * The worker's code is inlined at build time as `__ERD_EDGE_ROUTING_WORKER__`
+ * (the extension's `esbuild.js` and the package's `build.mjs` both define
+ * it). Where it is not defined (unit tests, a consumer bundling the source
+ * itself), where `Worker` or blob URLs are missing, or where the page's CSP
+ * refuses a blob worker, there is no worker.
+ */
+import type { WorkerRouteRequest, WorkerRouteResult } from './protocol.js';
+export interface RoutingWorkerEvents {
+    onResult: (result: WorkerRouteResult) => void;
+    /** The worker failed to start or crashed: it is terminated and never answers again. */
+    onFailure: (err: unknown) => void;
+}
+export interface RoutingWorkerHandle {
+    post: (request: WorkerRouteRequest) => void;
+    terminate: () => void;
+}
+/** Starts a worker for one canvas. */
+export type RoutingWorkerFactory = (events: RoutingWorkerEvents) => RoutingWorkerHandle | null;
+export declare const createRoutingWorker: RoutingWorkerFactory;

package/dist/types/lib/edgeRouting/worker/entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/edgeRouting/worker/protocol.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Messages between a canvas and its line-routing worker (`worker/entry.ts`).
+ * Everything here is structured-clone safe: plain objects, arrays and Maps.
+ */
+import type { LineStyle } from '../lineStyle.js';
+import type { RoutedEdge, RoutingInput } from '../types.js';
+/** Route `input` in `style`. `seq` comes back on the answer, so a canvas can drop a stale one. */
+export interface WorkerRouteRequest {
+    type: 'route';
+    seq: number;
+    input: RoutingInput;
+    style: LineStyle;
+    zoom: number;
+}
+/** The worker's answer to one request. */
+export interface WorkerRouteResult {
+    seq: number;
+    edges: Map<string, RoutedEdge>;
+    /** How long the pass took in the worker. */
+    millis: number;
+    /** A router or renderer error in this pass (the routes then leave those lines out). */
+    error?: string;
+}

package/dist/types/lib/graphTransformer.d.ts

@@ -1,18 +1,18 @@
 /**
- * Graph transformer — converts a DisplayDomain into React Flow nodes and edges.
+ * Graph transformer — converts a DisplaySubjectArea into React Flow nodes and edges.
  *
  * This is a pure function with no side effects, making it easy to unit test.
  * It handles:
- *   1. Mapping each DisplayModel → ModelFlowNode (with position + columns)
+ *   1. Mapping each DisplayTable → TableFlowNode (with position + columns)
  *   2. Mapping each DisplayRelationship → FkFlowEdge (with handle side selection)
  *   3. Selecting optimal handle sides based on relative node positions
  *   4. Injecting discrepancy data and ghost nodes/edges when a comparison report is active
  */
-import type { DisplayDomain } from '@erd-studio/core';
+import type { DisplaySubjectArea } from '@erd-studio/core';
 import type { DiscrepancyReport } from '@erd-studio/core';
-import type { ModelFlowNode, FkFlowEdge, AnnotationFlowNode, AnnotationFlowEdge } from '../types/graph.js';
+import type { TableFlowNode, FkFlowEdge, AnnotationFlowNode, AnnotationFlowEdge } from '../types/graph.js';
 export interface TransformResult {
-    nodes: (ModelFlowNode | AnnotationFlowNode)[];
+    nodes: (TableFlowNode | AnnotationFlowNode)[];
     edges: (FkFlowEdge | AnnotationFlowEdge)[];
 }
 /** Width/height of a rendered node, in canvas pixels. */
@@ -55,11 +55,11 @@ export declare function pickHandleSides(source: NodeRect, target: NodeRect): {
     targetSide: Side;
 };
 /**
- * Convert a DisplayDomain into React Flow nodes and edges.
+ * Convert a DisplaySubjectArea into React Flow nodes and edges.
  *
  * @param domain — the display domain from extension host
  * @param options — optional discrepancy report and ghost positions
  * @returns nodes and edges ready for React Flow's `<ReactFlow>` component
  */
-export declare function transformDomain(domain: DisplayDomain, options?: TransformOptions): TransformResult;
+export declare function transformSubjectArea(domain: DisplaySubjectArea, options?: TransformOptions): TransformResult;
 export {};

package/dist/types/lib/hoverIntent.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Hover intent — decides when a pointer resting on a table becomes a hover
+ * focus, so skimming across the canvas does not flash every table it crosses.
+ *
+ *   - From nothing to a table: wait `HOVER_ENTER_DELAY_MS`.
+ *   - From table A to table B: wait `HOVER_SWITCH_DELAY_MS`, then commit B
+ *     directly (never null in between, so nothing un-dims and re-dims).
+ *   - Leaving: wait `HOVER_LEAVE_GRACE_MS` before clearing; entering again,
+ *     or `hold()` (the pointer is on one of the focus's bright lines), cancels
+ *     the clear.
+ *
+ * `cancelEnter()` drops only a pending enter; a pending clear still runs, so
+ * a pointer that has left a table never leaves its focus behind.
+ *
+ * An enter is ignored while a mouse button is held (`buttons !== 0`), while
+ * `isSuppressed()` says so (it is asked again when the timer fires), or when
+ * the table is already the focus. At most two timers exist at a time.
+ *
+ * Framework-free; timers are injected so tests can use fake ones.
+ */
+export declare const HOVER_ENTER_DELAY_MS = 120;
+export declare const HOVER_SWITCH_DELAY_MS = 60;
+export declare const HOVER_LEAVE_GRACE_MS = 150;
+type TimerId = ReturnType<typeof setTimeout>;
+export interface HoverIntentOptions {
+    /** Make `id` the focus, or clear it with null. */
+    commit: (id: string | null) => void;
+    /** The id currently in focus (read at event time). */
+    current: () => string | null;
+    /** True while hover must not start a focus (drags, menus, pans). */
+    isSuppressed: () => boolean;
+    setTimeout?: (fn: () => void, ms: number) => TimerId;
+    clearTimeout?: (id: TimerId) => void;
+}
+export interface HoverIntent {
+    enter(id: string, buttons: number): void;
+    leave(): void;
+    hold(): void;
+    cancelEnter(): void;
+    cancelPending(): void;
+    dispose(): void;
+}
+export declare function createHoverIntent(options: HoverIntentOptions): HoverIntent;
+export {};

package/dist/types/lib/layerCues.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Layer cues: how the canvas names the layer a table lives in.
+ *
+ * A table's header badge has one meaning, its layer, and the layer is named
+ * the same way wherever the canvas names one (the node badge, the toolbar
+ * chip, the status-bar key): the layer's abbreviation, then its label.
+ *
+ * A project with a single layer has nothing to tell apart, so the per-table
+ * badge, its colour strip, the status-bar key and the toolbar chip are left
+ * off there ({@link isSingleLayerProject}).
+ */
+import type { DisplaySubjectArea, LayerConfig } from '@erd-studio/core';
+/** Abbreviations for the default layers, for when a layer has no config. */
+export declare const LAYER_BADGE_FALLBACK: Readonly<Record<string, string>>;
+/**
+ * A layer's badge text: its configured abbreviation, else the default
+ * layers' abbreviation, else the first three letters of its id.
+ */
+export declare function layerAbbreviation(id: string, config?: Pick<LayerConfig, 'abbreviation'>): string;
+/**
+ * Whether the project has one layer at most, with every table on the diagram
+ * in the diagram's layer: the layer badge, strip, key and chip are then left
+ * off. Needs `layerConfigs`: a domain from an older core (or a host that
+ * sends no layer list) keeps every layer cue, as it did before.
+ */
+export declare function isSingleLayerProject(domain: Pick<DisplaySubjectArea, 'layer' | 'layerConfigs' | 'models'>): boolean;

package/dist/types/lib/modelLabels.d.ts

@@ -8,7 +8,7 @@
  * same are told apart by schema (`silver.date`, `gold.date`).
  */
 /** The fields a label is computed from. */
-export interface LabelledModel {
+export interface LabelledTable {
     name: string;
     schema?: string;
     alias?: string;
@@ -18,9 +18,9 @@ export interface LabelledModel {
  * name. A model absent from the map is labelled with its name, exactly as
  * before aliases existed.
  */
-export declare function computeModelLabels(models: readonly LabelledModel[]): Map<string, string>;
+export declare function computeTableLabels(models: readonly LabelledTable[]): Map<string, string>;
 /** Whether a search query (already lower-cased) matches a model by name or label. */
-export declare function matchesModelSearch(data: {
+export declare function matchesTableSearch(data: {
     modelName: string;
     label?: string;
 }, query: string): boolean;

package/dist/types/lib/nodeOverlays.d.ts

@@ -1,6 +1,6 @@
 /**
  * Node/edge overlays — ephemeral per-node presentation state layered on top
- * of the graph produced by `transformDomain`:
+ * of the graph produced by `transformSubjectArea`:
  *
  *   - `dimmed`: search-miss or not-connected-to-selection dimming (F402)
  *   - `isExpanded` / `onToggleExpansion`: column expansion (F405)
@@ -8,15 +8,21 @@
  * `applyNodeOverlays` is a pure function that preserves object identity for
  * every node/edge whose overlay values did not change, so React Flow's
  * `adoptUserNodes` short-circuits on unchanged nodes and memoised
- * `ModelNode` / `FkEdge` components skip re-rendering. When nothing changed
+ * `TableNode` / `FkEdge` components skip re-rendering. When nothing changed
  * at all, the *same arrays* are returned so callers can skip `setNodes`.
  *
  * This lets selection / search / expansion changes avoid re-running the full
  * domain transform (which would also drop `measured` and force React Flow to
  * re-measure every node).
+ *
+ * What counts as "connected" is `computeCanvasFocus` (`canvasFocus.ts`), the
+ * same rule the hover preview uses. Hover itself never comes through here:
+ * every `setEdges` re-renders every `FkEdge`, which is fine once per click but
+ * not on every pointer move, so hover dims with a root CSS class instead
+ * (`useHoverFocus`).
  */
-import type { ModelFlowNode, FkFlowEdge, AnnotationFlowNode, AnnotationFlowEdge } from '../types/graph.js';
-export type GraphNode = ModelFlowNode | AnnotationFlowNode;
+import type { TableFlowNode, FkFlowEdge, AnnotationFlowNode, AnnotationFlowEdge } from '../types/graph.js';
+export type GraphNode = TableFlowNode | AnnotationFlowNode;
 export type GraphEdge = FkFlowEdge | AnnotationFlowEdge;
 export interface OverlayState {
     /** Currently selected model (drives connected-node dimming). */

package/dist/types/lib/nodeSizing.d.ts

@@ -1,5 +1,5 @@
 /**
- * Model node size estimation (matches ModelNode CSS).
+ * Model node size estimation (matches TableNode CSS).
  *
  * The width and height a model node will render at, estimated from its
  * content, for code that needs node sizes before React Flow has measured the
@@ -9,7 +9,7 @@
  * Kept free of elkjs and React Flow runtime imports so it can be loaded on its
  * own.
  */
-import type { ModelFlowNode, ModelNodeData } from '../types/graph.js';
+import type { TableFlowNode, TableNodeData } from '../types/graph.js';
 /** Default width — used as fallback by edgeDistribution.ts. */
 export declare const NODE_WIDTH = 280;
 /**
@@ -18,7 +18,7 @@ export declare const NODE_WIDTH = 280;
  */
 export declare function estimateNodeHeight(rowCount: number, hasGrain: boolean): number;
 /**
- * Number of rows ModelNode actually renders in its columns section.
+ * Number of rows TableNode actually renders in its columns section.
  *
  * Mirrors the rendering rules in `ModelNode.tsx`:
  *   - stub models show only PK/NK columns
@@ -29,12 +29,12 @@ export declare function estimateNodeHeight(rowCount: number, hasGrain: boolean):
  * Using the full column count (the old behaviour) over-reserved
  * `(columns - 5) * rowHeight` per node on auto-collapsed domains (≥30 models).
  */
-export declare function countVisibleColumnRows(data: Pick<ModelNodeData, 'columns' | 'isStub' | 'isExpanded'>): number;
+export declare function countVisibleColumnRows(data: Pick<TableNodeData, 'columns' | 'isStub' | 'isExpanded'>): number;
 /**
  * Best-known size for a model node: React Flow's measured DOM size when
  * available, otherwise an estimate from the rows that will be rendered.
  */
-export declare function resolveNodeDimensions(node: Pick<ModelFlowNode, 'data' | 'measured'>): {
+export declare function resolveNodeDimensions(node: Pick<TableFlowNode, 'data' | 'measured'>): {
     width: number;
     height: number;
 };
@@ -47,4 +47,4 @@ export declare function resolveNodeDimensions(node: Pick<ModelFlowNode, 'data' |
  * slightly more space than the minimum estimate, preventing overlap
  * when font rendering or badge widths differ from the approximation.
  */
-export declare function estimateNodeWidth(data: Pick<ModelNodeData, 'modelName' | 'label' | 'columns' | 'provenance'>): number;
+export declare function estimateNodeWidth(data: Pick<TableNodeData, 'modelName' | 'label' | 'columns' | 'provenance'> & Partial<Pick<TableNodeData, 'tableLayer' | 'shownSchema' | 'alias' | 'singleLayer'>>): number;

package/dist/types/lib/pathGeometry.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Path geometry for the relationship flow glyphs: how long a drawn edge path
+ * is, where its straight runs are, and the point and heading at a fraction
+ * of its length.
+ *
+ * Reads the absolute commands the canvas draws: `M`, `L`, `H`, `V` (xyflow's
+ * smooth-step path and the Legend samples), `Q` (smooth-step bends) and `C`
+ * (self-loops). Curves are flattened into a few chords, which is accurate to
+ * well under a pixel for the radii used here. Anything else ends the parse;
+ * what was read so far is kept.
+ *
+ * Pure: no React, no DOM (`SVGPathElement.getTotalLength` would need a
+ * mounted element and a layout).
+ */
+export interface PathPoint {
+    x: number;
+    y: number;
+}
+export interface PathPose extends PathPoint {
+    /** Heading in degrees, along increasing path length (SVG `rotate="auto"`). */
+    angle: number;
+}
+export interface PathGeometry {
+    /** The flattened path. */
+    readonly points: readonly PathPoint[];
+    /** Cumulative length at each point (`cumulative[0] === 0`). */
+    readonly cumulative: readonly number[];
+    readonly length: number;
+    /** Straight runs (`L` / `H` / `V`) as fractions of the length, in path order. */
+    readonly straights: readonly {
+        start: number;
+        end: number;
+    }[];
+}
+/** Flatten and measure a path. An unreadable path has length 0. */
+export declare function measurePath(d: string): PathGeometry;
+/** The point and heading at `fraction` (0..1) of the path's length. */
+export declare function poseAt(geom: PathGeometry, fraction: number): PathPose;
+/**
+ * Where two still glyphs sit so that neither lands on a bend: the middle of
+ * the first and of the last usable straight run, or a third and two thirds
+ * of the only one. Null when the path has no usable straight run (a
+ * self-loop's curve): the planner's defaults then apply.
+ */
+export declare function stillPositions(geom: PathGeometry): readonly [number, number] | null;

package/dist/types/lib/reuseUnchanged.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Structural sharing for a rebuilt graph: every rebuilt node or edge that is
+ * structurally equal to the one already in the store is replaced by that
+ * same object.
+ *
+ * The canvas rebuilds every node and edge whenever the domain changes —
+ * including the optimistic update after a drag, where only the moved
+ * tables' positions (and the sides of their edges) differ. React Flow reuses
+ * its internal node for a user node that is the same object as last time,
+ * and memoised node and edge components skip rendering when their props keep
+ * their identity, so handing back the old objects for everything that did
+ * not change turns a 500-table re-render into a handful.
+ *
+ * Correct by construction: the result is equal, field for field, to what the
+ * rebuild produced; only identities change. Transient React Flow fields that
+ * the rebuild never sets (`dragging`, `resizing`) are ignored, and an absent
+ * `selected` equals `false`.
+ */
+/** Structural equality of plain data: functions, Maps, Sets and class instances compare by identity. */
+export declare function sameData(a: unknown, b: unknown): boolean;
+/**
+ * `next` with each element replaced by the element of `prev` with the same
+ * id when the two are structurally equal. Returns `prev` itself when every
+ * element was reused in the same order (nothing to set at all).
+ */
+export declare function reuseUnchanged<T extends {
+    id: string;
+}>(prev: readonly T[], next: T[]): T[];

package/dist/types/lib/roleOptions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The words the canvas shows for each table role. The stored keys
+ * (`gold-fact`, …) never change; only the labels are for people. The order is
+ * core's `TABLE_ROLE_VALUES` (the role field's choices).
+ */
+import type { TableRole } from '@erd-studio/core';
+/** Human-readable labels for each role (the stored key stays as it is). */
+export declare const ROLE_OPTIONS: ReadonlyArray<{
+    value: TableRole;
+    label: string;
+}>;
+/** The label for a role key, or the key itself for a role this renderer does not know. */
+export declare function roleLabel(role: string): string;