gitnexus 1.6.13-rc.37 → 1.6.13-rc.39

package/dist/core/ingestion/cfg/visitors/kotlin.d.ts

@@ -3,9 +3,10 @@
  *
  * Kotlin's tree-sitter grammar (vendored, NOT an npm package — loaded via
  * `requireVendoredGrammar('tree-sitter-kotlin')`, exactly like tree-sitter-swift)
- * is field-less for control flow: NONE of the control-flow nodes expose
- * `childForFieldName` fields (verified by a real parse — every `fieldNameForChild`
- * came back null), so this visitor navigates purely by child TYPE and position.
+ * is mostly field-less for control flow (`when` / loops / `try` / `elvis_expression`
+ * expose no fields), so this visitor navigates purely by child TYPE and position.
+ * `if_expression` is the exception: it DOES field `condition` / `consequence` /
+ * `alternative` (#3354 — callable-flow capture reads them); position still works.
  * Every node-type literal below was grammar-validated against the vendored
  * tree-sitter-kotlin via the introspection probe before use (mandatory pre-step —
  * the grammar-literal CI gate maps `kotlin.ts → Kotlin` and fails on a wrong

package/dist/core/ingestion/cfg/visitors/python-harvest.d.ts

@@ -46,8 +46,8 @@
  *  - reads: `attribute` (fields `object`/`attribute`), `subscript` (fields
  *    `value`/`subscript`), `call` (fields `function`/`arguments`),
  *    `boolean_operator` (fields `left`/`operator`/`right`),
- *    `conditional_expression` (ternary: consequent / condition / alternative in
- *    source order), `parenthesized_expression`.
+ *    `conditional_expression` (ternary, FIELDLESS: consequent, condition,
+ *    alternative as positional children), `parenthesized_expression`.
  *
  * TWO-PHASE, ORDER-INDEPENDENT (load-bearing — mirrors the TS / Go harvesters):
  * the CFG walk is NOT source-order, so resolving names against a scope stack

package/dist/core/ingestion/languages/dart/captures.js

@@ -109,6 +109,23 @@ const DART_CALLABLE_CAPTURE_OPTIONS = {
     extractCallCallee: (node) => dartCallableCallee(node) ?? undefined,
     callSiteNode: (node) => dartCallableCallee(node) ?? undefined,
     callableProtocolMethods: new Set(['call']),
+    // tree-sitter-dart spells `a ?? b` as `if_null_expression(first:, second:)`
+    // and `c ? a : b` as a `conditional_expression` with `consequence` /
+    // `alternative` but NO `condition` field, so neither matches the shared
+    // field-based branch rule and only the last operand flowed (#3354).
+    valueAlternatives: (node) => {
+        if (node.type === 'if_null_expression') {
+            const first = node.childForFieldName('first');
+            const second = node.childForFieldName('second');
+            return first !== null && second !== null ? [first, second] : undefined;
+        }
+        if (node.type === 'conditional_expression') {
+            const consequence = node.childForFieldName('consequence');
+            const alternative = node.childForFieldName('alternative');
+            return consequence !== null && alternative !== null ? [consequence, alternative] : undefined;
+        }
+        return undefined;
+    },
 };
 function dartLexicalFunctionOwner(input) {
     let node = input;

package/dist/core/ingestion/languages/dart/import-target.d.ts

@@ -1,15 +1,14 @@
 /**
  * `resolveImportTarget` adapter for the Dart `ScopeResolver`. Ports the
- * legacy-DAG Dart import logic (`import-resolvers/configs/dart.ts`):
+ * Dart import logic:
  *
  *   - `dart:` SDK imports          → `null` (external, no edge)
- *   - `package:pkg/path`           → `lib/path` (or bare `path`) matched
- *                                     against the workspace file set
+ *   - `package:pkg/path`           → declared package's exact `lib/path`
  *   - relative `'foo/bar.dart'`    → resolved against the importer's dir
  *   - `__heritage__:` markers      → `null` (synthetic heritage carrier,
  *                                     consumed by `emitDartHeritageEdges`)
  *
- * The `ScopeResolver` hook signature is `(targetRaw, fromFile, allFilePaths)`;
+ * Package identity comes from the workspace's pubspec resolution config;
  * `targetRaw` arrives already quote-stripped from `interpretDartImport`.
  */
-export declare function resolveDartImportTarget(targetRaw: string, fromFile: string, allFilePaths: ReadonlySet<string>): string | readonly string[] | null;
+export declare function resolveDartImportTarget(targetRaw: string, fromFile: string, allFilePaths: ReadonlySet<string>, resolutionConfig?: unknown): string | readonly string[] | null;

package/dist/core/ingestion/languages/dart/import-target.js

@@ -1,19 +1,19 @@
 /**
  * `resolveImportTarget` adapter for the Dart `ScopeResolver`. Ports the
- * legacy-DAG Dart import logic (`import-resolvers/configs/dart.ts`):
+ * Dart import logic:
  *
  *   - `dart:` SDK imports          → `null` (external, no edge)
- *   - `package:pkg/path`           → `lib/path` (or bare `path`) matched
- *                                     against the workspace file set
+ *   - `package:pkg/path`           → declared package's exact `lib/path`
  *   - relative `'foo/bar.dart'`    → resolved against the importer's dir
  *   - `__heritage__:` markers      → `null` (synthetic heritage carrier,
  *                                     consumed by `emitDartHeritageEdges`)
  *
- * The `ScopeResolver` hook signature is `(targetRaw, fromFile, allFilePaths)`;
+ * Package identity comes from the workspace's pubspec resolution config;
  * `targetRaw` arrives already quote-stripped from `interpretDartImport`.
  */
 import { perFileSet } from '../../import-resolvers/per-file-set.js';
 import { DART_HERITAGE_PREFIX } from './interpret.js';
+import { DART_PACKAGE_SCHEME, dartPackageImportName } from './package-uri.js';
 const getDartFileIndex = perFileSet((allFilePaths) => {
     const byBasename = new Map();
     for (const fp of allFilePaths) {
@@ -60,7 +60,7 @@ function resolveRelative(rel, fromFile, allFilePaths) {
     // Suffix fallback for absolute/rooted workspace paths.
     return findByPathSuffix(allFilePaths, target);
 }
-export function resolveDartImportTarget(targetRaw, fromFile, allFilePaths) {
+export function resolveDartImportTarget(targetRaw, fromFile, allFilePaths, resolutionConfig) {
     if (targetRaw.startsWith(DART_HERITAGE_PREFIX))
         return null;
     // `targetRaw` already arrives quote-stripped from `interpretDartImport`.
@@ -69,19 +69,21 @@ export function resolveDartImportTarget(targetRaw, fromFile, allFilePaths) {
     // Dart SDK imports never resolve to a repo file.
     if (targetRaw.startsWith('dart:'))
         return null;
-    // `package:pkg/path.dart` → `lib/path.dart` (or bare `path.dart`).
-    if (targetRaw.startsWith('package:')) {
-        const slash = targetRaw.indexOf('/');
-        if (slash === -1)
+    // A package URI never falls back to another package's same-named file.
+    if (targetRaw.startsWith(DART_PACKAGE_SCHEME)) {
+        const packageName = dartPackageImportName(targetRaw);
+        if (packageName === null)
             return null;
-        const relPath = targetRaw.slice(slash + 1);
-        // Candidate priority is load-bearing: `lib/<rel>` before bare `<rel>`.
-        for (const candidate of [`lib/${relPath}`, relPath]) {
-            const hit = findByPathSuffix(allFilePaths, candidate);
-            if (hit !== null)
-                return hit;
-        }
-        return null; // external package
+        const config = resolutionConfig;
+        const lib = config?.packages?.get(packageName);
+        if (lib === undefined)
+            return null;
+        const relPath = targetRaw.slice(DART_PACKAGE_SCHEME.length + packageName.length + 1);
+        if (/[\\%?#:]/.test(relPath) ||
+            relPath.split('/').some((part) => part === '' || part === '.' || part === '..'))
+            return null;
+        const candidate = `${lib}/${relPath}`;
+        return allFilePaths.has(candidate) ? candidate : null;
     }
     // Relative import.
     return resolveRelative(targetRaw, fromFile, allFilePaths);

package/dist/core/ingestion/languages/dart/index.d.ts

@@ -9,7 +9,10 @@
  *   - `query.ts`             — tree-sitter scope query + lazy parser/query
  *   - `captures.ts`          — `emitDartScopeCaptures` orchestrator
  *   - `interpret.ts`         — capture-match → `ParsedImport` / `ParsedTypeBinding`
- *   - `import-target.ts`     — `(targetRaw, fromFile, allFilePaths) → file path`
+ *   - `import-target.ts`     — exact declared-package / relative import targets
+ *   - `package-uri.ts`       — shared `package:name/...` parse
+ *   - `package-config.ts`    — bounded, ignore-aware in-repo pubspec discovery
+ *   - `package-dependencies.ts` — manifest dependencies for incremental writeback
  *   - `receiver-binding.ts`  — synthesize `this` / `super` type-bindings
  *   - `signature-bindings.ts`— synthesize parameter / return type-bindings
  *   - `arity.ts`             — Dart arity compatibility (count-primary)

package/dist/core/ingestion/languages/dart/index.js

@@ -9,7 +9,10 @@
  *   - `query.ts`             — tree-sitter scope query + lazy parser/query
  *   - `captures.ts`          — `emitDartScopeCaptures` orchestrator
  *   - `interpret.ts`         — capture-match → `ParsedImport` / `ParsedTypeBinding`
- *   - `import-target.ts`     — `(targetRaw, fromFile, allFilePaths) → file path`
+ *   - `import-target.ts`     — exact declared-package / relative import targets
+ *   - `package-uri.ts`       — shared `package:name/...` parse
+ *   - `package-config.ts`    — bounded, ignore-aware in-repo pubspec discovery
+ *   - `package-dependencies.ts` — manifest dependencies for incremental writeback
  *   - `receiver-binding.ts`  — synthesize `this` / `super` type-bindings
  *   - `signature-bindings.ts`— synthesize parameter / return type-bindings
  *   - `arity.ts`             — Dart arity compatibility (count-primary)

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

@@ -0,0 +1,42 @@
+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>;
+}
+/** 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`.
+ * Linux uses `/proc/self/fd/N` and macOS uses `/dev/fd/N`.
+ * Other platforms have no such path; callers refuse instead of listing by name.
+ */
+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 loadDartPackageConfig(repoPath: string, options?: DartPackageConfigOptions): Promise<DartPackageConfig>;

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

@@ -0,0 +1,398 @@
+import { constants, lstat, open, opendir } from 'node:fs/promises';
+import path from 'node:path';
+import { JSON_SCHEMA, load } from 'js-yaml';
+import { createWatchIgnorePredicate } from '../../../../config/ignore-service.js';
+import { logger } from '../../../logger.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) {
+    try {
+        const info = await handle.stat();
+        if (!info.isFile())
+            return { ok: false, reason: 'read-pubspec' };
+        if (info.size > maxManifestSize)
+            return { ok: false, reason: 'manifest-size' };
+        const toRead = Math.min(maxManifestSize + 1, info.size + 1);
+        const buffer = Buffer.allocUnsafe(toRead);
+        let bytesRead = 0;
+        while (bytesRead < toRead) {
+            const chunk = await handle.read(buffer, bytesRead, toRead - bytesRead, bytesRead);
+            if (chunk.bytesRead === 0)
+                break;
+            bytesRead += chunk.bytesRead;
+        }
+        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)
+            return { ok: false, reason: 'manifest-size' };
+        if (after.size !== bytesRead)
+            return { ok: false, reason: 'read-pubspec' };
+        return { ok: true, content: buffer.subarray(0, bytesRead).toString('utf8') };
+    }
+    catch {
+        return { ok: false, reason: 'read-pubspec' };
+    }
+    finally {
+        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`.
+ * Linux uses `/proc/self/fd/N` and macOS uses `/dev/fd/N`.
+ * Other platforms have no such path; callers refuse instead of listing by name.
+ */
+export function descriptorDirectoryPath(fd) {
+    if (process.platform === 'linux')
+        return `/proc/self/fd/${fd}`;
+    if (process.platform === 'darwin')
+        return `/dev/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);
+    try {
+        await assertPinnedChain(frames);
+        return opened;
+    }
+    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;
+    }
+}
+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' });
+}
+async function listOpenedDirectory(handle, entryLimit) {
+    const listing = descriptorDirectoryPath(handle.fd);
+    if (listing === null) {
+        throw Object.assign(new Error('no descriptor listing'), { code: 'ENOTSUP' });
+    }
+    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);
+        }
+    }
+    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);
+    try {
+        return await listOpenedDirectory(opened.handle, 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);
+    }
+    catch {
+        return incomplete('ignore-rules');
+    }
+    const packages = new Map();
+    const manifestsByName = new Map();
+    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 {
+            frame.entries = await listOpenedDirectory(frame.handle, directoryEntryLimit);
+        }
+        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);
+                }
+                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);
+            }
+            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);
+                }
+            }
+        }
+    }
+    finally {
+        await closeStack();
+    }
+    return { packages, manifestsByName };
+}

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

@@ -0,0 +1,6 @@
+import type { ParsedFile } from '../../../../_shared/index.js';
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import { DART_PACKAGE_IDENTITY_REASON } from '../../scope-resolution/graph-bridge/imports-to-edges.js';
+export { DART_PACKAGE_IDENTITY_REASON };
+/** Package identity is an input dependency, including unresolved/ambiguous imports. */
+export declare function emitDartPackageDependencies(graph: KnowledgeGraph, parsedFiles: readonly ParsedFile[], resolutionConfig?: unknown): void;