npm - graphlin - Versions diffs - 0.1.0 - Mend

graphlin 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (60) hide show

package/.claude-plugin/plugin.json +12 -0
package/.codex-plugin/plugin.json +29 -0
package/.mcp.json +9 -0
package/LICENSE +21 -0
package/README.md +71 -0
package/adapters/README.md +32 -0
package/adapters/claude/hooks.json +10 -0
package/adapters/claude/profile.json +18 -0
package/adapters/codex/hooks.json +9 -0
package/adapters/codex/profile.json +22 -0
package/adapters/kiro/profile.json +8 -0
package/mcp.json +11 -0
package/package.json +114 -0
package/plugin.json +20 -0
package/runtime/collector/index.mjs +23 -0
package/runtime/core/candidates.mjs +300 -0
package/runtime/core/common.mjs +69 -0
package/runtime/core/evidence.mjs +150 -0
package/runtime/core/graph.mjs +398 -0
package/runtime/core/index.mjs +4 -0
package/runtime/core/lexical.mjs +255 -0
package/runtime/core/privacy.mjs +206 -0
package/runtime/core/tool-discovery.mjs +122 -0
package/runtime/daemon/auth.mjs +50 -0
package/runtime/daemon/connection-info.mjs +249 -0
package/runtime/daemon/demo.mjs +195 -0
package/runtime/daemon/diagnostics.mjs +404 -0
package/runtime/daemon/export.mjs +7 -0
package/runtime/daemon/ipc.mjs +28 -0
package/runtime/daemon/lock.mjs +137 -0
package/runtime/daemon/manager.mjs +320 -0
package/runtime/daemon/paths.mjs +108 -0
package/runtime/daemon/persistence.mjs +64 -0
package/runtime/daemon/server.mjs +292 -0
package/runtime/daemon/settings.mjs +103 -0
package/runtime/jev/fixture.mjs +99 -0
package/runtime/jev/index.mjs +784 -0
package/runtime/jev/questions.mjs +268 -0
package/runtime/jev/wire.mjs +152 -0
package/runtime/pipeline.mjs +1071 -0
package/runtime/web/app.js +2596 -0
package/runtime/web/index.html +265 -0
package/runtime/web/layout.js +336 -0
package/runtime/web/sidebar.js +525 -0
package/runtime/web/sketch.js +347 -0
package/runtime/web/style.css +593 -0
package/schemas/bundle.schema.json +243 -0
package/schemas/event.schema.json +108 -0
package/schemas/graph.schema.json +449 -0
package/schemas/patch.schema.json +111 -0
package/scripts/arguments.mjs +37 -0
package/scripts/build-packages.mjs +160 -0
package/scripts/collect.sh +23 -0
package/scripts/collector.mjs +11 -0
package/scripts/control.mjs +80 -0
package/scripts/daemon.mjs +28 -0
package/scripts/graphlin.mjs +112 -0
package/scripts/onboarding.mjs +413 -0
package/scripts/validate-packages.mjs +118 -0
package/skills/graphlin/SKILL.md +103 -0

package/runtime/web/index.html ADDED Viewed

@@ -0,0 +1,265 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <meta name="color-scheme" content="light">
+  <meta name="darkreader-lock">
+  <meta name="referrer" content="no-referrer">
+  <meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'self'; style-src 'self'; connect-src 'self'; img-src 'self' data:; font-src 'self'; base-uri 'none'; form-action 'none'; object-src 'none'">
+  <title>Graphlin — Live architecture</title>
+  <link rel="stylesheet" href="/style.css">
+  <script type="module" src="/app.js"></script>
+</head>
+<body>
+  <a class="skip-link" href="#main">Skip to architecture</a>
+  <div class="page">
+    <header class="masthead">
+      <a class="brand" href="/" aria-label="Graphlin live viewer"><span class="brand-mark" aria-hidden="true"></span>graphlin</a>
+      <div class="connection" id="connection" data-state="connecting">
+        <span class="connection-dot" aria-hidden="true"></span>
+        <span id="connection-label" role="status">Connecting to local service</span>
+        <button id="retry" class="text-button" type="button" hidden>Reconnect</button>
+      </div>
+    </header>
+    <main id="main">
+      <div class="intro">
+        <div>
+          <h1>Architecture, as it happens.</h1>
+          <p>Follow the work. Inspect the evidence behind each connection.</p>
+        </div>
+        <p id="project-label" class="project-label">Local project</p>
+      </div>
+      <div id="demo-banner" class="notice demo-notice" role="status" hidden>
+        <strong>Demo session</strong>
+        <span>Generated project and fixture classifier answers. This is an offline illustration, not a live Jev evaluation.</span>
+      </div>
+      <div id="error-banner" class="notice error-notice" role="alert" hidden></div>
+      <noscript><p class="notice">Enable JavaScript to receive local snapshots and inspect this architecture.</p></noscript>
+      <section class="workspace" aria-label="Session workspace">
+        <div class="workspace-toolbar">
+          <label class="session-picker" for="session">
+            <span>Session</span>
+            <select id="session" disabled><option value="">Waiting for a session</option></select>
+          </label>
+          <div class="session-actions">
+            <button type="button" id="classification-log" aria-haspopup="dialog" aria-controls="diagnostics-dialog">Classification log</button>
+            <button type="button" id="how-to-connect" aria-haspopup="dialog" aria-controls="connection-dialog">How to connect</button>
+            <button type="button" id="pause" aria-describedby="capture-note" disabled>Pause classification</button>
+            <button type="button" id="export" disabled>Export JSON</button>
+          </div>
+        </div>
+        <div class="status-strip" aria-label="Capture and classification status">
+          <div class="classification-status">
+            <span class="status-dot" id="classifier-dot" data-state="waiting" aria-hidden="true"></span>
+            <strong id="classifier-label">Waiting for local service</strong>
+            <span id="capture-note">Capture status will appear with the first snapshot.</span>
+          </div>
+          <div class="coverage-status"><span id="coverage-label">Coverage not reported</span><span id="queue-label">No snapshot yet</span></div>
+        </div>
+        <div class="workspace-body">
+          <section class="drawing" id="drawing" data-theme="sketchbook" aria-labelledby="canvas-title">
+            <div class="drawing-toolbar">
+              <div class="drawing-heading">
+                <h2 id="canvas-title">Live architecture</h2>
+                <span id="revision">Revision —</span>
+              </div>
+              <div class="zoom-controls" role="group" aria-label="Diagram zoom">
+                <button type="button" id="zoom-out" aria-label="Zoom out" disabled>−</button>
+                <output id="zoom-level" aria-label="Zoom level">100%</output>
+                <button type="button" id="zoom-in" aria-label="Zoom in" disabled>+</button>
+                <button type="button" id="fit" disabled>Fit</button>
+              </div>
+            </div>
+            <div class="layout-toolbar" role="group" aria-label="Diagram arrangement">
+              <label for="layout">Layout
+                <select id="layout" disabled>
+                  <option value="hierarchy">Hierarchy top-down</option>
+                  <option value="dependency">Dependency left-right</option>
+                  <option value="grouped">Group by type</option>
+                  <option value="circular">Circular</option>
+                  <option value="grid">Grid</option>
+                  <option value="original">Original</option>
+                </select>
+              </label>
+              <button type="button" id="arrange" disabled>Arrange</button>
+              <label class="auto-arrange" for="auto-arrange"><input id="auto-arrange" type="checkbox" checked disabled> Auto-arrange</label>
+              <div class="theme-picker">
+                <label for="theme">Theme
+                  <select id="theme" aria-describedby="theme-note" disabled>
+                    <option value="sketchbook">Sketchbook</option>
+                    <option value="ocean">Ocean</option>
+                    <option value="forest">Forest</option>
+                    <option value="sunset">Sunset</option>
+                    <option value="berry">Berry</option>
+                    <option value="sepia">Sepia</option>
+                    <option value="blueprint">Blueprint dark</option>
+                    <option value="midnight">Midnight dark</option>
+                  </select>
+                </label>
+                <span class="theme-preview" aria-hidden="true"><i></i><i></i><i></i><i></i></span>
+              </div>
+              <span class="screen-reader" id="theme-note">Colors follow component types. Themes change appearance only.</span>
+              <span id="layout-note">Arranges when components or connections change.</span>
+            </div>
+            <div class="diagram-stage" id="diagram-stage">
+              <svg id="architecture" viewBox="0 0 920 510" role="group" tabindex="0" aria-labelledby="diagram-title diagram-desc">
+                <title id="diagram-title">Architecture diagram</title>
+                <desc id="diagram-desc">Components and relationships will appear as evidence arrives. Select a component or relationship to inspect its evidence.</desc>
+                <defs>
+                  <marker id="arrow-observed" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto"><path d="M 0 0 L 10 5 L 0 10 Z" class="arrow-observed"></path></marker>
+                  <marker id="arrow-proposed" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto"><path d="M 0 0 L 10 5 L 0 10 Z" class="arrow-proposed"></path></marker>
+                  <marker id="arrow-stale" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto"><path d="M 0 0 L 10 5 L 0 10 Z" class="arrow-stale"></path></marker>
+                </defs>
+                <g id="edge-layer"></g>
+                <g id="edge-label-layer"></g>
+                <g id="node-layer"></g>
+                <g id="effects-layer" aria-hidden="true" pointer-events="none"></g>
+              </svg>
+              <div class="empty-canvas" id="empty-canvas">
+                <div class="empty-map" aria-hidden="true"><i></i><span></span><i></i></div>
+                <h3 id="empty-title">Your architecture starts here.</h3>
+                <p id="empty-description">Waiting for the local service. Safe activity and supported components will appear as your agent works.</p>
+                <div id="orientation" class="orientation">
+                  <p>Ask your connected agent:</p>
+                  <blockquote id="orientation-prompt" tabindex="0">Orient yourself in this project: read its main files and explain how the components connect.</blockquote>
+                  <button id="orientation-copy" type="button">Copy orientation prompt</button>
+                  <p id="orientation-copy-status" role="status" aria-live="polite"></p>
+                </div>
+              </div>
+            </div>
+            <div class="drawing-footer">
+              <div class="legend" aria-label="Diagram legend">
+                <span><i class="observed" aria-hidden="true"></i>Code evidence</span>
+                <span><i class="proposed" aria-hidden="true"></i>Proposed / tentative</span>
+                <span><i class="stale" aria-hidden="true"></i>Stale / retracted</span>
+              </div>
+              <span id="graph-count">No components yet</span>
+            </div>
+            <details class="shape-key">
+              <summary>Shape key</summary>
+              <div id="shape-key-items"></div>
+              <p>Shapes describe component types. Display overrides change appearance only.</p>
+            </details>
+            <p class="diagram-note" id="diagram-note">Code classification does not establish runtime connectivity.</p>
+          </section>
+          <aside class="live-sidebar" id="live-sidebar" aria-label="Live activity and evidence">
+            <section class="onboarding" aria-labelledby="onboarding-title">
+              <h2 id="onboarding-title">Getting your first shape</h2>
+              <ol class="onboarding-progress" aria-label="Observed setup progress">
+                <li id="onboarding-server">Connecting to server</li>
+                <li id="onboarding-setup">Agent setup / trust: unverified</li>
+                <li id="onboarding-hooks">Waiting for a hook receipt</li>
+                <li id="onboarding-classification">Waiting for a classifier call</li>
+                <li id="onboarding-shape">Waiting for the first shape</li>
+              </ol>
+              <p class="sidebar-note">Hooks and calls are project-wide observations. A receipt confirms delivery, not full host trust; a call does not confirm success.</p>
+              <p id="onboarding-next" class="onboarding-next">Keep the Graphlin server terminal open while the viewer connects.</p>
+              <button id="onboarding-action" type="button" disabled>How to connect</button>
+            </section>
+            <details class="sidebar-hooks" id="sidebar-hooks" open>
+              <summary><span class="sidebar-title"><i class="hook-live-dot" id="sidebar-hook-dot" data-state="waiting" aria-hidden="true"></i>Hooks received</span><span class="sidebar-count" id="sidebar-hook-count">0</span></summary>
+              <p class="sidebar-note" id="sidebar-hook-coverage">Received hooks from all sessions in this project will appear here.</p>
+              <p class="sidebar-empty" id="sidebar-hook-empty">Waiting for hooks. Work in a connected agent to see each receipt here.</p>
+              <ol id="sidebar-hook-list" class="hook-receipts" aria-label="Received hooks across this project, newest first"></ol>
+            </details>
+            <section class="sidebar-history sidebar-theme" id="sidebar-history" data-theme="sketchbook" aria-labelledby="sidebar-change-heading">
+              <div class="sidebar-heading"><h2 id="sidebar-change-heading">Diagram changes</h2><span class="sidebar-count" id="sidebar-change-count">0</span></div>
+              <p class="sidebar-note" id="sidebar-change-note">Newest changes first. Select a shape to inspect it, or a revision to replay.</p>
+              <p class="sidebar-empty" id="sidebar-change-empty">Shape changes will stack here as this session discovers or changes the architecture.</p>
+              <ol class="diagram-changes" id="sidebar-change-list" aria-label="Diagram changes in this session, newest first"></ol>
+            </section>
+            <section class="inspector" aria-labelledby="inspector-heading">
+            <div class="inspector-header"><h2 id="inspector-heading">Evidence inspector</h2><button type="button" id="clear-selection" class="text-button" hidden>Clear</button></div>
+            <div id="inspector-body">
+              <div class="inspector-empty">
+                <span class="inspector-glyph" aria-hidden="true">↗</span>
+                <h3>Every connection has a reason.</h3>
+                <p>Select a component or an arrow to see its classification, confidence, and source references.</p>
+                <p class="inspector-hint">Use Tab to reach diagram items, then Enter to inspect.</p>
+              </div>
+            </div>
+            </section>
+          </aside>
+        </div>
+        <div class="playback">
+          <div class="mode-buttons" role="group" aria-label="Architecture view">
+            <button id="live" type="button" aria-pressed="true">Live</button>
+            <button id="replay" type="button" aria-pressed="false" disabled>Replay</button>
+          </div>
+          <label class="scrubber" for="history">
+            <span class="screen-reader">Recent architecture revision</span>
+            <input id="history" type="range" min="0" max="0" value="0" step="1" disabled aria-describedby="replay-note">
+            <output id="history-position" for="history">No history</output>
+          </label>
+          <span id="replay-note">Live follows the latest snapshot.</span>
+        </div>
+      </section>
+      <section class="activity-section" aria-labelledby="activity-heading">
+        <div class="activity-heading">
+          <div><h2 id="activity-heading">Activity stream</h2><p id="activity-note">Observable work, independent of classification.</p></div>
+          <span id="activity-count">0 events</span>
+          <button id="activity-toggle" type="button" aria-expanded="true" aria-controls="activity-content">Hide activity log</button>
+        </div>
+        <div id="activity-content">
+          <p class="activity-empty" id="activity-empty">No activity received. Start work in a connected agent session; its captured events will appear here.</p>
+          <ol id="activity-list" class="activity-list" aria-label="Recent activity, newest first"></ol>
+        </div>
+      </section>
+    </main>
+    <footer><p>Local viewer <span aria-hidden="true">/</span> evidence before inference</p><p id="updated-at">Waiting for a snapshot</p></footer>
+    <div id="announcement" class="screen-reader" role="status" aria-live="polite" aria-atomic="true"></div>
+    <div id="toast" class="toast" role="status" hidden></div>
+  </div>
+  <dialog id="diagnostics-dialog" class="diagnostics-dialog" aria-labelledby="diagnostics-title" aria-describedby="diagnostics-intro">
+    <div class="diagnostics-header">
+      <h2 id="diagnostics-title">Classification log</h2>
+      <button type="button" id="diagnostics-close" aria-label="Close classification log">Close</button>
+    </div>
+    <p id="diagnostics-intro">See which files were considered and why components were drawn or skipped.</p>
+    <p class="diagnostics-note">This is the live local log, including while replay is selected. Scores from before logging was enabled cannot be recovered.</p>
+    <div class="diagnostics-filters">
+      <label for="diagnostics-search">Find a record
+        <input id="diagnostics-search" type="search" maxlength="200" autocomplete="off" placeholder="File, label, event, or session">
+      </label>
+      <label for="diagnostics-session">Sessions
+        <select id="diagnostics-session"><option value="all">All sessions</option></select>
+      </label>
+      <button type="button" id="diagnostics-refresh">Refresh log</button>
+    </div>
+    <p id="diagnostics-loading" class="diagnostics-note" role="status" hidden>Loading classification records…</p>
+    <p id="diagnostics-error" class="diagnostics-error" role="alert" hidden></p>
+    <p id="diagnostics-count" class="diagnostics-note" role="status" aria-live="polite" aria-atomic="true"></p>
+    <p id="diagnostics-empty" class="diagnostics-empty" hidden></p>
+    <div id="diagnostics-records" class="diagnostics-records" role="region" aria-label="Classification records, newest first" aria-busy="false"></div>
+    <div class="diagnostics-footer">
+      <p id="diagnostics-updated" class="diagnostics-note"></p>
+      <p id="diagnostics-stats" class="diagnostics-note"></p>
+      <p id="diagnostics-log-path" class="diagnostics-log-path" hidden></p>
+    </div>
+  </dialog>
+  <dialog id="connection-dialog" class="connection-dialog" aria-labelledby="connection-dialog-title" aria-describedby="connection-dialog-intro">
+    <div class="connection-dialog-header">
+      <h2 id="connection-dialog-title">How to connect</h2>
+      <button type="button" id="connection-dialog-close" aria-label="Close connection instructions">Close</button>
+    </div>
+    <p id="connection-dialog-intro">Keep the server terminal open. Open a new terminal for the commands below.</p>
+    <p id="connection-project" class="connection-project" hidden></p>
+    <p id="connection-demo" class="notice demo-notice" hidden>Demo project. These instructions refer to the demo’s project.</p>
+    <p id="connection-loading" class="connection-loading" role="status" hidden>Loading connection instructions…</p>
+    <p id="connection-error" class="connection-error" role="alert" hidden></p>
+    <button type="button" id="connection-instructions-retry" hidden>Retry instructions</button>
+    <div id="connection-instructions" aria-busy="false"></div>
+    <ul id="connection-notes" class="connection-notes" hidden></ul>
+    <p id="connection-copy-status" class="connection-copy-status" role="status" aria-live="polite" aria-atomic="true"></p>
+  </dialog>
+</body>
+</html>

package/runtime/web/layout.js ADDED Viewed

@@ -0,0 +1,336 @@
+// Pure browser/Node layout; coordinates are the top-left of each node.
+// Only positions are returned. Direction comes from actual edges, never kinds.
+export const LAYOUT_ALGORITHMS = Object.freeze([
+  'hierarchy', 'dependency', 'grouped', 'circular', 'grid', 'original',
+]);
+const MAX_NODES = 256;
+const MAX_EDGES = 768;
+// Bound intake work as well as layout work. Ordinary oversized inputs select
+// the lowest IDs/pairs deterministically; pathological arrays fail closed.
+const MAX_INPUT_NODES = 4096;
+const MAX_INPUT_EDGES = 12288;
+const MAX_DIMENSION = 10000;
+const SWEEPS = 4;
+const record = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const finite = value => typeof value === 'number' && Number.isFinite(value);
+const compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+const validId = value => typeof value === 'string' && value.length > 0 && value.length <= 256;
+const numeric = (value, fallback, minimum) => finite(value) && value >= minimum
+  ? Math.min(value, MAX_DIMENSION) : fallback;
+function compareNodes(a, b) {
+  const completeA = a.x !== null && a.y !== null;
+  const completeB = b.x !== null && b.y !== null;
+  return compare(a.id, b.id) || compare(completeB, completeA) || compare(a.kind, b.kind) ||
+    compare(a.x === null, b.x === null) || compare(a.x, b.x) ||
+    compare(a.y === null, b.y === null) || compare(a.y, b.y);
+}
+function prepare(graph) {
+  const inputNodes = Array.isArray(graph?.nodes) ? graph.nodes : [];
+  const inputEdges = Array.isArray(graph?.edges) ? graph.edges : [];
+  if (inputNodes.length > MAX_INPUT_NODES || inputEdges.length > MAX_INPUT_EDGES) {
+    return { nodes: [], edges: [] };
+  }
+  const byId = new Map();
+  for (const raw of inputNodes) {
+    if (!record(raw) || !validId(raw.id)) continue;
+    const node = {
+      id: raw.id,
+      kind: typeof raw.kind === 'string' && raw.kind.length > 0 && raw.kind.length <= 80 ? raw.kind : 'unknown',
+      x: finite(raw.x) ? raw.x : null,
+      y: finite(raw.y) ? raw.y : null,
+    };
+    const previous = byId.get(node.id);
+    if (!previous || compareNodes(node, previous) < 0) byId.set(node.id, node);
+  }
+  const nodes = [...byId.values()].sort(compareNodes).slice(0, MAX_NODES);
+  const index = new Map(nodes.map((node, i) => [node.id, i]));
+  const pairs = new Map();
+  for (const edge of inputEdges) {
+    if (!record(edge) || !index.has(edge.source) || !index.has(edge.target)) continue;
+    const source = index.get(edge.source), target = index.get(edge.target);
+    // A self-loop does not change a node's position. Parallel relations share
+    // one structural pair, so relation count does not bias placement.
+    if (source !== target) pairs.set(`${source}:${target}`, { source, target });
+  }
+  return { nodes, edges: [...pairs.values()].sort((a, b) => a.source - b.source || a.target - b.target).slice(0, MAX_EDGES) };
+}
+function grid(items, size) {
+  const columns = Math.max(1, Math.min(items.length,
+    Math.ceil(Math.sqrt(items.length * (size.h + size.gy) / (size.w + size.gx)))));
+  const positions = new Map(items.map((item, i) => [item, {
+    x: (i % columns) * (size.w + size.gx),
+    y: Math.floor(i / columns) * (size.h + size.gy),
+  }]));
+  return {
+    positions,
+    width: Math.min(columns, items.length) * (size.w + size.gx) - size.gx,
+    height: Math.ceil(items.length / columns) * (size.h + size.gy) - size.gy,
+  };
+}
+// Shelf packing keeps disconnected components/kind groups disjoint without
+// implying containment, ownership, or relationships between their members.
+function pack(blocks, size) {
+  if (!blocks.length) return new Map();
+  const gapX = Math.max(size.gx * 2, size.w / 2, 16);
+  const gapY = Math.max(size.gy * 2, size.h / 2, 16);
+  const area = blocks.reduce((sum, block) => sum + (block.width + gapX) * (block.height + gapY), 0);
+  const targetWidth = Math.max(...blocks.map(block => block.width), Math.sqrt(area));
+  const result = new Map();
+  let x = 0, y = 0, rowHeight = 0;
+  for (const block of blocks) {
+    if (x > 0 && x + block.width > targetWidth) {
+      x = 0; y += rowHeight + gapY; rowHeight = 0;
+    }
+    for (const [id, point] of block.positions) result.set(id, { x: x + point.x, y: y + point.y });
+    x += block.width + gapX;
+    rowHeight = Math.max(rowHeight, block.height);
+  }
+  return result;
+}
+function grouped(nodes, size) {
+  const kinds = new Map();
+  for (const node of nodes) {
+    if (!kinds.has(node.kind)) kinds.set(node.kind, []);
+    kinds.get(node.kind).push(node.id);
+  }
+  return pack([...kinds.keys()].sort(compare).map(kind => grid(kinds.get(kind), size)), size);
+}
+function circular(nodes, size) {
+  if (nodes.length === 1) return new Map([[nodes[0].id, { x: 0, y: 0 }]]);
+  // Adjacent centers are separated by the diagonal of an expanded node.
+  // Consequently every pair of axis-aligned node boxes is disjoint, even at
+  // the 256-node limit or with extreme aspect ratios. One pixel absorbs error.
+  const radius = (Math.hypot(size.w + size.gx, size.h + size.gy) + 1) /
+    (2 * Math.sin(Math.PI / nodes.length));
+  const points = nodes.map((node, i) => {
+    const angle = -Math.PI / 2 + i * 2 * Math.PI / nodes.length;
+    return [node.id, { x: radius * Math.cos(angle), y: radius * Math.sin(angle) }];
+  });
+  const minX = Math.min(...points.map(([, point]) => point.x));
+  const minY = Math.min(...points.map(([, point]) => point.y));
+  return new Map(points.map(([id, point]) => [id, { x: point.x - minX, y: point.y - minY }]));
+}
+function original(nodes, size) {
+  const result = new Map(), missing = [];
+  for (const node of nodes) {
+    if (node.x !== null && node.y !== null) result.set(node.id, { x: node.x, y: node.y });
+    else missing.push(node);
+  }
+  const columns = Math.max(1, Math.ceil(Math.sqrt(nodes.length)));
+  let next = 0;
+  // A fixed box can obstruct at most four cells of this grid. Five cells per
+  // node therefore suffice, including cells occupied by earlier fallbacks.
+  for (let slot = 0; next < missing.length && slot < MAX_NODES * 5; slot++) {
+    const point = { x: (slot % columns) * (size.w + size.gx),
+      y: Math.floor(slot / columns) * (size.h + size.gy) };
+    const obstructed = [...result.values()].some(other =>
+      Math.abs(point.x - other.x) < size.w + size.gx - 1e-8 &&
+      Math.abs(point.y - other.y) < size.h + size.gy - 1e-8);
+    if (!obstructed) result.set(missing[next++].id, point);
+  }
+  return result;
+}
+function stronglyConnected(outgoing) {
+  const indices = Array(outgoing.length).fill(-1), low = [], stacked = new Set(), stack = [], groups = [];
+  let counter = 0;
+  function visit(vertex) {
+    indices[vertex] = low[vertex] = counter++;
+    stack.push(vertex); stacked.add(vertex);
+    for (const target of outgoing[vertex]) {
+      if (indices[target] === -1) { visit(target); low[vertex] = Math.min(low[vertex], low[target]); }
+      else if (stacked.has(target)) low[vertex] = Math.min(low[vertex], indices[target]);
+    }
+    if (low[vertex] !== indices[vertex]) return;
+    const members = [];
+    let member;
+    do { member = stack.pop(); stacked.delete(member); members.push(member); } while (member !== vertex);
+    groups.push(members.sort((a, b) => a - b));
+  }
+  // Recursion is bounded by the admitted 256 vertices.
+  for (let i = 0; i < outgoing.length; i++) if (indices[i] === -1) visit(i);
+  return groups.sort((a, b) => a[0] - b[0]);
+}
+function condense(nodes, edges, size) {
+  const outgoing = nodes.map(() => []);
+  for (const { source, target } of edges) outgoing[source].push(target);
+  const members = stronglyConnected(outgoing);
+  const owner = new Map();
+  members.forEach((group, i) => group.forEach(vertex => owner.set(vertex, i)));
+  const blocks = members.map(group => grid(group.map(vertex => nodes[vertex].id), size));
+  const next = members.map(() => new Set()), previous = members.map(() => new Set());
+  for (const edge of edges) {
+    const source = owner.get(edge.source), target = owner.get(edge.target);
+    if (source !== target) { next[source].add(target); previous[target].add(source); }
+  }
+  return {
+    blocks,
+    next: next.map(values => [...values].sort((a, b) => a - b)),
+    previous: previous.map(values => [...values].sort((a, b) => a - b)),
+  };
+}
+function weakComponents(next, previous) {
+  const seen = new Set(), result = [];
+  for (let root = 0; root < next.length; root++) {
+    if (seen.has(root)) continue;
+    const group = [], queue = [root];
+    seen.add(root);
+    for (let i = 0; i < queue.length; i++) {
+      const current = queue[i]; group.push(current);
+      for (const neighbor of [...next[current], ...previous[current]]) {
+        if (!seen.has(neighbor)) { seen.add(neighbor); queue.push(neighbor); }
+      }
+    }
+    result.push(group.sort((a, b) => a - b));
+  }
+  return result;
+}
+function rankedLayers(group, next, previous) {
+  const degrees = previous.map(values => values.length), rank = next.map(() => 0);
+  const queue = group.filter(vertex => degrees[vertex] === 0);
+  while (queue.length) {
+    queue.sort((a, b) => a - b);
+    const current = queue.shift();
+    for (const target of next[current]) {
+      rank[target] = Math.max(rank[target], rank[current] + 1);
+      if (--degrees[target] === 0) queue.push(target);
+    }
+  }
+  const layers = Array.from({ length: Math.max(...group.map(vertex => rank[vertex])) + 1 }, () => []);
+  for (const vertex of group) layers[rank[vertex]].push(vertex);
+  return { layers, rank };
+}
+function rowWidth(row, sizes, gap) {
+  return row.reduce((sum, vertex) => sum + sizes[vertex], 0) + Math.max(0, row.length - 1) * gap;
+}
+function crossCenters(layers, sizes, gap) {
+  const centers = new Map();
+  for (const row of layers) {
+    let offset = -rowWidth(row, sizes, gap) / 2;
+    for (const vertex of row) {
+      centers.set(vertex, offset + sizes[vertex] / 2);
+      offset += sizes[vertex] + gap;
+    }
+  }
+  return centers;
+}
+function reduceCrossings(initial, rank, next, previous, sizes, gap) {
+  const edges = initial.flat().flatMap(source => next[source].map(target => ({ source, target })));
+  const bands = new Map();
+  for (const edge of edges) {
+    const key = `${rank[edge.source]}:${rank[edge.target]}`;
+    if (!bands.has(key)) bands.set(key, []);
+    bands.get(key).push(edge);
+  }
+  function quality(layers) {
+    const centers = crossCenters(layers, sizes, gap);
+    let crossings = 0, span = 0;
+    for (const edge of edges) span += Math.abs(centers.get(edge.source) - centers.get(edge.target));
+    for (const band of bands.values()) for (let i = 0; i < band.length; i++) {
+      for (let j = i + 1; j < band.length; j++) {
+        const a = band[i], b = band[j];
+        if ((centers.get(a.source) - centers.get(b.source)) *
+          (centers.get(a.target) - centers.get(b.target)) < 0) crossings++;
+      }
+    }
+    return { crossings, span };
+  }
+  let layers = initial.map(row => [...row]), best = layers.map(row => [...row]), score = quality(best);
+  // Fixed forward/backward barycenter sweeps, retaining only the best ordering.
+  // Comparison uses actual endpoint geometry and does not introduce edges.
+  for (let sweep = 0; sweep < SWEEPS; sweep++) for (const forward of [true, false]) {
+    let centers = crossCenters(layers, sizes, gap);
+    const order = layers.map((_, i) => i);
+    if (!forward) order.reverse();
+    for (const index of order) {
+      const row = layers[index], neighbors = forward ? previous : next;
+      const scored = row.map((vertex, oldIndex) => ({
+        vertex, oldIndex,
+        value: neighbors[vertex].length
+          ? neighbors[vertex].reduce((sum, neighbor) => sum + centers.get(neighbor), 0) / neighbors[vertex].length
+          : centers.get(vertex),
+      }));
+      scored.sort((a, b) => a.value - b.value || a.oldIndex - b.oldIndex || a.vertex - b.vertex);
+      layers[index] = scored.map(item => item.vertex);
+      centers = crossCenters(layers, sizes, gap);
+    }
+    const candidate = quality(layers);
+    if (candidate.crossings < score.crossings ||
+      (candidate.crossings === score.crossings && candidate.span < score.span - 1e-8)) {
+      score = candidate; best = layers.map(row => [...row]);
+    }
+  }
+  return best;
+}
+function directed(nodes, edges, size, horizontal) {
+  const { blocks, next, previous } = condense(nodes, edges, size);
+  const crossSizes = blocks.map(block => horizontal ? block.height : block.width);
+  const flowSizes = blocks.map(block => horizontal ? block.width : block.height);
+  const crossGap = horizontal ? size.gy : size.gx, flowGap = horizontal ? size.gx : size.gy;
+  const components = weakComponents(next, previous).map(group => {
+    const ranked = rankedLayers(group, next, previous);
+    const layers = reduceCrossings(ranked.layers, ranked.rank, next, previous, crossSizes, crossGap);
+    const breadth = Math.max(...layers.map(row => rowWidth(row, crossSizes, crossGap)));
+    const positions = new Map();
+    let flow = 0;
+    for (const row of layers) {
+      const depth = Math.max(...row.map(vertex => flowSizes[vertex]));
+      let cross = (breadth - rowWidth(row, crossSizes, crossGap)) / 2;
+      for (const vertex of row) {
+        const offset = flow + (depth - flowSizes[vertex]) / 2;
+        for (const [id, point] of blocks[vertex].positions) positions.set(id, {
+          x: point.x + (horizontal ? offset : cross),
+          y: point.y + (horizontal ? cross : offset),
+        });
+        cross += crossSizes[vertex] + crossGap;
+      }
+      flow += depth + flowGap;
+    }
+    return { positions, width: horizontal ? flow - flowGap : breadth,
+      height: horizontal ? breadth : flow - flowGap };
+  });
+  return pack(components, size);
+}
+/**
+ * Return a fresh Map<id, {x,y}> in ID order without modifying graph/options.
+ * Algorithms: hierarchy (default, top-down), dependency (left-right), grouped
+ * (kind only), circular, grid, original. Unknown algorithms use hierarchy.
+ * Generated layouts do not overlap; original intentionally preserves finite
+ * coordinate pairs, including existing overlaps, and fills missing pairs.
+ * Dimensions: finite [1, 10000], gaps [0, 10000]; invalid values use defaults.
+ * Layout admits 256 unique nodes and 768 distinct directed endpoint pairs.
+ * Inputs above 4096 nodes or 12288 edges return an empty Map (bounded intake).
+ */
+export function layoutGraph(graph, options = {}) {
+  const settings = record(options) ? options : {};
+  const size = {
+    w: numeric(settings.nodeWidth, 190, 1), h: numeric(settings.nodeHeight, 104, 1),
+    gx: numeric(settings.gapX, 80, 0), gy: numeric(settings.gapY, 80, 0),
+  };
+  const { nodes, edges } = prepare(graph);
+  if (!nodes.length) return new Map();
+  const algorithm = LAYOUT_ALGORITHMS.includes(settings.algorithm) ? settings.algorithm : 'hierarchy';
+  let positions;
+  if (algorithm === 'grid') positions = grid(nodes.map(node => node.id), size).positions;
+  else if (algorithm === 'original') positions = original(nodes, size);
+  else if (algorithm === 'grouped') positions = grouped(nodes, size);
+  else if (algorithm === 'circular') positions = circular(nodes, size);
+  else positions = directed(nodes, edges, size, algorithm === 'dependency');
+  return new Map(nodes.map(node => [node.id, positions.get(node.id)]));
+}