@planu/cli 4.10.12 → 4.11.1

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+## [4.11.1] - 2026-07-09
+
+### Bug Fixes
+- fix: benchmark representative graph sources
+- fix: verify release lockfile with pinned pnpm
+
+
+## [4.11.0] - 2026-07-09
+
+### Features
+- feat: add native project graph and value-only specs
+
+### Bug Fixes
+- fix: stabilize native graph release benchmark
+
+
 ## [4.10.12] - 2026-07-08
 
 ### Chores

package/dist/config/project-knowledge-graph.json

@@ -25,7 +25,11 @@
     "architecture_risk",
     "drift",
     "contract",
-    "git_change"
+    "git_change",
+    "symbol",
+    "tool_handler",
+    "module",
+    "scenario"
   ],
   "edgeTypes": [
     "contains",
@@ -44,13 +48,34 @@
     "depends_on",
     "has_evidence",
     "has_status",
-    "has_contract"
+    "has_contract",
+    "imports",
+    "re_exports",
+    "exports",
+    "defines"
   ],
   "classifications": ["extracted", "inferred", "ambiguous"],
   "confidenceLabels": ["high", "medium", "low"],
   "freshness": {
     "staleAfterMinutes": 1440
   },
+  "limits": {
+    "operational": {
+      "maxFiles": 20000,
+      "maxFileBytes": 2097152,
+      "maxNodes": 60,
+      "maxEdges": 120,
+      "maxDepth": 3
+    },
+    "hard": {
+      "maxFiles": 50000,
+      "maxFileBytes": 8388608,
+      "maxNodes": 200,
+      "maxEdges": 1000,
+      "maxDepth": 16
+    },
+    "evidence": "Operational limits preserve the existing project-graph contract. Hard caps bound native allocation and traversal to under 8 MiB per source and 1,000 returned edges."
+  },
   "query": {
     "maxNodes": 60,
     "maxEdges": 120,
@@ -83,7 +108,11 @@
       "risk",
       "tool",
       "contract",
-      "git_change"
+      "git_change",
+      "symbol",
+      "tool_handler",
+      "module",
+      "scenario"
     ],
     "edgeTypes": [
       "contains",
@@ -99,7 +128,11 @@
       "depends_on",
       "has_evidence",
       "has_status",
-      "has_contract"
+      "has_contract",
+      "imports",
+      "re_exports",
+      "exports",
+      "defines"
     ],
     "response": {
       "defaultLimit": 60,
@@ -117,7 +150,11 @@
       "architecture_risk": ["path", "ruleId", "severity"],
       "drift": ["specId", "status", "severity"],
       "contract": ["kind", "passed"],
-      "git_change": ["path", "status"]
+      "git_change": ["path", "status"],
+      "symbol": ["path", "name"],
+      "tool_handler": ["path", "name"],
+      "module": ["specifier"],
+      "scenario": ["path", "name"]
     }
   },
   "toolNamePatterns": [

package/dist/engine/core-bridge-project-graph.d.ts

@@ -0,0 +1,13 @@
+import type { AffectedNodeRs, CompactGraphSliceRs, GraphEdgeInputRs, GraphNodeInputRs, ProjectGraphLimitsPolicyRs, ProjectGraphSourceFileRs, ResolvedProjectGraphLimitsRs, ShortestPathResultRs, TsRelationRs } from '../types/core-bridge.js';
+export declare class ProjectGraphError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare function resolveProjectGraphLimits(policy: ProjectGraphLimitsPolicyRs, overrides?: Partial<ResolvedProjectGraphLimitsRs>): ResolvedProjectGraphLimitsRs;
+export declare function validateResolvedLimits(limits: ResolvedProjectGraphLimitsRs): void;
+export declare function tsScanProjectGraphSources(rootPath: string, limits: ResolvedProjectGraphLimitsRs): ProjectGraphSourceFileRs[];
+export declare function tsExtractTsRelations(rootPath: string, paths: string[], limits: ResolvedProjectGraphLimitsRs): TsRelationRs[];
+export declare function tsQueryAffectedNodes(seed: string, edges: GraphEdgeInputRs[], relationFilter: string[], limits: ResolvedProjectGraphLimitsRs): AffectedNodeRs[];
+export declare function tsQueryShortestPath(from: string, to: string, edges: GraphEdgeInputRs[], relationFilter: string[], limits: ResolvedProjectGraphLimitsRs): ShortestPathResultRs;
+export declare function tsSelectCompactGraphSlice(seeds: string[], nodes: GraphNodeInputRs[], edges: GraphEdgeInputRs[], limits: ResolvedProjectGraphLimitsRs): CompactGraphSliceRs;
+//# sourceMappingURL=core-bridge-project-graph.d.ts.map

package/dist/engine/core-bridge-project-graph.js

@@ -0,0 +1,499 @@
+import { createHash } from 'node:crypto';
+import { closeSync, fstatSync, lstatSync, openSync, readSync, readdirSync, realpathSync, } from 'node:fs';
+import { extname, isAbsolute, join, relative, sep } from 'node:path';
+const PROJECT_GRAPH_EXTS = new Set(['.ts', '.tsx', '.js', '.jsx', '.json', '.md']);
+const PROJECT_GRAPH_CODE_EXTS = new Set(['.ts', '.tsx', '.js', '.jsx']);
+const IGNORED_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'coverage',
+    '.next',
+    'target',
+    'npm',
+]);
+export class ProjectGraphError extends Error {
+    code;
+    constructor(code, message) {
+        super(`${code}: ${message}`);
+        this.code = code;
+        this.name = 'ProjectGraphError';
+    }
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareTuple(left, right) {
+    for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+        const compared = compareText(left[index] ?? '', right[index] ?? '');
+        if (compared !== 0) {
+            return compared;
+        }
+    }
+    return 0;
+}
+function validateLimit(name, value, hard) {
+    if (!Number.isSafeInteger(value) || !Number.isSafeInteger(hard) || value <= 0 || value > hard) {
+        throw new ProjectGraphError('PROJECT_GRAPH_INVALID_LIMIT', `${name} must be an integer between 1 and its hard cap (${String(hard)}), received ${String(value)}`);
+    }
+}
+export function resolveProjectGraphLimits(policy, overrides = {}) {
+    const candidate = policy;
+    if (candidate.operational === undefined || candidate.hard === undefined) {
+        throw new ProjectGraphError('PROJECT_GRAPH_INVALID_LIMIT', 'project graph limits policy must include operational and hard values');
+    }
+    const resolved = {
+        maxFiles: overrides.maxFiles ?? policy.operational.maxFiles,
+        maxFileBytes: overrides.maxFileBytes ?? policy.operational.maxFileBytes,
+        maxNodes: overrides.maxNodes ?? policy.operational.maxNodes,
+        maxEdges: overrides.maxEdges ?? policy.operational.maxEdges,
+        maxDepth: overrides.maxDepth ?? policy.operational.maxDepth,
+        hardMaxFiles: policy.hard.maxFiles,
+        hardMaxFileBytes: policy.hard.maxFileBytes,
+        hardMaxNodes: policy.hard.maxNodes,
+        hardMaxEdges: policy.hard.maxEdges,
+        hardMaxDepth: policy.hard.maxDepth,
+    };
+    validateResolvedLimits(resolved);
+    return resolved;
+}
+export function validateResolvedLimits(limits) {
+    validateLimit('maxFiles', limits.maxFiles, limits.hardMaxFiles);
+    validateLimit('maxFileBytes', limits.maxFileBytes, limits.hardMaxFileBytes);
+    validateLimit('maxNodes', limits.maxNodes, limits.hardMaxNodes);
+    validateLimit('maxEdges', limits.maxEdges, limits.hardMaxEdges);
+    validateLimit('maxDepth', limits.maxDepth, limits.hardMaxDepth);
+}
+function canonicalRoot(rootPath) {
+    if (rootPath.includes('\0') || !isAbsolute(rootPath)) {
+        throw new ProjectGraphError('PROJECT_GRAPH_INVALID_PATH', 'root path must be absolute and contain no NUL');
+    }
+    let root;
+    try {
+        root = realpathSync.native(rootPath);
+    }
+    catch (error) {
+        throw new ProjectGraphError('PROJECT_GRAPH_INVALID_ROOT', `cannot canonicalize root: ${error.message}`);
+    }
+    if (!lstatSync(root).isDirectory()) {
+        throw new ProjectGraphError('PROJECT_GRAPH_INVALID_ROOT', 'root is not a directory');
+    }
+    return root;
+}
+function validateRelativeCandidate(candidate) {
+    if (candidate.length === 0 ||
+        candidate.includes('\0') ||
+        isAbsolute(candidate) ||
+        candidate.startsWith('/') ||
+        candidate.startsWith('\\') ||
+        /^[A-Za-z]:[/\\]/u.test(candidate)) {
+        throw new ProjectGraphError('PROJECT_GRAPH_INVALID_PATH', `candidate must be a non-empty relative path: ${candidate}`);
+    }
+    const parts = candidate.split(/[\\/]/u);
+    if (parts.some((part) => part.length === 0 || part === '.' || part === '..')) {
+        throw new ProjectGraphError('PROJECT_GRAPH_INVALID_PATH', `candidate must be normalized and relative: ${candidate}`);
+    }
+    return parts;
+}
+function normalizedRelative(root, path) {
+    const result = relative(root, path);
+    if (result === '' || result === '..' || result.startsWith(`..${sep}`) || isAbsolute(result)) {
+        throw new ProjectGraphError('PROJECT_GRAPH_PATH_OUTSIDE_ROOT', `${path} is outside ${root}`);
+    }
+    return result.split(sep).join('/');
+}
+function resolveRegularCandidate(root, candidate) {
+    const parts = validateRelativeCandidate(candidate);
+    let current = root;
+    for (const part of parts) {
+        current = join(current, part);
+        let metadata;
+        try {
+            metadata = lstatSync(current);
+        }
+        catch (error) {
+            throw new ProjectGraphError('PROJECT_GRAPH_INVALID_PATH', `cannot inspect ${candidate}: ${error.message}`);
+        }
+        if (metadata.isSymbolicLink()) {
+            throw new ProjectGraphError('PROJECT_GRAPH_SYMLINK_FORBIDDEN', `symlink component is forbidden: ${candidate}`);
+        }
+    }
+    const canonical = realpathSync.native(current);
+    normalizedRelative(root, canonical);
+    const metadata = lstatSync(canonical);
+    if (!metadata.isFile()) {
+        throw new ProjectGraphError('PROJECT_GRAPH_NON_REGULAR_FILE', `candidate is not a regular file: ${candidate}`);
+    }
+    return { path: canonical, size: metadata.size, mtimeMs: metadata.mtimeMs };
+}
+function ensureFileSize(candidate, size, maxFileBytes) {
+    if (size > maxFileBytes) {
+        throw new ProjectGraphError('PROJECT_GRAPH_FILE_TOO_LARGE', `${candidate} exceeds maxFileBytes (${String(maxFileBytes)})`);
+    }
+}
+function hashFile(path, candidate, maxFileBytes) {
+    const descriptor = openSync(path, 'r');
+    try {
+        ensureFileSize(candidate, fstatSync(descriptor).size, maxFileBytes);
+        const hash = createHash('sha256');
+        const buffer = Buffer.allocUnsafe(64 * 1024);
+        let total = 0;
+        for (;;) {
+            const bytesRead = readSync(descriptor, buffer, 0, buffer.length, null);
+            if (bytesRead === 0) {
+                break;
+            }
+            total += bytesRead;
+            if (total > maxFileBytes) {
+                throw new ProjectGraphError('PROJECT_GRAPH_FILE_TOO_LARGE', `${candidate} grew beyond maxFileBytes (${String(maxFileBytes)}) while hashing`);
+            }
+            hash.update(buffer.subarray(0, bytesRead));
+        }
+        return hash.digest('hex');
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}
+function readBoundedUtf8(path, candidate, maxFileBytes) {
+    const descriptor = openSync(path, 'r');
+    try {
+        const initialSize = fstatSync(descriptor).size;
+        ensureFileSize(candidate, initialSize, maxFileBytes);
+        const bytes = Buffer.allocUnsafe(initialSize);
+        let offset = 0;
+        while (offset < bytes.length) {
+            const bytesRead = readSync(descriptor, bytes, offset, bytes.length - offset, null);
+            if (bytesRead === 0) {
+                break;
+            }
+            offset += bytesRead;
+        }
+        const growthProbe = Buffer.allocUnsafe(1);
+        if (readSync(descriptor, growthProbe, 0, 1, null) !== 0) {
+            throw new ProjectGraphError('PROJECT_GRAPH_FILE_TOO_LARGE', `${candidate} changed while reading`);
+        }
+        try {
+            return new TextDecoder('utf-8', { fatal: true }).decode(bytes.subarray(0, offset));
+        }
+        catch {
+            throw new ProjectGraphError('PROJECT_GRAPH_INVALID_UTF8', `${candidate} is not valid UTF-8`);
+        }
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}
+function walkFiles(root) {
+    const output = [];
+    const visit = (directory) => {
+        const entries = readdirSync(directory, { withFileTypes: true }).sort((left, right) => compareText(left.name, right.name));
+        for (const entry of entries) {
+            if (entry.isSymbolicLink()) {
+                continue;
+            }
+            const path = join(directory, entry.name);
+            if (entry.isDirectory()) {
+                if (!IGNORED_DIRS.has(entry.name)) {
+                    visit(path);
+                }
+            }
+            else if (entry.isFile()) {
+                output.push(path);
+            }
+        }
+    };
+    visit(root);
+    return output;
+}
+export function tsScanProjectGraphSources(rootPath, limits) {
+    validateResolvedLimits(limits);
+    const root = canonicalRoot(rootPath);
+    return walkFiles(root)
+        .filter((path) => PROJECT_GRAPH_EXTS.has(extname(path).toLowerCase()))
+        .map((path) => ({ path, candidate: normalizedRelative(root, path) }))
+        .sort((left, right) => compareText(left.candidate, right.candidate))
+        .slice(0, limits.maxFiles)
+        .map(({ candidate }) => {
+        const resolved = resolveRegularCandidate(root, candidate);
+        ensureFileSize(candidate, resolved.size, limits.maxFileBytes);
+        return {
+            path: candidate,
+            hash: hashFile(resolved.path, candidate, limits.maxFileBytes),
+            size: resolved.size,
+            mtime: resolved.mtimeMs,
+        };
+    });
+}
+const IMPORT_RE = /^\s*import(?:\s+type)?(?:[^'"]*from\s*)?['"]([^'"]+)['"]/gmu;
+const EXPORT_FROM_RE = /^\s*export\s+[^'"]*from\s*['"]([^'"]+)['"]/gmu;
+const EXPORT_SYMBOL_RE = /^\s*export\s+(?:async\s+)?(?:function|class|interface|type|const|let|var|enum)\s+([A-Za-z_$][\w$]*)/gmu;
+const DEFINE_SYMBOL_RE = /^\s*(?:export\s+)?(?:async\s+)?(?:function|class|interface|type|const|let|var|enum)\s+([A-Za-z_$][\w$]*)/gmu;
+const TEST_RE = /\b(describe|it|test)\s*\(\s*['"]([^'"]+)['"]/gu;
+function pushMatches(output, content, candidate, regex, relation, targetPrefix, confidence = 'high') {
+    for (const match of content.matchAll(new RegExp(regex.source, regex.flags))) {
+        const target = match[1]?.trim();
+        if (target) {
+            output.push({
+                from: `file:${candidate}`,
+                to: targetPrefix.endsWith('#') ? `${targetPrefix}${target}` : `${targetPrefix}:${target}`,
+                relation,
+                sourceFile: candidate,
+                confidence,
+                classification: 'extracted',
+            });
+        }
+    }
+}
+function relationTuple(relation) {
+    return [
+        relation.from,
+        relation.to,
+        relation.relation,
+        relation.sourceFile,
+        relation.confidence,
+        relation.classification,
+    ];
+}
+export function tsExtractTsRelations(rootPath, paths, limits) {
+    validateResolvedLimits(limits);
+    const root = canonicalRoot(rootPath);
+    if (paths.length > limits.maxFiles) {
+        throw new ProjectGraphError('PROJECT_GRAPH_LIMIT_EXCEEDED', `candidate count exceeds maxFiles (${String(limits.maxFiles)})`);
+    }
+    const candidates = [
+        ...new Set(paths.length > 0
+            ? paths
+            : tsScanProjectGraphSources(rootPath, limits).map((source) => source.path)),
+    ].sort(compareText);
+    const output = [];
+    for (const candidate of candidates) {
+        const resolved = resolveRegularCandidate(root, candidate);
+        ensureFileSize(candidate, resolved.size, limits.maxFileBytes);
+        if (!PROJECT_GRAPH_CODE_EXTS.has(extname(candidate).toLowerCase())) {
+            continue;
+        }
+        const content = readBoundedUtf8(resolved.path, candidate, limits.maxFileBytes);
+        pushMatches(output, content, candidate, IMPORT_RE, 'imports', 'module');
+        pushMatches(output, content, candidate, EXPORT_FROM_RE, 're_exports', 'module');
+        pushMatches(output, content, candidate, EXPORT_SYMBOL_RE, 'exports', `symbol:${candidate}#`);
+        pushMatches(output, content, candidate, DEFINE_SYMBOL_RE, 'defines', `symbol:${candidate}#`, 'medium');
+        if (candidate.includes('test.') ||
+            candidate.endsWith('.test.ts') ||
+            candidate.endsWith('.test.tsx')) {
+            for (const match of content.matchAll(new RegExp(TEST_RE.source, TEST_RE.flags))) {
+                const name = match[2]?.trim();
+                if (name) {
+                    output.push({
+                        from: `test:${candidate}`,
+                        to: `scenario:${candidate}#${name}`,
+                        relation: 'tests',
+                        sourceFile: candidate,
+                        confidence: 'medium',
+                        classification: 'extracted',
+                    });
+                }
+            }
+        }
+    }
+    return output.sort((left, right) => compareTuple(relationTuple(left), relationTuple(right)));
+}
+function validateText(name, value) {
+    if (value.length === 0 || value.includes('\0')) {
+        throw new ProjectGraphError('PROJECT_GRAPH_INVALID_INPUT', `${name} must be non-empty and contain no NUL`);
+    }
+}
+function validateEdges(edges, limits) {
+    if (edges.length > limits.hardMaxEdges) {
+        throw new ProjectGraphError('PROJECT_GRAPH_LIMIT_EXCEEDED', `edge count exceeds hard maxEdges (${String(limits.hardMaxEdges)})`);
+    }
+    const ids = new Set();
+    for (const edge of edges) {
+        validateText('edge.id', edge.id);
+        validateText('edge.from', edge.from);
+        validateText('edge.to', edge.to);
+        validateText('edge.relation', edge.relation);
+        if (ids.has(edge.id)) {
+            throw new ProjectGraphError('PROJECT_GRAPH_INVALID_INPUT', `duplicate edge id: ${edge.id}`);
+        }
+        ids.add(edge.id);
+    }
+}
+function relationFilterSet(relationFilter) {
+    for (const relation of relationFilter) {
+        validateText('relationFilter', relation);
+    }
+    return new Set(relationFilter);
+}
+function relationAllowed(relation, filter) {
+    return filter.size === 0 || filter.has(relation);
+}
+function sortedIncoming(edges, filter) {
+    const incoming = new Map();
+    for (const edge of edges) {
+        if (relationAllowed(edge.relation, filter)) {
+            const values = incoming.get(edge.to) ?? [];
+            values.push(edge);
+            incoming.set(edge.to, values);
+        }
+    }
+    for (const values of incoming.values()) {
+        values.sort((left, right) => compareTuple([left.from, left.id, left.relation], [right.from, right.id, right.relation]));
+    }
+    return incoming;
+}
+export function tsQueryAffectedNodes(seed, edges, relationFilter, limits) {
+    validateResolvedLimits(limits);
+    validateText('seed', seed);
+    validateEdges(edges, limits);
+    const incoming = sortedIncoming(edges, relationFilterSet(relationFilter));
+    const seen = new Set([seed]);
+    const queue = [{ node: seed, depth: 0 }];
+    const output = [];
+    let cursor = 0;
+    while (cursor < queue.length && output.length < limits.maxNodes) {
+        const current = queue[cursor++];
+        if (!current || current.depth >= limits.maxDepth) {
+            continue;
+        }
+        for (const edge of incoming.get(current.node) ?? []) {
+            if (output.length >= limits.maxNodes) {
+                break;
+            }
+            if (seen.has(edge.from)) {
+                continue;
+            }
+            seen.add(edge.from);
+            const nextDepth = current.depth + 1;
+            output.push({ nodeId: edge.from, depth: nextDepth, viaRelation: edge.relation });
+            queue.push({ node: edge.from, depth: nextDepth });
+        }
+    }
+    return output;
+}
+function undirectedAdjacency(edges, filter) {
+    const adjacency = new Map();
+    const add = (from, neighbor) => {
+        const values = adjacency.get(from) ?? [];
+        values.push(neighbor);
+        adjacency.set(from, values);
+    };
+    for (const edge of edges) {
+        if (relationAllowed(edge.relation, filter)) {
+            add(edge.from, { node: edge.to, edgeId: edge.id, relation: edge.relation });
+            add(edge.to, { node: edge.from, edgeId: edge.id, relation: edge.relation });
+        }
+    }
+    for (const values of adjacency.values()) {
+        values.sort((left, right) => compareTuple([left.node, left.edgeId, left.relation], [right.node, right.edgeId, right.relation]));
+    }
+    return adjacency;
+}
+export function tsQueryShortestPath(from, to, edges, relationFilter, limits) {
+    validateResolvedLimits(limits);
+    validateText('from', from);
+    validateText('to', to);
+    validateEdges(edges, limits);
+    if (from === to) {
+        return { nodeIds: [from], edgeIds: [] };
+    }
+    const adjacency = undirectedAdjacency(edges, relationFilterSet(relationFilter));
+    const queue = [from];
+    const seen = new Set([from]);
+    const predecessor = new Map();
+    let cursor = 0;
+    while (cursor < queue.length) {
+        const current = queue[cursor++];
+        if (!current) {
+            continue;
+        }
+        for (const neighbor of adjacency.get(current) ?? []) {
+            if (seen.has(neighbor.node)) {
+                continue;
+            }
+            if (seen.size >= limits.maxNodes) {
+                throw new ProjectGraphError('PROJECT_GRAPH_TRAVERSAL_LIMIT', `shortest-path traversal exceeded maxNodes (${String(limits.maxNodes)})`);
+            }
+            seen.add(neighbor.node);
+            predecessor.set(neighbor.node, { node: current, edgeId: neighbor.edgeId });
+            if (neighbor.node === to) {
+                const nodeIds = [to];
+                const edgeIds = [];
+                let pathCursor = to;
+                while (pathCursor !== from) {
+                    const previous = predecessor.get(pathCursor);
+                    if (!previous) {
+                        throw new ProjectGraphError('PROJECT_GRAPH_INTERNAL_ERROR', 'missing predecessor while reconstructing path');
+                    }
+                    edgeIds.push(previous.edgeId);
+                    nodeIds.push(previous.node);
+                    pathCursor = previous.node;
+                }
+                return { nodeIds: nodeIds.reverse(), edgeIds: edgeIds.reverse() };
+            }
+            queue.push(neighbor.node);
+        }
+    }
+    return { nodeIds: [], edgeIds: [] };
+}
+export function tsSelectCompactGraphSlice(seeds, nodes, edges, limits) {
+    validateResolvedLimits(limits);
+    if (nodes.length > limits.hardMaxNodes) {
+        throw new ProjectGraphError('PROJECT_GRAPH_LIMIT_EXCEEDED', `node count exceeds hard maxNodes (${String(limits.hardMaxNodes)})`);
+    }
+    validateEdges(edges, limits);
+    const known = new Set();
+    for (const node of nodes) {
+        validateText('node.id', node.id);
+        if (known.has(node.id)) {
+            throw new ProjectGraphError('PROJECT_GRAPH_INVALID_INPUT', `duplicate node id: ${node.id}`);
+        }
+        known.add(node.id);
+    }
+    const sortedSeeds = [...new Set(seeds)].sort(compareText);
+    for (const seed of sortedSeeds) {
+        validateText('seed', seed);
+    }
+    const selectedNodes = new Set(sortedSeeds.filter((seed) => known.size === 0 || known.has(seed)).slice(0, limits.maxNodes));
+    const queue = [...selectedNodes].sort(compareText);
+    const edgeById = new Map(edges.map((edge) => [edge.id, edge]));
+    const adjacency = undirectedAdjacency(edges, new Set());
+    const selectedEdgeIds = new Set();
+    const edgeIds = [];
+    let cursor = 0;
+    while (cursor < queue.length && edgeIds.length < limits.maxEdges) {
+        const current = queue[cursor++];
+        if (!current) {
+            continue;
+        }
+        for (const neighbor of adjacency.get(current) ?? []) {
+            if (edgeIds.length >= limits.maxEdges) {
+                break;
+            }
+            if (known.size > 0 && !known.has(neighbor.node)) {
+                continue;
+            }
+            const newNode = !selectedNodes.has(neighbor.node);
+            if (newNode && selectedNodes.size >= limits.maxNodes) {
+                continue;
+            }
+            if (newNode) {
+                selectedNodes.add(neighbor.node);
+                queue.push(neighbor.node);
+            }
+            if (!selectedEdgeIds.has(neighbor.edgeId)) {
+                selectedEdgeIds.add(neighbor.edgeId);
+                const edge = edgeById.get(neighbor.edgeId);
+                if (!edge) {
+                    throw new ProjectGraphError('PROJECT_GRAPH_INTERNAL_ERROR', 'adjacency references unknown edge');
+                }
+                if (selectedNodes.has(edge.from) && selectedNodes.has(edge.to)) {
+                    edgeIds.push(neighbor.edgeId);
+                }
+            }
+        }
+    }
+    return { nodeIds: [...selectedNodes].sort(compareText), edgeIds };
+}
+//# sourceMappingURL=core-bridge-project-graph.js.map

package/dist/engine/core-bridge.d.ts

@@ -1,5 +1,5 @@
-import type { FileHash, FileMetadata, SpecAnnotation, DriftResult, PlanuCore, DuplicateRawBlockRs, DuplicateBlockLocationRs, FastGrepMatch, FileContent, SpecBriefRs, AmbiguousCriterionRs, GapsLogChainResultRs, SearchResult, VectorNode } from '../types/core-bridge.js';
-export type { FileHash, FileMetadata, SpecAnnotation, DriftResult, PlanuCore, DuplicateRawBlockRs, DuplicateBlockLocationRs, FastGrepMatch, FileContent, SpecBriefRs, AmbiguousCriterionRs, GapsLogChainResultRs, SearchResult, VectorNode, };
+import type { FileHash, FileMetadata, SpecAnnotation, DriftResult, PlanuCore, DuplicateRawBlockRs, DuplicateBlockLocationRs, FastGrepMatch, FileContent, SpecBriefRs, AmbiguousCriterionRs, GapsLogChainResultRs, SearchResult, VectorNode, ProjectGraphSourceFileRs, TsRelationRs, GraphNodeInputRs, GraphEdgeInputRs, AffectedNodeRs, ShortestPathResultRs, CompactGraphSliceRs, CompactGraphEdgesRs, ProjectGraphLimitsPolicyRs, ResolvedProjectGraphLimitsRs } from '../types/core-bridge.js';
+export type { FileHash, FileMetadata, SpecAnnotation, DriftResult, PlanuCore, DuplicateRawBlockRs, DuplicateBlockLocationRs, FastGrepMatch, FileContent, SpecBriefRs, AmbiguousCriterionRs, GapsLogChainResultRs, SearchResult, VectorNode, ProjectGraphSourceFileRs, TsRelationRs, GraphNodeInputRs, GraphEdgeInputRs, AffectedNodeRs, ShortestPathResultRs, CompactGraphSliceRs, CompactGraphEdgesRs, ProjectGraphLimitsPolicyRs, ResolvedProjectGraphLimitsRs, };
 interface LoadDiagnostic {
     attempted: string[];
     errors: string[];
@@ -25,6 +25,11 @@ export declare function fastCosineSimilarity(v1: number[], v2: number[]): number
 export declare function fastHnswSearchFlat(query: number[], nodes: VectorNode[], topK: number): SearchResult[];
 export declare function fastHmacSign(secret: string, data: string): string;
 export declare function fastHmacVerify(secret: string, data: string, signature: string): boolean;
+export declare function fastScanProjectGraphSources(rootPath: string, policy: ProjectGraphLimitsPolicyRs, overrides?: Partial<ResolvedProjectGraphLimitsRs>): ProjectGraphSourceFileRs[];
+export declare function fastExtractTsRelations(rootPath: string, paths: string[], policy: ProjectGraphLimitsPolicyRs, overrides?: Partial<ResolvedProjectGraphLimitsRs>): TsRelationRs[];
+export declare function fastQueryAffectedNodes(seed: string, edges: GraphEdgeInputRs[], relationFilter: string[], policy: ProjectGraphLimitsPolicyRs, overrides?: Partial<ResolvedProjectGraphLimitsRs>): AffectedNodeRs[];
+export declare function fastQueryShortestPath(from: string, to: string, edges: GraphEdgeInputRs[], relationFilter: string[], policy: ProjectGraphLimitsPolicyRs, overrides?: Partial<ResolvedProjectGraphLimitsRs>): ShortestPathResultRs;
+export declare function fastSelectCompactGraphSlice(seeds: string[], nodes: GraphNodeInputRs[], edges: GraphEdgeInputRs[], policy: ProjectGraphLimitsPolicyRs, overrides?: Partial<ResolvedProjectGraphLimitsRs>): CompactGraphSliceRs;
 export declare function startNativeWatcher(rootPath: string, callback: (err: Error | null, event: string) => void): void;
 export declare const isNativeActive: () => boolean;
 export declare const nativeLoadDiagnostic: () => LoadDiagnostic;