@nodius/layouting 0.1.0 → 0.1.1

package/README.md

@@ -1,145 +1,267 @@
-# nodius-layouting
+# @nodius/layouting
 
-A **zero-dependency**, high-performance graph layouting library for node-based technical diagrams.
+A **zero-dependency**, high-performance graph layouting library for node-based
+technical diagrams.
 
-Built for real-world use cases: data pipelines, visual programming environments, workflow editors, and any system where nodes with typed handles are connected by edges.
+Built for real-world use cases: data pipelines, visual programming environments,
+workflow editors, and any system where typed-handle nodes are connected by
+typed edges, with parent/child grouping and side-attached values.
 
 ## Features
 
-- **Zero runtime dependencies** - Pure TypeScript, nothing else
-- **Optimized Sugiyama-based layout** - Produces clean, hierarchical technical diagrams
-- **Handle-aware** - Each node has multiple handles (input/output) with precise positioning on any side (top, right, bottom, left) with configurable offsets
-- **Orthogonal edge routing** - Clean right-angle edge paths that respect handle positions
-- **Incremental layout** - Add or remove nodes without recomputing the entire layout
-- **4 layout directions** - Top-to-bottom, left-to-right, bottom-to-top, right-to-left
-- **Cycle support** - Automatically handles cyclic graphs
-- **Scales to 1000+ nodes** - Optimized algorithms (merge-sort crossing count, adaptive iterations)
+- **Zero runtime dependencies** — pure TypeScript, nothing else
+- **Strict-axis Sugiyama** — the chosen reading direction is honored end to end; compacity comes from packing and sidecars, never from local re-orientation
+- **Typed edges** (`control` / `data`) — `data` edges have light weight and pull their value nodes onto the consumer's layer instead of extending the rail
+- **Compound layout** — nodes can declare `parentId`; children are laid out inside their parent's bounding box recursively
+- **Sidecar value placement** — value nodes (only data edges) are attached to the flanks of their consumer, picked from the consumer's handle side
+- **Component packing** — disjoint components are packed along the order axis for a square-ish aspect ratio
+- **Rotation proposals** — when handle orientation doesn't match the chosen direction (or the value's sidecar slot), the engine asks the application via `onProposal` whether to rotate
+- **Handle-aware** — every node has multiple input/output handles with `top`/`right`/`bottom`/`left` positions and configurable offsets
+- **Orthogonal edge routing** through dummy waypoints
+- **Incremental layout** — keep position stability across edits via `IncrementalLayout`
+- **4 layout directions** — `TB`, `LR`, `BT`, `RL`
+- **Cycle support** — back edges are detected and reversed automatically
+- **Scales** — ~150 ms on 1000 nodes; merge-sort based crossing counting; adaptive iteration cap on large graphs
 
 ## Performance
 
-Benchmarked on a standard development machine:
+Measured on a standard dev machine (Node 22, vitest run):
 
-| Graph Size | Time |
-|---|---|
-| 100 nodes, 737 edges (dense) | ~70ms |
-| 200 nodes | ~25ms |
-| 500 nodes | ~100ms |
-| 1000 nodes | ~150ms |
+| Graph size                       | Time   |
+|----------------------------------|--------|
+| 100 nodes, 737 edges (dense)     | ~70 ms |
+| 200 nodes                        | ~25 ms |
+| 500 nodes                        | ~90 ms |
+| 1000 nodes                       | ~150 ms|
 
 ## Installation
 
 ```bash
-npm install nodius-layouting
+npm install @nodius/layouting
 ```
 
-## Quick Start
+## Quick start
 
-```typescript
-import { layout } from 'nodius-layouting';
+```ts
+import { layout } from '@nodius/layouting';
 
 const result = layout({
   nodes: [
-    {
-      id: 'source',
-      width: 120,
-      height: 60,
-      handles: [
-        { id: 'out', type: 'output', position: 'bottom', offset: 0.5 },
-      ],
-    },
-    {
-      id: 'transform',
-      width: 150,
-      height: 80,
-      handles: [
-        { id: 'in', type: 'input', position: 'top', offset: 0.5 },
-        { id: 'out', type: 'output', position: 'bottom', offset: 0.5 },
-        { id: 'err', type: 'output', position: 'right', offset: 0.5 },
-      ],
-    },
-    {
-      id: 'sink',
-      width: 120,
-      height: 60,
-      handles: [
-        { id: 'in', type: 'input', position: 'top', offset: 0.5 },
-      ],
-    },
+    { id: 'src', width: 120, height: 60, handles: [
+      { id: 'out', type: 'output', position: 'bottom' },
+    ]},
+    { id: 'transform', width: 150, height: 80, handles: [
+      { id: 'in',  type: 'input',  position: 'top' },
+      { id: 'out', type: 'output', position: 'bottom' },
+    ]},
+    { id: 'sink', width: 120, height: 60, handles: [
+      { id: 'in', type: 'input', position: 'top' },
+    ]},
   ],
   edges: [
-    { id: 'e1', from: 'source', to: 'transform', fromHandle: 'out', toHandle: 'in' },
+    { id: 'e1', from: 'src', to: 'transform', fromHandle: 'out', toHandle: 'in' },
     { id: 'e2', from: 'transform', to: 'sink', fromHandle: 'out', toHandle: 'in' },
   ],
+}, { direction: 'TB' });
+
+// result.nodes  → positioned nodes with absolute handle coordinates and parentId echoed
+// result.edges  → routed edges with waypoint arrays and `kind`
+```
+
+## Typed edges and value nodes
+
+Edges accept a `kind` of `'control'` (default) or `'data'`. **Control edges**
+define the execution rail and drive layer assignment. **Data edges** are weak
+links — their endpoints are pulled onto the consumer's layer, and a node whose
+every incident edge is a data edge becomes a **value**: it is attached as a
+sidecar to the flank of its dominant consumer rather than living inside the
+rail.
+
+```ts
+import { layout } from '@nodius/layouting';
+
+const result = layout({
+  nodes: [
+    { id: 'Start', width: 100, height: 50, handles: [
+      { id: 'out', type: 'output', position: 'bottom' },
+    ]},
+    { id: 'fetch', width: 140, height: 70, handles: [
+      { id: 'in',  type: 'input',  position: 'top' },
+      { id: 'key', type: 'input',  position: 'left', offset: 0.3 },
+      { id: 'url', type: 'input',  position: 'left', offset: 0.7 },
+      { id: 'out', type: 'output', position: 'bottom' },
+    ]},
+    { id: 'API_KEY', width: 100, height: 40, handles: [
+      { id: 'out', type: 'output', position: 'right' },
+    ]},
+    { id: 'BASE_URL', width: 100, height: 40, handles: [
+      { id: 'out', type: 'output', position: 'right' },
+    ]},
+    { id: 'Done', width: 100, height: 50, handles: [
+      { id: 'in', type: 'input', position: 'top' },
+    ]},
+  ],
+  edges: [
+    { id: 'c1', from: 'Start', to: 'fetch', fromHandle: 'out', toHandle: 'in', kind: 'control' },
+    { id: 'c2', from: 'fetch', to: 'Done',  fromHandle: 'out', toHandle: 'in', kind: 'control' },
+    { id: 'd1', from: 'API_KEY',  to: 'fetch', fromHandle: 'out', toHandle: 'key', kind: 'data' },
+    { id: 'd2', from: 'BASE_URL', to: 'fetch', fromHandle: 'out', toHandle: 'url', kind: 'data' },
+  ],
+});
+// Start, fetch and Done line up vertically. API_KEY and BASE_URL sit on
+// fetch's left flank, at fetch's vertical band — they don't extend the rail.
+```
+
+## Compound (nested) layout
+
+Set `parentId` on any node to make it a child of another. Children are laid out
+inside their parent's bounding box; the parent grows to fit them plus an
+optional padding and a header strip for its own label.
+
+```ts
+const result = layout({
+  nodes: [
+    { id: 'Start',       width: 110, height: 50, handles: [...] },
+    { id: 'parallel',    width: 220, height: 140, handles: [
+      { id: 'in',  type: 'input',  position: 'top' },
+      { id: 'out', type: 'output', position: 'bottom' },
+    ]},
+    { id: 'fetch users',  parentId: 'parallel', width: 130, height: 50, handles: [...] },
+    { id: 'fetch orders', parentId: 'parallel', width: 130, height: 50, handles: [...] },
+    { id: 'End',         width: 100, height: 50, handles: [...] },
+  ],
+  edges: [
+    { id: 'c1', from: 'Start', to: 'parallel', fromHandle: 'out', toHandle: 'in', kind: 'control' },
+    { id: 'c2', from: 'parallel', to: 'End',   fromHandle: 'out', toHandle: 'in', kind: 'control' },
+  ],
+});
+
+// Output nodes carry `parentId` so you can reconstruct the hierarchy in your renderer.
+```
+
+## Rotation proposals (`onProposal`)
+
+When a node's handles don't match how the engine plans to place it, it emits a
+**rotation proposal**. The application decides what to do:
+
+```ts
+import { layout } from '@nodius/layouting';
+
+layout(input, {
+  direction: 'LR',
+  // Accept every proposal and use the engine-suggested rotation:
+  onProposal: (p) => p.proposed,
+
+  // Or filter: only accept rotations for nodes you own
+  // onProposal: (p) => p.nodeId.startsWith('mine_') ? p.proposed : null,
+
+  // Or partial: rotate only some handles
+  // onProposal: (p) => ({
+  //   ...p.current,
+  //   handles: p.current.handles.map(h => h.id === 'main' ? { ...h, position: 'right' } : h),
+  // }),
 });
+```
+
+The engine reasons about two roles:
 
-// result.nodes → positioned nodes with absolute handle coordinates
-// result.edges → routed edges with waypoint arrays
+- **Rail nodes** are aligned to the global flow: in `TB`, inputs go on top,
+  outputs on bottom.
+- **Value nodes** are sidecars: their handles must face the consumer. A value
+  attached to a consumer's `left` handle will sit on the consumer's left
+  flank, so its output is expected on `right`.
+
+Each proposal includes the original node, the rotated proposal, the rotation
+angle (`90` / `-90` / `180`), and a human-readable reason.
+
+## Component packing
+
+By default disjoint components are packed side-by-side along the order axis.
+Disable with `packComponents: false`. Packing respects compound groups — a
+compound and its children always travel as one block.
+
+```ts
+layout(input, { packComponents: true });  // default
+layout(input, { packComponents: false }); // long ribbon
 ```
 
 ## API
 
 ### `layout(input, options?)`
 
-Compute a complete layout for the given graph. Returns positioned nodes and routed edges.
+Compute a complete layout for the given graph. Returns positioned nodes and
+routed edges.
 
-```typescript
+```ts
 function layout(input: LayoutInput, options?: LayoutOptions): LayoutResult;
 ```
 
 ### `IncrementalLayout`
 
-Maintains layout state for incremental updates. Use this when you need to add or remove nodes without full recomputation.
+Maintains state for incremental updates with position stability:
 
-```typescript
-import { IncrementalLayout } from 'nodius-layouting';
+```ts
+import { IncrementalLayout } from '@nodius/layouting';
 
 const inc = new IncrementalLayout({ direction: 'LR' });
+const r1 = inc.setGraph({ nodes: [...], edges: [...] });
+const r2 = inc.addNodes([newNode], [newEdge]);
+const r3 = inc.removeNodes(['stale_id']);
+inc.addEdges([...]);
+inc.removeEdges(['e1']);
+inc.getResult();
+```
 
-// Set initial graph
-const result1 = inc.setGraph({ nodes: [...], edges: [...] });
+### `printLayout(result, options?)`
 
-// Add nodes and edges incrementally
-const result2 = inc.addNodes(
-  [{ id: 'new_node', width: 100, height: 60, handles: [...] }],
-  [{ id: 'new_edge', from: 'existing', to: 'new_node', fromHandle: 'out', toHandle: 'in' }]
-);
+Render a layout result to a debug-friendly text block: per-Y-band summary,
+node hierarchy, edges, overlaps and an optional ASCII grid. Useful when
+iterating on layout strategies without opening a browser.
 
-// Remove nodes (connected edges are removed automatically)
-const result3 = inc.removeNodes(['node_to_remove']);
+```ts
+import { layout, printLayout } from '@nodius/layouting';
+const r = layout(input);
+console.log(printLayout(r));
+```
 
-// Add/remove edges independently
-inc.addEdges([...]);
-inc.removeEdges(['edge_id']);
+### `rotateHandles(handles, rotation)`
 
-// Get current result
-const current = inc.getResult();
+Utility re-exported for applications that build their own handle-rotation
+logic in their `onProposal` callback.
+
+```ts
+import { rotateHandles } from '@nodius/layouting';
+const rotated = rotateHandles(node.handles, 90);
 ```
 
-### Types
+## Types
 
-#### Input Types
+### Input
 
-```typescript
+```ts
 interface NodeInput {
   id: string;
   width: number;
   height: number;
   handles: HandleInput[];
+  parentId?: string; // make this node a child of another
 }
 
 interface HandleInput {
   id: string;
   type: 'input' | 'output';
   position: 'top' | 'right' | 'bottom' | 'left';
-  offset?: number; // 0-1 position along the side. Default: 0.5
+  offset?: number; // 0..1 along the side. Default: 0.5
 }
 
 interface EdgeInput {
   id: string;
-  from: string;       // Source node ID
-  to: string;         // Target node ID
-  fromHandle: string; // Source handle ID
-  toHandle: string;   // Target handle ID
+  from: string;
+  to: string;
+  fromHandle: string;
+  toHandle: string;
+  kind?: 'control' | 'data'; // default: 'control'
+  weight?: number;           // override (default: 1 control, 0.25 data)
 }
 
 interface LayoutInput {
@@ -148,22 +270,34 @@ interface LayoutInput {
 }
 ```
 
-#### Options
+### Options
 
-```typescript
+```ts
 interface LayoutOptions {
-  direction?: 'TB' | 'LR' | 'BT' | 'RL';       // Default: 'TB'
-  nodeSpacing?: number;                           // Default: 40
-  layerSpacing?: number;                          // Default: 60
-  crossingMinimizationIterations?: number;        // Default: 24
-  coordinateOptimizationIterations?: number;      // Default: 8
-  edgeMargin?: number;                            // Default: 20
+  direction?: 'TB' | 'LR' | 'BT' | 'RL';   // Default: 'TB'
+  nodeSpacing?: number;                     // Default: 40
+  layerSpacing?: number;                    // Default: 60
+  crossingMinimizationIterations?: number;  // Default: 24
+  coordinateOptimizationIterations?: number;// Default: 8
+  edgeMargin?: number;                      // Default: 20
+
+  // Typed edges
+  edgeWeights?: { control?: number; data?: number };
+
+  // Component packing
+  packComponents?: boolean;                 // Default: true
+
+  // Compound layout
+  compoundPadding?: number;                 // Default: 24
+
+  // Proposals
+  onProposal?: (p: LayoutProposal) => NodeInput | null | undefined | void;
 }
 ```
 
-#### Output Types
+### Output
 
-```typescript
+```ts
 interface LayoutResult {
   nodes: NodeOutput[];
   edges: EdgeOutput[];
@@ -175,15 +309,16 @@ interface NodeOutput {
   y: number;
   width: number;
   height: number;
-  handles: HandleOutput[]; // Absolute positions
+  handles: HandleOutput[]; // absolute positions
+  parentId?: string;        // echoed from the input
 }
 
 interface HandleOutput {
   id: string;
   type: 'input' | 'output';
   position: 'top' | 'right' | 'bottom' | 'left';
-  x: number; // Absolute x position
-  y: number; // Absolute y position
+  x: number;
+  y: number;
 }
 
 interface EdgeOutput {
@@ -192,60 +327,79 @@ interface EdgeOutput {
   to: string;
   fromHandle: string;
   toHandle: string;
-  points: Point[]; // Ordered waypoints from source to target
+  points: Point[]; // ordered waypoints
+  kind: 'control' | 'data';
 }
-```
 
-## Algorithm
-
-The layout engine uses a modified **Sugiyama algorithm** with five phases:
-
-1. **Cycle Breaking** - DFS-based back edge detection and reversal
-2. **Layer Assignment** - Longest-path layering with dummy node insertion for long edges
-3. **Crossing Minimization** - Barycenter heuristic with up/down sweeps and transpose improvement. Uses merge-sort based O(E log V) inversion counting
-4. **Coordinate Assignment** - Median-based iterative positioning with spacing constraints and multi-pass centering
-5. **Edge Routing** - Orthogonal path computation through dummy node waypoints with handle-aware entry/exit directions
+interface RotateProposal {
+  type: 'rotate';
+  nodeId: string;
+  current: NodeInput;
+  proposed: NodeInput;
+  rotation: 90 | -90 | 180;
+  reason: string;
+}
 
-### Incremental Layout
+type LayoutProposal = RotateProposal;
+```
 
-The `IncrementalLayout` class provides position stability when modifying graphs:
+## Algorithm
 
-- New nodes are inserted into appropriate layers based on their connections
-- Existing node positions are blended (70% new / 30% old) to reduce visual disruption
-- Full crossing minimization and coordinate assignment run on the updated graph
-- Only affected edges are re-routed
+The engine uses a modified **Sugiyama algorithm** with these phases:
+
+1. **Proposals** — scan input nodes; emit rotation proposals when handle
+   orientation doesn't match the planned placement (rail vs. sidecar).
+2. **Compound resolution** — group nodes by `parentId`; recursively lay out
+   each compound's children bottom-up so the compound's bounding box is
+   known before it appears in the parent level.
+3. **Cycle breaking** — DFS-based back edge detection and reversal.
+4. **Two-pass layer assignment**:
+   - control rail via longest-path on control-only edges between non-value nodes
+   - values pulled onto the median layer of their non-value neighbors
+5. **Dummy insertion** for long control edges only — data edges route directly.
+6. **Crossing minimization on the rail** — barycenter heuristic with up/down
+   sweeps and transpose improvement; merge-sort inversion counting.
+7. **Coordinate assignment on the rail** — median-based iterative positioning
+   with spacing constraints.
+8. **Sidecar value placement** — values are attached to the flank of their
+   dominant consumer, side chosen from the consumer's handle position.
+9. **Edge routing** — orthogonal paths through dummy waypoints with
+   handle-aware entry/exit directions; `kind` is preserved.
+10. **Component packing** — disjoint components packed along the order axis;
+    compound groups travel as a single block.
 
 ## Playground
 
-A visual playground is included in the `playground/` directory:
-
 ```bash
 cd playground
 npm install
-npm run dev
+npm run dev   # → http://localhost:6501
 ```
 
-This opens a Vite dev server with:
-- Predefined example graphs (chain, diamond, data pipeline, hub, binary tree, cycle)
-- Editable JSON input
-- Before/after SVG visualization
-- Configurable layout direction and spacing
-- Real-time performance metrics
+The playground ships with examples covering every layout feature:
+
+- Compound · Promise.all
+- Floating Values (auto-rotate demo)
+- Compound + Values
+- Try / Catch (compound)
+- Switch / Case
+- Map / Reduce pipeline
+- HTTP middleware chain
+- Disjoint Components
+- Binary Tree
+- Cycle Example
+- ... and classics (Simple Chain, Diamond, Data Pipeline, Multi-Handle Hub)
+
+Toggle **Pack components** and **Auto-rotate handles** in the toolbar to see
+the corresponding features kick in.
 
 ## Development
 
 ```bash
-# Install dependencies
 npm install
-
-# Run tests
-npm test
-
-# Run tests in watch mode
+npm test              # 79 tests cover compound, sidecars, proposals, perf, cycles…
 npm run test:watch
-
-# Build the library
-npm run build
+npm run build         # tsup bundle + tsc declaration files
 ```
 
 ## License

package/dist/algorithms/component-packing.d.ts

@@ -0,0 +1,9 @@
+import { EdgeOutput, NodeOutput, ResolvedOptions } from '../types';
+/**
+ * Pack disjoint connected components side-by-side (in the order axis) so the
+ * overall layout is roughly square instead of a long ribbon.
+ *
+ * Compound parents are kept as atomic groups: children move with their parent.
+ */
+export declare function packComponents(nodes: NodeOutput[], edges: EdgeOutput[], options: ResolvedOptions): void;
+//# sourceMappingURL=component-packing.d.ts.map

package/dist/algorithms/component-packing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-packing.d.ts","sourceRoot":"","sources":["../../src/algorithms/component-packing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEnE;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,UAAU,EAAE,EACnB,KAAK,EAAE,UAAU,EAAE,EACnB,OAAO,EAAE,eAAe,GACvB,IAAI,CAqJN"}

package/dist/algorithms/coordinate-assignment.d.ts

@@ -0,0 +1,7 @@
+import { Graph } from '../graph';
+import { ResolvedOptions } from '../types';
+/**
+ * Assign x,y coordinates to all nodes using a median-based iterative approach.
+ */
+export declare function assignCoordinates(graph: Graph, layers: string[][], options: ResolvedOptions): void;
+//# sourceMappingURL=coordinate-assignment.d.ts.map

package/dist/algorithms/coordinate-assignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinate-assignment.d.ts","sourceRoot":"","sources":["../../src/algorithms/coordinate-assignment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAmB,eAAe,EAAE,MAAM,UAAU,CAAC;AAE5D;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EAAE,EAAE,EAClB,OAAO,EAAE,eAAe,GACvB,IAAI,CAON"}

package/dist/algorithms/crossing-minimization.d.ts

@@ -0,0 +1,7 @@
+import { Graph } from '../graph';
+/**
+ * Minimize edge crossings using barycenter heuristic with transpose improvement.
+ */
+export declare function minimizeCrossings(graph: Graph, layers: string[][], iterations: number): string[][];
+export declare function countAllCrossings(graph: Graph, layers: string[][]): number;
+//# sourceMappingURL=crossing-minimization.d.ts.map

package/dist/algorithms/crossing-minimization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crossing-minimization.d.ts","sourceRoot":"","sources":["../../src/algorithms/crossing-minimization.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EAAE,EAAE,EAClB,UAAU,EAAE,MAAM,GACjB,MAAM,EAAE,EAAE,CAqEZ;AAgMD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,CAM1E"}

package/dist/algorithms/cycle-breaking.d.ts

@@ -0,0 +1,8 @@
+import { Graph } from '../graph';
+/**
+ * Break cycles in the graph using DFS-based back edge detection.
+ * Reverses back edges to make the graph a DAG.
+ * Returns the set of reversed edge IDs.
+ */
+export declare function breakCycles(graph: Graph): Set<string>;
+//# sourceMappingURL=cycle-breaking.d.ts.map

package/dist/algorithms/cycle-breaking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cycle-breaking.d.ts","sourceRoot":"","sources":["../../src/algorithms/cycle-breaking.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,CA4DrD"}

package/dist/algorithms/edge-routing.d.ts

@@ -0,0 +1,17 @@
+import { Graph } from '../graph';
+import { Point, LayoutDirection, EdgeKind } from '../types';
+export interface RoutedEdge {
+    id: string;
+    from: string;
+    to: string;
+    fromHandle: string;
+    toHandle: string;
+    points: Point[];
+    kind: EdgeKind;
+}
+/**
+ * Route all edges with orthogonal paths.
+ * Reconstructs original edges from dummy node chains.
+ */
+export declare function routeEdges(graph: Graph, direction: LayoutDirection, edgeMargin: number): RoutedEdge[];
+//# sourceMappingURL=edge-routing.d.ts.map

package/dist/algorithms/edge-routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-routing.d.ts","sourceRoot":"","sources":["../../src/algorithms/edge-routing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAyC,MAAM,UAAU,CAAC;AACxE,OAAO,EAAE,KAAK,EAAc,eAAe,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAExE,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,eAAe,EAC1B,UAAU,EAAE,MAAM,GACjB,UAAU,EAAE,CASd"}

package/dist/algorithms/layer-assignment.d.ts

@@ -0,0 +1,20 @@
+import { Graph } from '../graph';
+/**
+ * Two-pass layer assignment:
+ *
+ *   Pass A (control rail): longest-path on the subgraph induced by control
+ *   edges between non-value nodes. This defines the canonical execution
+ *   timeline — value nodes do not extend it.
+ *
+ *   Pass B (value pull): each value node is assigned the median layer of its
+ *   non-value neighbors. This snaps floating constants/imports onto the same
+ *   layer as the consumer that needs them, where they can be packed laterally.
+ */
+export declare function assignLayers(graph: Graph): string[][];
+/**
+ * Insert dummy nodes only for control edges that span multiple layers.
+ * Data edges keep their layer-span; routing handles them directly because
+ * they're typically short and decorative.
+ */
+export declare function insertDummyNodes(graph: Graph, layers: string[][]): string[][];
+//# sourceMappingURL=layer-assignment.d.ts.map

package/dist/algorithms/layer-assignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-assignment.d.ts","sourceRoot":"","sources":["../../src/algorithms/layer-assignment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,EAAE,EAAE,CA8GrD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CA0E7E"}

package/dist/algorithms/value-cluster.d.ts

@@ -0,0 +1,15 @@
+import { Graph } from '../graph';
+/**
+ * After crossing minimization places nodes onto their layers, this pass moves
+ * value nodes (data-only) so they sit immediately next to their dominant
+ * consumer/producer within the same layer.
+ *
+ * Without this pass, barycenter ordering happens to scatter values across the
+ * layer because their only incident edges are within the same layer (and so
+ * provide no cross-layer signal to the barycenter heuristic).
+ *
+ * Values are placed alternately on either side of the target so a hub
+ * consuming multiple values stays balanced.
+ */
+export declare function clusterValues(graph: Graph, layers: string[][]): void;
+//# sourceMappingURL=value-cluster.d.ts.map

package/dist/algorithms/value-cluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-cluster.d.ts","sourceRoot":"","sources":["../../src/algorithms/value-cluster.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,IAAI,CAuFpE"}