gitnexus 1.6.13-rc.83 → 1.6.13-rc.85

package/dist/core/ingestion/filesystem-walker.d.ts

@@ -9,6 +9,8 @@ export interface FilePath {
 }
 export declare const READ_CONCURRENCY = 32;
 export interface WalkRepositoryOptions {
+    /** Capture required metadata before stat/size filtering can omit its inputs. */
+    onPathsDiscovered?: (paths: readonly string[]) => Promise<void>;
     /**
      * Suppress the operator-facing large-file notice. Set by read-only callers
      * such as `status`, which reuse this scan purely to learn which files the

package/dist/core/ingestion/filesystem-walker.js

@@ -1,6 +1,7 @@
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { DEFAULT_MAX_FILE_SIZE_BYTES, getMaxFileSizeBytes } from './utils/max-file-size.js';
 import fs from 'fs/promises';
+import { readdir } from 'node:fs';
 import path from 'path';
 import { glob } from 'glob';
 import { createIgnoreFilter } from '../../config/ignore-service.js';
@@ -36,7 +37,7 @@ const warnLargeFileSkip = (message) => {
     logger.warn(message);
 };
 /**
- * Phase 1: Scan repository — stat files to get paths + sizes, no content loaded.
+ * Phase 1: Scan repository — capture required metadata, then stat paths + sizes.
  * Memory: ~10MB for 100K files vs ~1GB+ with content.
  */
 const assertWalkRootIsDirectory = async (repoPath) => {
@@ -59,12 +60,29 @@ export const walkRepositoryPaths = async (repoPath, onProgress, options = {}) =>
     await assertWalkRootIsDirectory(repoPath);
     const ignoreFilter = await createIgnoreFilter(repoPath);
     const maxFileSizeBytes = options.maxFileSizeBytes ?? getMaxFileSizeBytes();
-    const filtered = await glob('**/*', {
+    let enumerationError;
+    const filtered = (await glob('**/*', {
         cwd: repoPath,
         nodir: true,
         dot: false,
         ignore: ignoreFilter,
-    });
+        // glob treats unreadable directories as empty. Required metadata must
+        // not silently lose declarations, so retain the first enumeration error.
+        fs: options.onPathsDiscovered === undefined
+            ? undefined
+            : {
+                readdir(directory, readOptions, callback) {
+                    readdir(directory, readOptions, (error, entries) => {
+                        if (error)
+                            enumerationError ??= error;
+                        callback(error, entries);
+                    });
+                },
+            },
+    })).map((filePath) => filePath.replace(/\\/g, '/'));
+    if (enumerationError !== undefined)
+        throw enumerationError;
+    await options.onPathsDiscovered?.(filtered);
     const entries = [];
     let processed = 0;
     let skippedLarge = 0;
@@ -76,10 +94,10 @@ export const walkRepositoryPaths = async (repoPath, onProgress, options = {}) =>
             const stat = await fs.stat(fullPath);
             if (stat.size > maxFileSizeBytes) {
                 skippedLarge++;
-                skippedLargePaths.push(relativePath.replace(/\\/g, '/'));
+                skippedLargePaths.push(relativePath);
                 return null;
             }
-            return { path: relativePath.replace(/\\/g, '/'), size: stat.size };
+            return { path: relativePath, size: stat.size };
         }));
         for (const result of results) {
             processed++;

package/dist/core/ingestion/languages/dart/package-config.d.ts

@@ -1,49 +1,21 @@
-import type { Dirent } from 'node:fs';
 export interface DartPackageConfig {
     readonly packages: ReadonlyMap<string, string>;
     readonly manifestsByName: ReadonlyMap<string, readonly string[]>;
 }
 export interface DartPackageConfigOptions {
-    /** Test seam. Production calls omit it and use the module directory limit. */
-    readonly directoryLimit?: number;
-    /** Test seam. Production calls omit it and use the open-directory cap. */
-    readonly directoryDepthLimit?: number;
-    /** Test seam. Production calls omit it and use the per-directory entry cap. */
-    readonly directoryEntryLimit?: number;
-    /**
-     * Test seam. Production calls omit it. Invoked after the directory inode
-     * is listed and before its entries are opened.
-     */
-    readonly beforeEntryOpen?: (relativePath: string) => void | Promise<void>;
-    /**
-     * Test seam. Production calls omit it. Invoked after the directory is
-     * opened and before it is listed.
-     */
-    readonly beforeDirectoryList?: (relativePath: string) => void | Promise<void>;
+    /** Test seam. Production calls use the manifest-count limit. */
+    readonly manifestLimit?: number;
 }
-/** Linux anchors child opens. macOS verifies them. Every other platform does neither. */
-export declare function pubspecWalkAnchored(): boolean;
-export declare function directoryOpenFlags(): number;
 /**
- * Path that lists the directory inode already open on `fd`.
- * Only Linux has one: `/proc/self/fd/N`. macOS refuses `opendir` on
- * `/dev/fd/N` for a directory (ENOTDIR) and Node has no `fdopendir`, so the
- * walker lists the lexical path and verifies the pinned chain around it.
- * Every other platform returns null and is not walked.
+ * Capture declarations from the shared scan, before source stat/size filtering.
+ * No directory enumeration occurs here. Every enumerated regular manifest must
+ * be captured successfully before this config can be published.
+ *
+ * Acquisition assumes a stable, trusted workspace, like the source-file reader.
+ * Static symlinks/junctions are excluded and observed file changes are rejected;
+ * these checks do not provide a sandbox or an atomic view of a mutating tree.
+ * Once returned, resolution uses only this compact map, on every operating system.
  */
-export declare function descriptorDirectoryPath(fd: number): string | null;
-/**
- * One entry of the directory inode open on `fd`.
- * Linux looks up `/proc/self/fd/N/<name>` in that inode. macOS `/dev/fd/N/<name>`
- * does not resolve a child, so this returns null and the walker verifies the
- * pinned parent chain instead. Every other platform returns null and is not walked.
- */
-export declare function descriptorEntryPath(fd: number, name: string): string | null;
-/**
- * Open `directory` without following a final symlink, then list that inode.
- * A path swapped for a symlink after the parent listing fails this open
- * (`ENOTDIR` / `ELOOP`) instead of being traversed.
- */
-export declare function readDirectoryNoFollow(directory: string): Promise<Dirent[]>;
-/** Discover only in-repository packages; never follow dependency paths or symlinks. */
+export declare function captureDartPackageConfig(repoPath: string, filePaths: readonly string[], options?: DartPackageConfigOptions): Promise<DartPackageConfig>;
+/** Standalone callers use the same scanner/capture boundary as the pipeline. */
 export declare function loadDartPackageConfig(repoPath: string, options?: DartPackageConfigOptions): Promise<DartPackageConfig>;

package/dist/core/ingestion/languages/dart/package-config.js

@@ -1,36 +1,46 @@
-import { constants, lstat, open, opendir } from 'node:fs/promises';
+import { constants, lstat, open } from 'node:fs/promises';
 import path from 'node:path';
 import { JSON_SCHEMA, load } from 'js-yaml';
-import { createWatchIgnorePredicate } from '../../../../config/ignore-service.js';
+import { loadIgnoreRules } from '../../../../config/ignore-service.js';
 import { logger } from '../../../logger.js';
+import { walkRepositoryPaths } from '../../filesystem-walker.js';
 import { getMaxFileSizeBytes } from '../../utils/max-file-size.js';
-/** An incomplete walk cannot prove package names are unique. */
-const DART_PUBSPEC_DIRECTORY_LIMIT = 20_000;
-/**
- * Directory descriptors one walk may hold at once. The visit budget is far
- * above a process file-descriptor limit, so a deep chain is refused before
- * the next open instead of failing later with EMFILE.
- */
-const DART_PUBSPEC_OPEN_DIRECTORY_LIMIT = 64;
-/**
- * Names read from one directory. `readdir` would retain every entry before the
- * visit budget can run, so the walk counts names as it reads and stops there.
- */
-const DART_PUBSPEC_DIRECTORY_ENTRY_LIMIT = 100_000;
-/**
- * Read at most `maxManifestSize` bytes from a descriptor already opened
- * with `O_NOFOLLOW`. A size check after the read rejects a file that grew
- * past the captured bytes, including past the cap. The caller closes nothing;
- * this function owns `handle`.
- */
-async function readManifestBounded(handle, maxManifestSize) {
+const DART_PUBSPEC_MANIFEST_LIMIT = 20_000;
+function warn(reason, relativePath) {
+    logger.warn({ reason, relativePath }, 'Dart pubspec discovery could not read a valid package declaration.');
+}
+function incomplete(reason, relativePath = '.') {
+    warn(reason, relativePath);
+    throw new Error(`Dart pubspec discovery failed (${reason}): ${relativePath}`);
+}
+function manifestIdentity(info) {
+    return `${info.dev}:${info.ino}:${info.mode}:${info.size}:${info.mtimeNs}:${info.ctimeNs}`;
+}
+/** Open once, validate and read that descriptor. Null excludes a symbolic link. */
+async function readManifestBounded(absolute, maxManifestSize) {
+    let handle;
+    try {
+        handle = await open(absolute, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+    }
+    catch {
+        // O_NOFOLLOW rejects leaf symlinks on POSIX. Keep static links excluded,
+        // including dangling links, without retrying the pathname open.
+        if ((await lstat(absolute).catch(() => null))?.isSymbolicLink())
+            return null;
+        return { ok: false, reason: 'read-pubspec' };
+    }
     try {
-        const info = await handle.stat();
-        if (!info.isFile())
+        const before = await handle.stat({ bigint: true });
+        const current = await lstat(absolute, { bigint: true });
+        // Also exclude links before reading on platforms without O_NOFOLLOW.
+        if (current.isSymbolicLink())
+            return null;
+        if (!before.isFile() || manifestIdentity(before) !== manifestIdentity(current)) {
             return { ok: false, reason: 'read-pubspec' };
-        if (info.size > maxManifestSize)
+        }
+        if (before.size > BigInt(maxManifestSize))
             return { ok: false, reason: 'manifest-size' };
-        const toRead = Math.min(maxManifestSize + 1, info.size + 1);
+        const toRead = Math.min(maxManifestSize + 1, Number(before.size) + 1);
         const buffer = Buffer.allocUnsafe(toRead);
         let bytesRead = 0;
         while (bytesRead < toRead) {
@@ -41,13 +51,12 @@ async function readManifestBounded(handle, maxManifestSize) {
         }
         if (bytesRead > maxManifestSize)
             return { ok: false, reason: 'manifest-size' };
-        const after = await handle.stat();
-        if (!after.isFile())
-            return { ok: false, reason: 'read-pubspec' };
-        if (after.size > maxManifestSize)
+        const after = await handle.stat({ bigint: true });
+        if (after.size > BigInt(maxManifestSize))
             return { ok: false, reason: 'manifest-size' };
-        if (after.size !== bytesRead)
+        if (manifestIdentity(after) !== manifestIdentity(before) || after.size !== BigInt(bytesRead)) {
             return { ok: false, reason: 'read-pubspec' };
+        }
         return { ok: true, content: buffer.subarray(0, bytesRead).toString('utf8') };
     }
     catch {
@@ -57,371 +66,122 @@ async function readManifestBounded(handle, maxManifestSize) {
         await handle.close();
     }
 }
-function requireNoFollowFlag() {
-    const noFollow = constants.O_NOFOLLOW;
-    if (typeof noFollow !== 'number' || noFollow === 0) {
-        throw Object.assign(new Error('O_NOFOLLOW is unavailable'), { code: 'ENOTSUP' });
-    }
-    return noFollow;
-}
-/** Linux anchors child opens. macOS verifies them. Every other platform does neither. */
-export function pubspecWalkAnchored() {
-    const noFollow = constants.O_NOFOLLOW;
-    return ((process.platform === 'linux' || process.platform === 'darwin') &&
-        typeof noFollow === 'number' &&
-        noFollow !== 0);
-}
-export function directoryOpenFlags() {
-    let flags = constants.O_RDONLY | requireNoFollowFlag();
-    if (typeof constants.O_DIRECTORY === 'number')
-        flags |= constants.O_DIRECTORY;
-    return flags;
-}
-/**
- * Read-only, no-follow, and non-blocking. `O_NONBLOCK` does not change a
- * regular-file read. Without it, a FIFO blocks inside `open` until a writer
- * connects, so the later file-type check never runs.
- */
-function fileOpenFlags() {
-    const nonBlock = constants.O_NONBLOCK;
-    if (typeof nonBlock !== 'number' || nonBlock === 0) {
-        throw Object.assign(new Error('O_NONBLOCK is unavailable'), { code: 'ENOTSUP' });
-    }
-    return constants.O_RDONLY | requireNoFollowFlag() | nonBlock;
-}
-function directoryIdentity(stat) {
-    return `${stat.dev}:${stat.ino}:${stat.mode}`;
-}
-/**
- * Path that lists the directory inode already open on `fd`.
- * Only Linux has one: `/proc/self/fd/N`. macOS refuses `opendir` on
- * `/dev/fd/N` for a directory (ENOTDIR) and Node has no `fdopendir`, so the
- * walker lists the lexical path and verifies the pinned chain around it.
- * Every other platform returns null and is not walked.
- */
-export function descriptorDirectoryPath(fd) {
-    if (process.platform === 'linux')
-        return `/proc/self/fd/${fd}`;
-    return null;
-}
-/**
- * One entry of the directory inode open on `fd`.
- * Linux looks up `/proc/self/fd/N/<name>` in that inode. macOS `/dev/fd/N/<name>`
- * does not resolve a child, so this returns null and the walker verifies the
- * pinned parent chain instead. Every other platform returns null and is not walked.
- */
-export function descriptorEntryPath(fd, name) {
-    if (process.platform !== 'linux')
-        return null;
-    if (!isSingleDirectoryEntry(name))
-        return null;
-    return `/proc/self/fd/${fd}/${name}`;
-}
-function isSingleDirectoryEntry(name) {
-    return (name !== '' && name !== '.' && name !== '..' && !name.includes('/') && !name.includes('\0'));
-}
-async function openVerifiedDirectory(directory) {
-    const handle = await open(directory, directoryOpenFlags());
-    try {
-        const info = await handle.stat({ bigint: true });
-        if (!info.isDirectory()) {
-            throw Object.assign(new Error('not a directory'), { code: 'ENOTDIR' });
-        }
-        return { handle, identity: directoryIdentity(info) };
-    }
-    catch (error) {
-        await handle.close();
-        throw error;
-    }
-}
-/** Re-stat each pinned directory and its path. A replaced inode or a symlink fails the walk. */
-async function assertPinnedChain(frames) {
-    for (const frame of frames) {
-        const pinned = await frame.handle.stat({ bigint: true });
-        if (!pinned.isDirectory() || directoryIdentity(pinned) !== frame.identity) {
-            throw Object.assign(new Error('parent descriptor changed'), { code: 'ELOOP' });
-        }
-        let lexical;
-        try {
-            lexical = await lstat(frame.absolute, { bigint: true });
-        }
-        catch {
-            throw Object.assign(new Error('parent path changed'), { code: 'ELOOP' });
-        }
-        if (lexical.isSymbolicLink() ||
-            !lexical.isDirectory() ||
-            directoryIdentity(lexical) !== frame.identity) {
-            throw Object.assign(new Error('parent path changed'), { code: 'ELOOP' });
-        }
-    }
-}
-/**
- * macOS has no descriptor-relative child lookup. Re-check the pinned parents,
- * open the child with O_NOFOLLOW, then re-check the parents. The opened
- * descriptor is the only child metadata consulted.
- */
-async function openLexicalDirectory(frames, lexicalPath) {
-    await assertPinnedChain(frames);
-    const opened = await openVerifiedDirectory(lexicalPath);
+/** Package identity is a pure function of captured manifest text. */
+function packageName(content, manifestPath) {
     try {
-        await assertPinnedChain(frames);
-        return opened;
+        const manifest = load(content, { schema: JSON_SCHEMA });
+        if (manifest === null || typeof manifest !== 'object' || Array.isArray(manifest))
+            return null;
+        const name = manifest.name;
+        return typeof name === 'string' && /^[a-z_][a-z0-9_]*$/.test(name) ? name : null;
     }
-    catch (error) {
-        await opened.handle.close();
-        throw error;
-    }
-}
-async function openLexicalFile(frames, lexicalPath) {
-    await assertPinnedChain(frames);
-    const handle = await open(lexicalPath, fileOpenFlags());
-    try {
-        const opened = await handle.stat({ bigint: true });
-        if (!opened.isFile()) {
-            throw Object.assign(new Error('not a file'), { code: 'ELOOP' });
-        }
-        await assertPinnedChain(frames);
-        return handle;
-    }
-    catch (error) {
-        await handle.close();
-        throw error;
+    catch {
+        warn('invalid-yaml', manifestPath);
+        return null;
     }
 }
-async function openChildDirectory(frames, parentFd, name, lexicalPath) {
-    const anchored = descriptorEntryPath(parentFd, name);
-    if (anchored !== null)
-        return openVerifiedDirectory(anchored);
-    if (process.platform === 'darwin')
-        return openLexicalDirectory(frames, lexicalPath);
-    throw Object.assign(new Error('no descriptor anchor'), { code: 'ENOTSUP' });
-}
-async function openChildFile(frames, parentFd, name, lexicalPath) {
-    const anchored = descriptorEntryPath(parentFd, name);
-    if (anchored !== null)
-        return open(anchored, fileOpenFlags());
-    if (process.platform === 'darwin')
-        return openLexicalFile(frames, lexicalPath);
-    throw Object.assign(new Error('no descriptor anchor'), { code: 'ENOTSUP' });
-}
 /**
- * List the directory open on the last frame of `frames`. Linux lists the
- * pinned inode through its descriptor. macOS re-checks the pinned chain, lists
- * the lexical path, then re-checks the chain, so a path replaced around the
- * listing fails the walk instead of being listed.
+ * Capture declarations from the shared scan, before source stat/size filtering.
+ * No directory enumeration occurs here. Every enumerated regular manifest must
+ * be captured successfully before this config can be published.
+ *
+ * Acquisition assumes a stable, trusted workspace, like the source-file reader.
+ * Static symlinks/junctions are excluded and observed file changes are rejected;
+ * these checks do not provide a sandbox or an atomic view of a mutating tree.
+ * Once returned, resolution uses only this compact map, on every operating system.
  */
-async function listOpenedDirectory(frames, entryLimit, beforeList) {
-    const frame = frames[frames.length - 1];
-    if (frame === undefined) {
-        throw Object.assign(new Error('no directory to list'), { code: 'EINVAL' });
-    }
-    const anchored = descriptorDirectoryPath(frame.handle.fd);
-    if (anchored === null && process.platform !== 'darwin') {
-        throw Object.assign(new Error('no descriptor listing'), { code: 'ENOTSUP' });
-    }
-    if (anchored === null)
-        await assertPinnedChain(frames);
-    if (beforeList)
-        await beforeList();
-    const entries = await readDirectoryBounded(anchored ?? frame.absolute, entryLimit);
-    if (anchored === null)
-        await assertPinnedChain(frames);
-    return entries;
-}
-async function readDirectoryBounded(listing, entryLimit) {
-    const dir = await opendir(listing);
-    const entries = [];
-    try {
-        let count = 0;
-        while (true) {
-            const entry = await dir.read();
-            if (entry === null)
-                break;
-            count += 1;
-            if (count > entryLimit) {
-                throw Object.assign(new Error('directory entry limit'), { code: 'E2BIG' });
-            }
-            entries.push(entry);
+export async function captureDartPackageConfig(repoPath, filePaths, options) {
+    const manifests = new Set();
+    const limit = options?.manifestLimit ?? DART_PUBSPEC_MANIFEST_LIMIT;
+    for (const filePath of filePaths) {
+        if (filePath !== 'pubspec.yaml' && !filePath.endsWith('/pubspec.yaml'))
+            continue;
+        if (/[\\\0]/.test(filePath) ||
+            /^[a-zA-Z]:/.test(filePath) ||
+            filePath.split('/').some((part) => part === '' || part === '.' || part === '..')) {
+            return incomplete('manifest-path');
         }
+        manifests.add(filePath);
+        if (manifests.size > limit)
+            return incomplete('manifest-limit');
     }
-    finally {
-        await dir.close().catch(() => undefined);
-    }
-    return entries;
-}
-/**
- * Open `directory` without following a final symlink, then list that inode.
- * A path swapped for a symlink after the parent listing fails this open
- * (`ENOTDIR` / `ELOOP`) instead of being traversed.
- */
-export async function readDirectoryNoFollow(directory) {
-    const opened = await openVerifiedDirectory(directory);
-    const frame = {
-        relative: '',
-        absolute: directory,
-        handle: opened.handle,
-        identity: opened.identity,
-        entries: [],
-        next: 0,
-    };
-    try {
-        return await listOpenedDirectory([frame], DART_PUBSPEC_DIRECTORY_ENTRY_LIMIT);
-    }
-    finally {
-        await opened.handle.close();
-    }
-}
-/** Discover only in-repository packages; never follow dependency paths or symlinks. */
-export async function loadDartPackageConfig(repoPath, options) {
-    const warn = (reason, relativePath = '.') => {
-        logger.warn({ reason, relativePath }, 'Dart pubspec discovery could not read a valid package declaration.');
-    };
-    const incomplete = (reason, relativePath = '.') => {
-        warn(reason, relativePath);
-        throw new Error(`Dart pubspec discovery failed (${reason}): ${relativePath}`);
-    };
-    if (!pubspecWalkAnchored()) {
-        warn('nofollow-anchor');
-        return { packages: new Map(), manifestsByName: new Map() };
-    }
-    let isIgnored;
     try {
-        isIgnored = await createWatchIgnorePredicate(repoPath);
+        await loadIgnoreRules(repoPath, { strictRepoControlFiles: true, noGlobalIgnore: true });
     }
     catch {
-        return incomplete('ignore-rules');
+        return incomplete('scan-inputs');
     }
     const packages = new Map();
     const manifestsByName = new Map();
+    if (manifests.size === 0)
+        return { packages, manifestsByName };
+    // Cache static parent checks once per directory, not once per import/file.
+    // This cache belongs only to this capture and never survives another analysis.
+    const directories = new Map();
+    const root = await lstat(repoPath).catch(() => null);
+    if (root === null || !root.isDirectory() || root.isSymbolicLink()) {
+        return incomplete('read-directory');
+    }
     const maxManifestSize = Math.min(1024 * 1024, getMaxFileSizeBytes());
-    const directoryLimit = options?.directoryLimit ?? DART_PUBSPEC_DIRECTORY_LIMIT;
-    const directoryDepthLimit = options?.directoryDepthLimit ?? DART_PUBSPEC_OPEN_DIRECTORY_LIMIT;
-    const directoryEntryLimit = options?.directoryEntryLimit ?? DART_PUBSPEC_DIRECTORY_ENTRY_LIMIT;
-    const ambiguous = new Set();
-    const stack = [];
-    let visited = 0;
-    const closeStack = async () => {
-        const frames = stack.splice(0);
-        await Promise.all(frames.map((frame) => frame.handle.close().catch(() => undefined)));
-    };
-    const fillFrame = async (frame) => {
-        if (++visited > directoryLimit)
-            return incomplete('directory-limit', frame.relative || '.');
-        try {
-            const beforeList = options?.beforeDirectoryList;
-            frame.entries = await listOpenedDirectory(stack, directoryEntryLimit, beforeList ? () => beforeList(frame.relative) : undefined);
-        }
-        catch (error) {
-            const reason = error.code === 'E2BIG' ? 'directory-entries' : 'read-directory';
-            return incomplete(reason, frame.relative || '.');
-        }
-        if (options?.beforeEntryOpen)
-            await options.beforeEntryOpen(frame.relative);
-    };
-    try {
-        let rootOpened;
-        try {
-            rootOpened = await openVerifiedDirectory(repoPath);
-        }
-        catch {
-            return incomplete('read-directory', '.');
-        }
-        const root = {
-            relative: '',
-            absolute: repoPath,
-            handle: rootOpened.handle,
-            identity: rootOpened.identity,
-            entries: [],
-            next: 0,
-        };
-        stack.push(root);
-        await fillFrame(root);
-        while (stack.length > 0) {
-            const frame = stack[stack.length - 1];
-            if (frame === undefined)
-                break;
-            if (frame.next >= frame.entries.length) {
-                stack.pop();
-                await frame.handle.close().catch(() => undefined);
-                continue;
-            }
-            const entry = frame.entries[frame.next];
-            frame.next += 1;
-            if (entry === undefined || !isSingleDirectoryEntry(entry.name) || entry.isSymbolicLink()) {
-                continue;
-            }
-            const childRelative = frame.relative ? `${frame.relative}/${entry.name}` : entry.name;
-            const entryPath = path.join(repoPath, childRelative);
-            if (entry.isDirectory()) {
-                if (entry.name.startsWith('.') || isIgnored(entryPath, true))
-                    continue;
-                if (stack.length >= directoryDepthLimit) {
-                    return incomplete('directory-depth', childRelative);
+    for (const manifestPath of manifests) {
+        const parts = manifestPath.split('/');
+        let parent = '';
+        let linked = false;
+        for (const part of parts.slice(0, -1)) {
+            parent = parent ? `${parent}/${part}` : part;
+            let accepted = directories.get(parent);
+            if (accepted === undefined) {
+                const info = await lstat(path.join(repoPath, parent)).catch(() => null);
+                if (info === null || (!info.isDirectory() && !info.isSymbolicLink())) {
+                    return incomplete('read-directory', parent);
                 }
-                let childOpened;
-                try {
-                    childOpened = await openChildDirectory(stack, frame.handle.fd, entry.name, entryPath);
-                }
-                catch {
-                    return incomplete('read-directory', childRelative);
-                }
-                const child = {
-                    relative: childRelative,
-                    absolute: entryPath,
-                    handle: childOpened.handle,
-                    identity: childOpened.identity,
-                    entries: [],
-                    next: 0,
-                };
-                stack.push(child);
-                await fillFrame(child);
+                accepted = !info.isSymbolicLink();
+                directories.set(parent, accepted);
             }
-            else if (entry.isFile() && entry.name === 'pubspec.yaml' && !isIgnored(entryPath, false)) {
-                const manifestPath = frame.relative ? `${frame.relative}/pubspec.yaml` : 'pubspec.yaml';
-                let manifestHandle;
-                try {
-                    manifestHandle = await openChildFile(stack, frame.handle.fd, entry.name, entryPath);
-                }
-                catch {
-                    return incomplete('read-pubspec', manifestPath);
-                }
-                const read = await readManifestBounded(manifestHandle, maxManifestSize);
-                if (read.ok === false)
-                    return incomplete(read.reason, manifestPath);
-                try {
-                    const manifest = load(read.content, {
-                        schema: JSON_SCHEMA,
-                    });
-                    if (manifest === null || typeof manifest !== 'object' || Array.isArray(manifest))
-                        continue;
-                    const name = manifest.name;
-                    if (typeof name !== 'string' || !/^[a-z_][a-z0-9_]*$/.test(name))
-                        continue;
-                    const manifests = manifestsByName.get(name) ?? [];
-                    manifests.push(manifestPath);
-                    // Two deterministic witnesses suffice to prove ambiguity. Retaining
-                    // more would create unbounded duplicate-package dependency fanout.
-                    manifests.sort();
-                    if (manifests.length > 2)
-                        manifests.length = 2;
-                    manifestsByName.set(name, manifests);
-                    if (packages.has(name) || ambiguous.has(name)) {
-                        packages.delete(name);
-                        ambiguous.add(name);
-                    }
-                    else {
-                        packages.set(name, frame.relative ? `${frame.relative}/lib` : 'lib');
-                    }
-                }
-                catch {
-                    // Invalid YAML cannot declare a package. Other valid packages remain usable.
-                    warn('invalid-yaml', manifestPath);
-                }
+            if (!accepted) {
+                linked = true;
+                break;
             }
         }
-    }
-    finally {
-        await closeStack();
+        if (linked)
+            continue;
+        const read = await readManifestBounded(path.join(repoPath, manifestPath), maxManifestSize);
+        if (read === null)
+            continue;
+        if (read.ok === false)
+            return incomplete(read.reason, manifestPath);
+        const name = packageName(read.content, manifestPath);
+        if (name === null)
+            continue;
+        const witnesses = manifestsByName.get(name) ?? [];
+        witnesses.push(manifestPath);
+        witnesses.sort();
+        // Two deterministic witnesses prove ambiguity without duplicate fanout.
+        if (witnesses.length > 2)
+            witnesses.length = 2;
+        manifestsByName.set(name, witnesses);
+        if (witnesses.length > 1)
+            packages.delete(name);
+        else
+            packages.set(name, parent ? `${parent}/lib` : 'lib');
     }
     return { packages, manifestsByName };
 }
+/** Standalone callers use the same scanner/capture boundary as the pipeline. */
+export async function loadDartPackageConfig(repoPath, options) {
+    let captured;
+    try {
+        await walkRepositoryPaths(repoPath, undefined, {
+            onPathsDiscovered: async (paths) => {
+                captured = await captureDartPackageConfig(repoPath, paths, options);
+            },
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('Dart pubspec discovery failed')) {
+            throw error;
+        }
+        return incomplete('scan-inputs');
+    }
+    return captured ?? incomplete('scan-inputs');
+}

package/dist/core/ingestion/languages/dart/scope-resolver.js

@@ -36,7 +36,7 @@ import { decodeMarker } from '../../utils/heritage-marker.js';
 import { typeApplicationArguments } from '../../utils/template-arguments.js';
 import { expandDartWildcardNames } from './expand-wildcards.js';
 import { dartIsGlobalNameFallbackPlausible } from './name-fallback-visibility.js';
-import { loadDartPackageConfig } from './package-config.js';
+import { captureDartPackageConfig, loadDartPackageConfig } from './package-config.js';
 import { emitDartPackageDependencies } from './package-dependencies.js';
 /**
  * Resolve a class simple name to a graph id with FILE AFFINITY: prefer a
@@ -182,6 +182,7 @@ export const dartScopeResolver = {
     languageProvider: dartProvider,
     importEdgeReason: 'dart-scope: import',
     loadResolutionConfig: loadDartPackageConfig,
+    captureResolutionConfig: captureDartPackageConfig,
     // Package dependencies use cached ParsedFile facts, never raw source text.
     postExtractSourceTextPolicy: 'uncached-files',
     emitPostResolutionEdges: (graph, parsedFiles, _nodeLookup, _indexes, ctx) => emitDartPackageDependencies(graph, parsedFiles, ctx.resolutionConfig),

package/dist/core/ingestion/pipeline-phases/parse-impl.d.ts

@@ -62,7 +62,7 @@ export declare function extractCrossFileRoutes(allPaths: string[], repoPath: str
  * Import, call, and inheritance edges are emitted by the scope-resolution
  * phase, not here (RING4-1 #942 / RING4-2 #943 removed the legacy passes).
  */
-export declare function runChunkedParseAndResolve(graph: KnowledgeGraph, scannedFiles: ScannedFile[], allPaths: string[], totalFiles: number, repoPath: string, pipelineStart: number, onProgress: ProgressFn, options?: PipelineOptions): Promise<{
+export declare function runChunkedParseAndResolve(graph: KnowledgeGraph, scannedFiles: ScannedFile[], allPaths: string[], totalFiles: number, repoPath: string, pipelineStart: number, onProgress: ProgressFn, options?: PipelineOptions, capturedResolutionConfigs?: ReadonlyMap<SupportedLanguages, unknown>): Promise<{
     exportedTypeMap: ExportedTypeMap;
     allFetchCalls: ExtractedFetchCall[];
     allFetchWrapperDefs: FetchWrapperDef[];

package/dist/core/ingestion/pipeline-phases/parse-impl.js

@@ -328,7 +328,7 @@ export function handleWorkerStartupFailure(err) {
  * Import, call, and inheritance edges are emitted by the scope-resolution
  * phase, not here (RING4-1 #942 / RING4-2 #943 removed the legacy passes).
  */
-export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, totalFiles, repoPath, pipelineStart, onProgress, options) {
+export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, totalFiles, repoPath, pipelineStart, onProgress, options, capturedResolutionConfigs) {
     const model = createSemanticModel();
     const symbolTable = model.symbols;
     const contentClassifiedPaths = scannedFiles
@@ -1487,9 +1487,11 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
         if (language === null || routeResolutionConfigs.has(language))
             continue;
         const resolver = SCOPE_RESOLVERS.get(language);
-        routeResolutionConfigs.set(language, resolver?.loadResolutionConfig === undefined
-            ? undefined
-            : await resolver.loadResolutionConfig(repoPath));
+        routeResolutionConfigs.set(language, capturedResolutionConfigs?.has(language)
+            ? capturedResolutionConfigs.get(language)
+            : resolver?.loadResolutionConfig === undefined
+                ? undefined
+                : await resolver.loadResolutionConfig(repoPath));
     }
     let routeResolutionFiles = allParsedFiles;
     const resolveRouteImportTargets = (parsedImport, fromFile) => {

package/dist/core/ingestion/pipeline-phases/parse.js

@@ -26,8 +26,8 @@ export const parsePhase = {
         // `mapCobolToGraph` scans CALLS edges and removes the unresolved ones — and
         // nothing before parse produces bulk edge volume anyway.
         ctx.graphEmit?.beginStreaming();
-        const { scannedFiles, allPaths, allPathSet, totalFiles } = getPhaseOutput(deps, 'structure');
-        const result = await runChunkedParseAndResolve(ctx.graph, scannedFiles, allPaths, totalFiles, ctx.repoPath, ctx.pipelineStart, ctx.onProgress, ctx.options);
+        const { scannedFiles, allPaths, allPathSet, totalFiles, resolutionConfigs } = getPhaseOutput(deps, 'structure');
+        const result = await runChunkedParseAndResolve(ctx.graph, scannedFiles, allPaths, totalFiles, ctx.repoPath, ctx.pipelineStart, ctx.onProgress, ctx.options, resolutionConfigs);
         return {
             ...result,
             allPaths,

package/dist/core/ingestion/pipeline-phases/scan.d.ts

@@ -2,7 +2,7 @@
  * Phase: scan
  *
  * Walks the repository filesystem and collects file paths + sizes.
- * Does NOT read file contents — that happens in downstream phases.
+ * Captures required provider metadata; source contents are read downstream.
  *
  * @deps    (none — this is the pipeline root)
  * @reads   repoPath (filesystem)
@@ -10,6 +10,7 @@
  * @output  ScannedFile[], allPaths[], totalFiles
  */
 import type { PipelinePhase } from './types.js';
+import { type SupportedLanguages } from '../../../_shared/index.js';
 export interface ScanOutput {
     scannedFiles: {
         path: string;
@@ -17,5 +18,6 @@ export interface ScanOutput {
     }[];
     allPaths: string[];
     totalFiles: number;
+    resolutionConfigs?: ReadonlyMap<SupportedLanguages, unknown>;
 }
 export declare const scanPhase: PipelinePhase<ScanOutput>;

package/dist/core/ingestion/pipeline-phases/scan.js

@@ -2,7 +2,7 @@
  * Phase: scan
  *
  * Walks the repository filesystem and collects file paths + sizes.
- * Does NOT read file contents — that happens in downstream phases.
+ * Captures required provider metadata; source contents are read downstream.
  *
  * @deps    (none — this is the pipeline root)
  * @reads   repoPath (filesystem)
@@ -12,6 +12,8 @@
 import { walkRepositoryPaths } from '../filesystem-walker.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { getLanguageFromFilename } from '../../../_shared/index.js';
+import { SCOPE_RESOLVERS } from '../scope-resolution/pipeline/registry.js';
 const SPRING_ACTUATOR_ENDPOINT_FILES = new Set([
     'mappings.json',
     'beans.json',
@@ -97,6 +99,7 @@ export const scanPhase = {
             ...(ctx.options?.springActuatorScanExclusions ?? []),
         ]);
         let scannedFiles;
+        const resolutionConfigs = new Map();
         try {
             scannedFiles = await walkRepositoryPaths(ctx.repoPath, (current, total, filePath) => {
                 const scanProgress = Math.round((current / total) * 15);
@@ -112,6 +115,16 @@ export const scanPhase = {
                         nodesCreated: ctx.graph.nodeCount,
                     },
                 });
+            }, {
+                onPathsDiscovered: async (paths) => {
+                    const inputs = paths.filter((filePath) => !matchesActuatorExclusion(canonicalRepoPath, filePath, actuatorExclusions));
+                    const languages = new Set(inputs.map(getLanguageFromFilename));
+                    for (const [language, provider] of SCOPE_RESOLVERS) {
+                        if (languages.has(language) && provider.captureResolutionConfig !== undefined) {
+                            resolutionConfigs.set(language, await provider.captureResolutionConfig(ctx.repoPath, inputs));
+                        }
+                    }
+                },
             });
         }
         catch (err) {
@@ -134,6 +147,6 @@ export const scanPhase = {
             message: 'Repository scanned successfully',
             stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: ctx.graph.nodeCount },
         });
-        return { scannedFiles, allPaths, totalFiles };
+        return { scannedFiles, allPaths, totalFiles, resolutionConfigs };
     },
 };

package/dist/core/ingestion/pipeline-phases/structure.d.ts

@@ -8,6 +8,7 @@
  * @writes  graph (File, Folder nodes + CONTAINS edges)
  */
 import type { PipelinePhase } from './types.js';
+import type { SupportedLanguages } from '../../../_shared/index.js';
 /** Structure phase produces no additional data — it writes directly to the graph. */
 export interface StructureOutput {
     /** Pass-through from scan for downstream phases. */
@@ -23,5 +24,6 @@ export interface StructureOutput {
      */
     allPathSet: ReadonlySet<string>;
     totalFiles: number;
+    resolutionConfigs?: ReadonlyMap<SupportedLanguages, unknown>;
 }
 export declare const structurePhase: PipelinePhase<StructureOutput>;

package/dist/core/ingestion/pipeline-phases/structure.js

@@ -13,7 +13,7 @@ export const structurePhase = {
     name: 'structure',
     deps: ['scan'],
     async execute(ctx, deps) {
-        const { scannedFiles, allPaths, totalFiles } = getPhaseOutput(deps, 'scan');
+        const { scannedFiles, allPaths, totalFiles, resolutionConfigs } = getPhaseOutput(deps, 'scan');
         ctx.onProgress({
             phase: 'structure',
             percent: 15,
@@ -30,6 +30,6 @@ export const structurePhase = {
         // Build the set once here so cobol, markdown, and cross-file propagation
         // can all reuse it instead of re-materializing `new Set(allPaths)` each.
         const allPathSet = new Set(allPaths);
-        return { scannedFiles, allPaths, allPathSet, totalFiles };
+        return { scannedFiles, allPaths, allPathSet, totalFiles, resolutionConfigs };
     },
 };

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -425,6 +425,15 @@ export interface ScopeResolver {
      * `resolveImportTarget` casts it to the language's expected shape.
      */
     loadResolutionConfig?(repoPath: string): Promise<unknown> | unknown;
+    /**
+     * Capture metadata from the scan's complete, nonignored candidate paths,
+     * before unreadable/large source files are filtered out. Called once for a
+     * language present in the scan. The compact result is shared by every
+     * resolution pass instead of calling loadResolutionConfig again.
+     * Capture failures must throw; consumers must not mutate the result.
+     * This is a stable-workspace input boundary, not an atomic filesystem snapshot.
+     */
+    captureResolutionConfig?(repoPath: string, filePaths: readonly string[]): Promise<unknown> | unknown;
     /**
      * Per-scope binding-merge precedence. The shared finalize pass
      * collects bindings from multiple sources (local declarations,

package/dist/core/ingestion/scope-resolution/pipeline/phase.js

@@ -79,7 +79,7 @@ export const scopeResolutionPhase = {
     deps: ['parse', 'crossFile', 'structure'],
     async execute(ctx, deps) {
         logHeapProbe('scopeResolution-enter');
-        const { scannedFiles } = getPhaseOutput(deps, 'structure');
+        const { scannedFiles, resolutionConfigs } = getPhaseOutput(deps, 'structure');
         const parseOutput = getPhaseOutput(deps, 'parse');
         const { model, parsedFiles: workerParsedFiles, contentLanguageByPath } = parseOutput;
         const scopeExtractionFailures = new Set(parseOutput.scopeExtractionFailures);
@@ -257,9 +257,11 @@ export const scopeResolutionPhase = {
                 // composer.json autoload, go.mod, ...). One I/O round trip per
                 // workspace pass — cached implicitly by the result handed to
                 // every `resolveImportTarget` call below.
-                const resolutionConfig = provider.loadResolutionConfig !== undefined
-                    ? await provider.loadResolutionConfig(ctx.repoPath)
-                    : undefined;
+                const resolutionConfig = resolutionConfigs?.has(lang)
+                    ? resolutionConfigs.get(lang)
+                    : provider.loadResolutionConfig !== undefined
+                        ? await provider.loadResolutionConfig(ctx.repoPath)
+                        : undefined;
                 // Some languages (e.g. Vue) expand their file universe beyond the
                 // primary-language files via the `collectScopeContextPaths` hook.
                 // The hook receives raw source contents of the primary files so it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.13-rc.83",
+  "version": "1.6.13-rc.85",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",
@@ -128,11 +128,11 @@
     "@types/express": "^5.0.6",
     "@types/node": "^26.0.0",
     "@types/proxy-addr": "^2.0.3",
-    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/coverage-v8": "^5.0.0",
     "gitnexus-shared": "file:../gitnexus-shared",
     "tsx": "^4.0.0",
     "typescript": "^7.0.2",
-    "vitest": "^4.0.18"
+    "vitest": "^5.0.0"
   },
   "overrides": {
     "adm-zip": ">=0.6.0",

package/scripts/cross-platform-tests.ts

@@ -311,7 +311,10 @@ const FILESYSTEM = [
   // The deletion-guard cases in this file require real Windows path semantics.
   'test/unit/canonicalize-path-long-path-prefix.test.ts',
   'test/unit/storage-resolver.test.ts',
+  // Dart package metadata is captured during the shared scan on every platform.
   'test/unit/dart-package-imports.test.ts',
+  // Verify the same capture is reused by native parsing and scope resolution.
+  'test/integration/resolvers/dart.test.ts',
   // Cargo membership uses path normalization, descriptor validation, symlinks,
   // and Rust native parsing (including long Windows source strings).
   'test/unit/scope-resolution/rust-cargo-targets.test.ts',

package/scripts/execution-reporter.ts

@@ -1,10 +1,9 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
 import { JsonReporter, type TestRunEndReason } from 'vitest/node';
 
 /** Vitest's stock JSON omits unhandled errors, even when success is true. */
 export default class ExecutionReporter extends JsonReporter {
-  private executionErrors = 0;
-  private executionReason: TestRunEndReason = 'interrupted';
-
   constructor() {
     super({});
   }
@@ -14,20 +13,26 @@ export default class ExecutionReporter extends JsonReporter {
     errors: readonly unknown[] = [],
     reason: TestRunEndReason = 'interrupted',
   ): Promise<void> {
-    this.executionErrors = errors.length;
-    this.executionReason = reason;
+    const configuredOutput = this.ctx.config.outputFile;
+    const outputFile = resolve(
+      this.ctx.config.root,
+      (typeof configuredOutput === 'string' ? configuredOutput : configuredOutput?.json) ??
+        '.vitest/json/output.json',
+    );
+    // Vitest 5 writes JSON directly instead of calling writeReport. Use an
+    // explicit path so this reporter also works for the web suite on Vitest 4.
+    this.options.outputFile = outputFile;
     await super.onTestRunEnd(modules);
-  }
-
-  override async writeReport(json: string): Promise<void> {
-    const report = JSON.parse(json);
-    await super.writeReport(
+    const report = JSON.parse(await readFile(outputFile, 'utf8'));
+    await writeFile(
+      outputFile,
       JSON.stringify({
         ...report,
-        success: report.success && this.executionErrors === 0 && this.executionReason === 'passed',
-        executionErrors: this.executionErrors,
-        executionReason: this.executionReason,
+        success: report.success && errors.length === 0 && reason === 'passed',
+        executionErrors: errors.length,
+        executionReason: reason,
       }),
+      'utf8',
     );
   }
 }