@psnext/lscg 0.1.1

package/dist/src/storage/schema.js

@@ -0,0 +1,93 @@
+export const SCHEMA_VERSION = 2;
+export const CREATE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS schema_migrations (
+  version INTEGER PRIMARY KEY,
+  applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS repositories (
+  id TEXT PRIMARY KEY,
+  root TEXT NOT NULL,
+  name TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS files (
+  id TEXT PRIMARY KEY,
+  repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
+  path TEXT NOT NULL,
+  language TEXT NOT NULL,
+  hash TEXT NOT NULL,
+  size INTEGER NOT NULL,
+  mtime_ms INTEGER NOT NULL,
+  scanned_at TEXT NOT NULL DEFAULT (datetime('now')),
+  UNIQUE(repository_id, path)
+);
+
+CREATE TABLE IF NOT EXISTS nodes (
+  id TEXT PRIMARY KEY,
+  repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
+  file_id TEXT REFERENCES files(id) ON DELETE CASCADE,
+  kind TEXT NOT NULL,
+  type TEXT NOT NULL,
+  name TEXT,
+  start_byte INTEGER NOT NULL,
+  end_byte INTEGER NOT NULL,
+  start_point TEXT NOT NULL,
+  end_point TEXT NOT NULL,
+  source_hash TEXT NOT NULL,
+  parser TEXT NOT NULL,
+  parser_version TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  last_modified_user_id TEXT
+);
+
+CREATE TABLE IF NOT EXISTS edges (
+  id TEXT PRIMARY KEY,
+  repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
+  file_id TEXT NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+  source_id TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,
+  target_id TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,
+  kind TEXT NOT NULL,
+  confidence REAL NOT NULL DEFAULT 1.0,
+  metadata_json TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS overlays (
+  id TEXT PRIMARY KEY,
+  repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
+  subject_id TEXT NOT NULL,
+  subject_kind TEXT NOT NULL,
+  operation TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_files_repo_path ON files(repository_id, path);
+CREATE INDEX IF NOT EXISTS idx_nodes_repo_kind ON nodes(repository_id, kind);
+CREATE INDEX IF NOT EXISTS idx_nodes_repo_name ON nodes(repository_id, name);
+CREATE INDEX IF NOT EXISTS idx_edges_repo_kind ON edges(repository_id, kind);
+CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id);
+CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id);
+`;
+export const CREATE_NODES_TABLE_SQL = `
+CREATE TABLE nodes_new (
+  id TEXT PRIMARY KEY,
+  repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
+  file_id TEXT REFERENCES files(id) ON DELETE CASCADE,
+  kind TEXT NOT NULL,
+  type TEXT NOT NULL,
+  name TEXT,
+  start_byte INTEGER NOT NULL,
+  end_byte INTEGER NOT NULL,
+  start_point TEXT NOT NULL,
+  end_point TEXT NOT NULL,
+  source_hash TEXT NOT NULL,
+  parser TEXT NOT NULL,
+  parser_version TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  last_modified_user_id TEXT
+);
+`;
+//# sourceMappingURL=schema.js.map

package/dist/src/types.d.ts

@@ -0,0 +1,233 @@
+import type Parser from 'tree-sitter';
+export type GraphScope = 'repo' | 'home' | 'both';
+export type StorageScope = Exclude<GraphScope, 'both'>;
+export type GraphNodeKind = 'file' | 'symbol' | 'import' | 'export' | 'call' | 'user';
+export type GraphEdgeKind = 'contains' | 'defines' | 'imports' | 'exports' | 'calls' | 'attributed_to';
+export interface Point {
+    row: number;
+    column: number;
+}
+export interface RepositoryRecord {
+    id: string;
+    root: string;
+    name: string;
+}
+export interface FileRecord {
+    id: string;
+    path: string;
+    language: string;
+    hash: string;
+    size: number;
+    mtimeMs: number;
+}
+export interface GraphNode {
+    id: string;
+    kind: GraphNodeKind;
+    type: string;
+    name: string | null;
+    startByte: number;
+    endByte: number;
+    startPoint: Point;
+    endPoint: Point;
+    sourceHash: string;
+    parser: string;
+    parserVersion: string;
+    metadata: Record<string, unknown>;
+    lastModifiedUserId: string | null;
+}
+export interface GraphEdge {
+    id: string;
+    sourceId: string;
+    targetId: string;
+    kind: GraphEdgeKind;
+    confidence: number;
+    metadata: Record<string, unknown>;
+}
+export interface ParseResult {
+    tree: Parser.Tree;
+    language: string;
+    parser: string;
+    parserVersion: string;
+}
+export interface ExtractGraphInput {
+    repositoryId: string;
+    fileId: string;
+    relativePath: string;
+    source: string;
+    sourceHash: string;
+    parseResult: ParseResult;
+}
+export interface GraphExtractionResult {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+}
+export interface ContributorIdentity {
+    email: string;
+}
+export interface NodeAttribution {
+    nodeId: string;
+    contributorEmails: string[];
+    lastModifiedEmail: string | null;
+}
+export interface FileAttribution {
+    contributorEmails: ContributorIdentity[];
+    nodeAttributions: NodeAttribution[];
+}
+export interface ScanSummary {
+    repository: RepositoryRecord;
+    scopes: Array<{
+        scope: StorageScope;
+        databasePath: string;
+    }>;
+    filesDiscovered: number;
+    filesScanned: number;
+    nodesWritten: number;
+    edgesWritten: number;
+    skipped: string[];
+}
+export interface RepositoryInfo {
+    id: string;
+    root: string;
+    name: string;
+}
+export interface GraphNodeRow {
+    id: string;
+    kind: GraphNodeKind;
+    type: string;
+    name: string | null;
+    fileId: string | null;
+    startByte: number;
+    endByte: number;
+    metadataJson: string;
+    lastModifiedUserId: string | null;
+}
+export interface GraphNodeTextRow extends GraphNodeRow {
+    path: string | null;
+    startPoint: Point;
+    endPoint: Point;
+}
+export interface GraphEdgeRow {
+    id: string;
+    kind: GraphEdgeKind;
+    sourceId: string;
+    targetId: string;
+    fileId: string;
+    confidence: number;
+    metadataJson: string;
+}
+export interface NeighborRow {
+    id: string;
+    kind: GraphNodeKind;
+    type: string;
+    name: string | null;
+    viaEdgeId: string | null;
+    depth: number;
+}
+export interface CallGraphRelation {
+    id: string;
+    kind: GraphNodeKind;
+    type: string;
+    name: string | null;
+    viaEdgeId: string;
+    edgeKind: GraphEdgeKind;
+    depth: number;
+}
+export interface CallGraphMatch extends GraphNodeRow {
+    upstream: CallGraphRelation[];
+    downstream: CallGraphRelation[];
+}
+export interface StatusResult {
+    repository: RepositoryRecord | null;
+    files: number;
+    nodes: number;
+    edges: number;
+}
+/** Stable, transport-neutral contract returned by the context retrieval command. */
+export type ContextResultState = 'ok' | 'ambiguous' | 'not_found' | 'refresh_failed' | 'stale';
+export type ContextFreshnessState = 'unchanged' | 'refreshed' | 'stale' | 'refresh_failed';
+export type ContextFreshnessVerification = 'metadata_only' | 'content_hash';
+export type ContextRelationCategory = 'definition' | 'impact' | 'dependency';
+export interface ContextBudget {
+    depth: number;
+    relationshipLimit: number;
+    candidateLimit: number;
+    excerptLines: number;
+    excerptBytes: number;
+}
+export interface ContextRequest {
+    symbol: string;
+    root: string;
+    scope: GraphScope;
+    kind?: string;
+    file?: string;
+    budget: ContextBudget;
+    excerpts: boolean;
+}
+export interface ContextSpan {
+    start: Point;
+    end: Point;
+}
+export interface ContextSourceReference {
+    id: string;
+    path: string | null;
+    kind: GraphNodeKind;
+    type: string;
+    name: string | null;
+    span: ContextSpan;
+    sourceHash: string | null;
+    parser: string | null;
+    parserVersion: string | null;
+    metadata: Record<string, unknown>;
+    excerpt?: string;
+}
+export interface ContextRelationship {
+    category: ContextRelationCategory;
+    edgeKind: GraphEdgeKind;
+    direction: 'caller' | 'callee' | 'import' | 'export' | 'contains';
+    source: ContextSourceReference;
+    target: ContextSourceReference;
+    confidence: number;
+    provenance: Record<string, unknown>;
+    depth: number;
+}
+export interface ContextCandidate extends ContextSourceReference {
+    rank: number;
+    match: 'qualified' | 'exact' | 'prefix' | 'substring';
+}
+export interface ContextTruncation {
+    section: 'candidates' | 'impact' | 'dependencies' | 'definition' | 'work';
+    reason: 'limit' | 'depth' | 'candidate_limit' | 'work_budget';
+    omitted: number;
+}
+export interface ContextRefreshSummary {
+    outcome: 'reused' | 'refreshed' | 'refresh_failed';
+    filesDiscovered: number;
+    filesScanned: number;
+    skipped: string[];
+}
+export interface ContextScopeResult {
+    scope: StorageScope;
+    databasePath: string;
+    result: {
+        state: ContextResultState;
+        anchor?: ContextSourceReference;
+        candidates?: ContextCandidate[];
+        definition?: ContextSourceReference;
+        impact: ContextRelationship[];
+        dependencies: ContextRelationship[];
+        warnings: string[];
+        truncation: ContextTruncation[];
+    };
+    freshness: {
+        state: ContextFreshnessState;
+        verification: ContextFreshnessVerification;
+        refresh: ContextRefreshSummary;
+    };
+}
+export interface ContextGraphResult {
+    contract_version: 1;
+    repository: RepositoryRecord;
+    request: ContextRequest;
+    scopes: ContextScopeResult[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/view/index.d.ts

@@ -0,0 +1,27 @@
+import type { StorageScope } from '../types.js';
+import { type ViewModelOptions } from './model.js';
+import { type BrowserOpenResult } from './open.js';
+export interface ViewCommandOptions extends ViewModelOptions {
+    output?: string | undefined;
+}
+export interface ViewRunResult {
+    mode: 'interactive' | 'export';
+    scope: StorageScope;
+    artifactPath: string;
+    opened: boolean;
+    command?: string | undefined;
+    error?: string | undefined;
+    anchorNodeId: string | null;
+    search: string | null;
+    nodeCount: number;
+    edgeCount: number;
+}
+export interface ViewRunDependencies {
+    opener?: (targetPath: string) => BrowserOpenResult;
+}
+export declare function viewGraph(options?: ViewCommandOptions, dependencies?: ViewRunDependencies): Promise<ViewRunResult>;
+export { buildViewModel, loadViewSnapshot } from './model.js';
+export type { ViewSnapshot, ViewNode, ViewEdge, ViewBox, ViewModel } from './model.js';
+export { renderInteractiveHtml, renderSvgMarkup, writeSvgSnapshot } from './render.js';
+export { openHtmlArtifactInBrowser, openInDefaultBrowser, writeTemporaryHtmlArtifact } from './open.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/view/index.js

@@ -0,0 +1,42 @@
+import path from 'node:path';
+import { mkdirSync } from 'node:fs';
+import { buildViewModel, loadViewSnapshot } from './model.js';
+import { openHtmlArtifactInBrowser } from './open.js';
+import { renderInteractiveHtml, renderSvgMarkup, writeSvgSnapshot } from './render.js';
+export async function viewGraph(options = {}, dependencies = {}) {
+    const snapshot = loadViewSnapshot(options);
+    const model = buildViewModel(snapshot, options);
+    if (options.output) {
+        const svg = renderSvgMarkup(model, { includeHiddenNodes: false, interactive: false });
+        mkdirSync(path.dirname(options.output), { recursive: true });
+        writeSvgSnapshot(options.output, svg);
+        return {
+            mode: 'export',
+            scope: model.scope,
+            artifactPath: options.output,
+            opened: false,
+            anchorNodeId: model.anchorNodeId,
+            search: model.search,
+            nodeCount: model.nodes.length,
+            edgeCount: model.edges.length
+        };
+    }
+    const html = renderInteractiveHtml(model);
+    const opened = openHtmlArtifactInBrowser(html, dependencies.opener);
+    return {
+        mode: 'interactive',
+        scope: model.scope,
+        artifactPath: opened.htmlPath,
+        opened: opened.opened,
+        command: opened.command,
+        error: opened.error,
+        anchorNodeId: model.anchorNodeId,
+        search: model.search,
+        nodeCount: model.nodes.length,
+        edgeCount: model.edges.length
+    };
+}
+export { buildViewModel, loadViewSnapshot } from './model.js';
+export { renderInteractiveHtml, renderSvgMarkup, writeSvgSnapshot } from './render.js';
+export { openHtmlArtifactInBrowser, openInDefaultBrowser, writeTemporaryHtmlArtifact } from './open.js';
+//# sourceMappingURL=index.js.map

package/dist/src/view/layout.d.ts

@@ -0,0 +1,28 @@
+export interface GraphLike {
+    order: number;
+    forEachNode(callback: (nodeId: string, attributes: Record<string, unknown>) => void): void;
+    setNodeAttribute(nodeId: string, attribute: 'x' | 'y', value: number): void;
+    addNode(nodeId: string, attributes: Record<string, unknown>): void;
+    addEdgeWithKey(edgeId: string, sourceId: string, targetId: string, attributes: Record<string, unknown>): void;
+    hasNode(nodeId: string): boolean;
+    getNodeAttributes(nodeId: string): Record<string, unknown>;
+}
+export interface LayoutBounds {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+    width: number;
+    height: number;
+    centerX: number;
+    centerY: number;
+}
+export interface LayoutOptions {
+    size?: number | undefined;
+    padding?: number | undefined;
+}
+export declare function assignDeterministicLayout(graph: GraphLike, options?: LayoutOptions): LayoutBounds;
+export declare function collectBounds(graph: GraphLike): LayoutBounds;
+export declare function emptyBounds(): LayoutBounds;
+export declare function finalizeBounds(minX: number, maxX: number, minY: number, maxY: number): LayoutBounds;
+//# sourceMappingURL=layout.d.ts.map

package/dist/src/view/layout.js

@@ -0,0 +1,235 @@
+const GOLDEN_ANGLE = Math.PI * (3 - Math.sqrt(5));
+const NODE_GAP = 14;
+const CLUSTER_GAP = 72;
+const MAX_RELAX_ITERATIONS = 80;
+export function assignDeterministicLayout(graph, options = {}) {
+    const size = options.size ?? 1000;
+    const padding = options.padding ?? 80;
+    if (graph.order === 0) {
+        return emptyBounds();
+    }
+    const nodes = [];
+    graph.forEachNode((nodeId, attributes) => {
+        nodes.push({
+            nodeId,
+            index: nodes.length,
+            kind: normalizeKind(attributes.kind),
+            degree: Number(attributes.degree ?? 0),
+            label: normalizeLabel(attributes.label, nodeId)
+        });
+    });
+    if (nodes.length === 1) {
+        const onlyNode = nodes[0];
+        graph.setNodeAttribute(onlyNode.nodeId, 'x', size / 2);
+        graph.setNodeAttribute(onlyNode.nodeId, 'y', size / 2);
+        return collectBounds(graph);
+    }
+    const clusters = buildClusters(nodes);
+    const allPositions = placeClusteredNodes(clusters, size, padding);
+    for (const position of allPositions) {
+        graph.setNodeAttribute(position.nodeId, 'x', position.x);
+        graph.setNodeAttribute(position.nodeId, 'y', position.y);
+    }
+    return collectBounds(graph);
+}
+export function collectBounds(graph) {
+    if (graph.order === 0)
+        return emptyBounds();
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    graph.forEachNode((_nodeId, attributes) => {
+        const x = Number(attributes.x ?? 0);
+        const y = Number(attributes.y ?? 0);
+        if (x < minX)
+            minX = x;
+        if (x > maxX)
+            maxX = x;
+        if (y < minY)
+            minY = y;
+        if (y > maxY)
+            maxY = y;
+    });
+    return finalizeBounds(minX, maxX, minY, maxY);
+}
+export function emptyBounds() {
+    return {
+        minX: 0,
+        maxX: 0,
+        minY: 0,
+        maxY: 0,
+        width: 0,
+        height: 0,
+        centerX: 0,
+        centerY: 0
+    };
+}
+export function finalizeBounds(minX, maxX, minY, maxY) {
+    if (!Number.isFinite(minX) || !Number.isFinite(maxX) || !Number.isFinite(minY) || !Number.isFinite(maxY)) {
+        return emptyBounds();
+    }
+    const width = maxX - minX;
+    const height = maxY - minY;
+    return {
+        minX,
+        maxX,
+        minY,
+        maxY,
+        width,
+        height,
+        centerX: minX + width / 2,
+        centerY: minY + height / 2
+    };
+}
+function buildClusters(nodes) {
+    const byKind = new Map();
+    for (const node of nodes) {
+        const bucket = byKind.get(node.kind) ?? [];
+        bucket.push(node);
+        byKind.set(node.kind, bucket);
+    }
+    const clusters = [...byKind.entries()]
+        .map(([kind, clusterNodes]) => ({
+        kind,
+        nodes: [...clusterNodes].sort(compareLayoutNode),
+        radius: clusterRadius(clusterNodes)
+    }))
+        .sort((left, right) => {
+        if (right.nodes.length !== left.nodes.length)
+            return right.nodes.length - left.nodes.length;
+        if (right.radius !== left.radius)
+            return right.radius - left.radius;
+        return left.kind.localeCompare(right.kind);
+    });
+    return clusters;
+}
+function placeClusteredNodes(clusters, size, padding) {
+    if (clusters.length === 0)
+        return [];
+    const center = size / 2;
+    const maxClusterRadius = Math.max(...clusters.map((cluster) => cluster.radius));
+    const ringRadius = clusters.length === 1
+        ? 0
+        : Math.max((2 * maxClusterRadius + CLUSTER_GAP) / (2 * Math.sin(Math.PI / clusters.length)), center - padding - maxClusterRadius);
+    const clusterRingRadius = Math.max(ringRadius, maxClusterRadius + 48);
+    const centerRadius = clusters.length === 1 ? 0 : clusterRingRadius;
+    const positionedClusters = clusters.map((cluster, index) => {
+        const angle = clusters.length === 1 ? 0 : -Math.PI / 2 + (index * (Math.PI * 2)) / clusters.length;
+        const centerX = center + Math.cos(angle) * centerRadius;
+        const centerY = center + Math.sin(angle) * centerRadius;
+        return { ...cluster, centerX, centerY };
+    });
+    const positions = [];
+    for (const cluster of positionedClusters) {
+        const localPositions = placeNodesWithinCluster(cluster);
+        positions.push(...localPositions);
+    }
+    relaxCollisions(positions);
+    return positions.map(({ nodeId, x, y }) => ({ nodeId, x, y }));
+}
+function placeNodesWithinCluster(cluster) {
+    const maxRadius = Math.max(...cluster.nodes.map((node) => nodeRadius(node.degree, maxNodeDegree(cluster.nodes))), 6);
+    const spiralSpacing = Math.max(maxRadius * 2 + 20, 44);
+    const ringSpacing = spiralSpacing * 0.9;
+    return cluster.nodes.map((node, index) => {
+        if (index === 0) {
+            return {
+                nodeId: node.nodeId,
+                x: cluster.centerX,
+                y: cluster.centerY,
+                radius: nodeRadius(node.degree, maxNodeDegree(cluster.nodes)),
+                centerX: cluster.centerX,
+                centerY: cluster.centerY
+            };
+        }
+        const radius = nodeRadius(node.degree, maxNodeDegree(cluster.nodes));
+        const orbit = Math.max(ringSpacing * Math.sqrt(index), radius + NODE_GAP);
+        const angle = index * GOLDEN_ANGLE + stableAngleOffset(cluster.kind);
+        return {
+            nodeId: node.nodeId,
+            x: cluster.centerX + Math.cos(angle) * orbit,
+            y: cluster.centerY + Math.sin(angle) * orbit,
+            radius,
+            centerX: cluster.centerX,
+            centerY: cluster.centerY
+        };
+    });
+}
+function relaxCollisions(nodes) {
+    if (nodes.length <= 1)
+        return;
+    for (let iteration = 0; iteration < MAX_RELAX_ITERATIONS; iteration += 1) {
+        let moved = false;
+        for (let leftIndex = 0; leftIndex < nodes.length; leftIndex += 1) {
+            for (let rightIndex = leftIndex + 1; rightIndex < nodes.length; rightIndex += 1) {
+                const left = nodes[leftIndex];
+                const right = nodes[rightIndex];
+                const dx = right.x - left.x;
+                const dy = right.y - left.y;
+                const distance = Math.hypot(dx, dy);
+                const required = left.radius + right.radius + NODE_GAP;
+                if (distance >= required)
+                    continue;
+                const overlap = required - distance;
+                const [nx, ny] = normalizedVector(dx, dy, left, right);
+                const shift = overlap / 2;
+                left.x -= nx * shift;
+                left.y -= ny * shift;
+                right.x += nx * shift;
+                right.y += ny * shift;
+                moved = true;
+            }
+        }
+        if (!moved)
+            return;
+    }
+}
+function normalizedVector(dx, dy, left, right) {
+    if (dx !== 0 || dy !== 0) {
+        const length = Math.hypot(dx, dy) || 1;
+        return [dx / length, dy / length];
+    }
+    const fallbackDx = right.centerX - left.centerX;
+    const fallbackDy = right.centerY - left.centerY;
+    if (fallbackDx !== 0 || fallbackDy !== 0) {
+        const length = Math.hypot(fallbackDx, fallbackDy) || 1;
+        return [fallbackDx / length, fallbackDy / length];
+    }
+    return [1, 0];
+}
+function clusterRadius(nodes) {
+    const maxRadius = Math.max(...nodes.map((node) => nodeRadius(node.degree, maxNodeDegree(nodes))), 6);
+    const spread = Math.sqrt(nodes.length) * (maxRadius * 2 + 18);
+    return maxRadius + 36 + spread / Math.PI;
+}
+function compareLayoutNode(left, right) {
+    if (right.degree !== left.degree)
+        return right.degree - left.degree;
+    const labelComparison = left.label.localeCompare(right.label);
+    if (labelComparison !== 0)
+        return labelComparison;
+    return left.nodeId.localeCompare(right.nodeId);
+}
+function normalizeKind(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : 'unknown';
+}
+function normalizeLabel(value, fallback) {
+    return typeof value === 'string' && value.trim() ? value.trim() : fallback;
+}
+function stableAngleOffset(kind) {
+    let hash = 0;
+    for (let index = 0; index < kind.length; index += 1) {
+        hash = (hash * 31 + kind.charCodeAt(index)) >>> 0;
+    }
+    return (hash % 997) / 997 * Math.PI * 2;
+}
+function nodeRadius(degree, maxDegree) {
+    if (maxDegree <= 0)
+        return 4;
+    return Math.max(4, Math.max(0, degree) * 4);
+}
+function maxNodeDegree(nodes) {
+    return nodes.reduce((max, node) => Math.max(max, node.degree), 0);
+}
+//# sourceMappingURL=layout.js.map