gitnexus 1.6.13-rc.38 → 1.6.13-rc.39

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;

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

@@ -0,0 +1,86 @@
+import { generateId } from '../../../../lib/utils.js';
+import { DART_PACKAGE_IDENTITY_REASON } from '../../scope-resolution/graph-bridge/imports-to-edges.js';
+import { dartPackageImportName } from './package-uri.js';
+export { DART_PACKAGE_IDENTITY_REASON };
+const MAX_DEPENDENCIES = 100_000;
+const MAX_TRAVERSALS = 1_000_000;
+/** Package identity is an input dependency, including unresolved/ambiguous imports. */
+export function emitDartPackageDependencies(graph, parsedFiles, resolutionConfig) {
+    const config = resolutionConfig;
+    if (!config?.manifestsByName)
+        return;
+    const consumersByManifest = new Map();
+    let dependencyCount = 0;
+    const addConsumer = (consumers, sourceId) => {
+        if (consumers.has(sourceId))
+            return;
+        if (++dependencyCount > MAX_DEPENDENCIES) {
+            throw new Error('Dart package dependency limit exceeded; narrow the workspace with .gitnexusignore.');
+        }
+        consumers.add(sourceId);
+    };
+    const fileIds = new Set(parsedFiles.map((parsed) => generateId('File', parsed.filePath)));
+    for (const parsed of parsedFiles) {
+        const sourceId = generateId('File', parsed.filePath);
+        if (!graph.getNode(sourceId))
+            continue;
+        for (const imp of parsed.parsedImports) {
+            const raw = imp.targetRaw;
+            if (typeof raw !== 'string')
+                continue;
+            const packageName = dartPackageImportName(raw);
+            if (packageName === null)
+                continue;
+            for (const manifest of config.manifestsByName.get(packageName) ?? []) {
+                let consumers = consumersByManifest.get(manifest);
+                if (!consumers)
+                    consumersByManifest.set(manifest, (consumers = new Set()));
+                addConsumer(consumers, sourceId);
+            }
+        }
+    }
+    if (consumersByManifest.size === 0)
+        return;
+    // New manifests are not present in the old DB's importer closure. Carry
+    // identity dependencies through the freshly resolved imports as well, so
+    // one-hop incremental boundary expansion rewrites downstream consumers.
+    const importers = new Map();
+    for (const edge of graph.iterRelationshipsByType('IMPORTS')) {
+        if (!fileIds.has(edge.sourceId) || !fileIds.has(edge.targetId))
+            continue;
+        let sources = importers.get(edge.targetId);
+        if (!sources)
+            importers.set(edge.targetId, (sources = new Set()));
+        sources.add(edge.sourceId);
+    }
+    let traversals = 0;
+    for (const [manifest, consumers] of consumersByManifest) {
+        const targetId = generateId('File', manifest);
+        if (!graph.getNode(targetId)) {
+            throw new Error(`Dart package manifest is missing from the indexed file set: ${manifest}`);
+        }
+        // Set iteration visits additions and deduplicates cycles without recursion.
+        for (const sourceId of consumers) {
+            for (const importer of importers.get(sourceId) ?? []) {
+                if (++traversals > MAX_TRAVERSALS) {
+                    throw new Error('Dart package dependency traversal limit exceeded; narrow the workspace with .gitnexusignore.');
+                }
+                addConsumer(consumers, importer);
+            }
+        }
+    }
+    // Validate the complete closure before publishing any dependency edges.
+    for (const [manifest, consumers] of consumersByManifest) {
+        const targetId = generateId('File', manifest);
+        for (const sourceId of consumers) {
+            graph.addRelationship({
+                id: generateId('IMPORTS', `${sourceId}->${targetId}`),
+                sourceId,
+                targetId,
+                type: 'IMPORTS',
+                confidence: 1,
+                reason: DART_PACKAGE_IDENTITY_REASON,
+            });
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+export declare const DART_PACKAGE_SCHEME = "package:";
+/**
+ * Name from `package:name/library.dart`.
+ * A bare `package:name` or `package:name/` has no library path, so it is not
+ * an import target and it does not create a package-identity dependency.
+ */
+export declare function dartPackageImportName(targetRaw: string): string | null;

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

@@ -0,0 +1,14 @@
+export const DART_PACKAGE_SCHEME = 'package:';
+/**
+ * Name from `package:name/library.dart`.
+ * A bare `package:name` or `package:name/` has no library path, so it is not
+ * an import target and it does not create a package-identity dependency.
+ */
+export function dartPackageImportName(targetRaw) {
+    if (!targetRaw.startsWith(DART_PACKAGE_SCHEME))
+        return null;
+    const slash = targetRaw.indexOf('/', DART_PACKAGE_SCHEME.length);
+    if (slash <= DART_PACKAGE_SCHEME.length || slash === targetRaw.length - 1)
+        return null;
+    return targetRaw.slice(DART_PACKAGE_SCHEME.length, slash);
+}

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

@@ -36,6 +36,8 @@ 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 { emitDartPackageDependencies } from './package-dependencies.js';
 /**
  * Resolve a class simple name to a graph id with FILE AFFINITY: prefer a
  * definition in `preferredFile`, then a workspace-unique match, otherwise
@@ -179,7 +181,11 @@ export const dartScopeResolver = {
     language: SupportedLanguages.Dart,
     languageProvider: dartProvider,
     importEdgeReason: 'dart-scope: import',
-    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => resolveDartImportTarget(targetRaw, fromFile, allFilePaths),
+    loadResolutionConfig: loadDartPackageConfig,
+    // Package dependencies use cached ParsedFile facts, never raw source text.
+    postExtractSourceTextPolicy: 'uncached-files',
+    emitPostResolutionEdges: (graph, parsedFiles, _nodeLookup, _indexes, ctx) => emitDartPackageDependencies(graph, parsedFiles, ctx.resolutionConfig),
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths, resolutionConfig) => resolveDartImportTarget(targetRaw, fromFile, allFilePaths, resolutionConfig),
     // Dart `import` is whole-library: every public top-level symbol of the
     // target enters scope. Enumerating them lets `propagateImportedReturnTypes`
     // mirror imported functions' return types into the importer.

package/dist/core/ingestion/scope-resolution/graph-bridge/imports-to-edges.d.ts

@@ -137,4 +137,10 @@ export declare const DEFERRED_IMPORT_REASON_SUFFIX = " (deferred)";
  * place the graph records which one this pair is.
  */
 export declare const TYPE_ONLY_IMPORT_REASON_SUFFIX = " (type-only)";
+/**
+ * Dart pubspec identity edges are incremental metadata, not initialization
+ * edges. Kept here so the cycle query can name the reason without importing
+ * a language provider into MCP startup.
+ */
+export declare const DART_PACKAGE_IDENTITY_REASON = "dart-scope: package identity dependency";
 export declare function emitImportEdges(graph: KnowledgeGraph, imports: ReadonlyMap<ScopeId, readonly ImportEdge[]>, scopeTree: ScopeResolutionIndexes['scopeTree'], reason?: string): number;

package/dist/core/ingestion/scope-resolution/graph-bridge/imports-to-edges.js

@@ -135,6 +135,12 @@ export const DEFERRED_IMPORT_REASON_SUFFIX = ' (deferred)';
  * place the graph records which one this pair is.
  */
 export const TYPE_ONLY_IMPORT_REASON_SUFFIX = ' (type-only)';
+/**
+ * Dart pubspec identity edges are incremental metadata, not initialization
+ * edges. Kept here so the cycle query can name the reason without importing
+ * a language provider into MCP startup.
+ */
+export const DART_PACKAGE_IDENTITY_REASON = 'dart-scope: package identity dependency';
 /**
  * How much of an import survives to run time. Lower is stronger; a pair takes
  * the minimum over every edge that reaches it. See the precedence section in

package/dist/mcp/local/local-backend.js

@@ -69,7 +69,7 @@ import { lookupExternalCallCount, lookupUnresolvedCallCount, } from '../../core/
 import { scopeExtractionFailureTotal } from '../../core/ingestion/scope-resolution/scope-extraction-failures.js';
 import { lookupCount } from '../../core/ingestion/scope-resolution/summary-maps.js';
 import { VALUE_REF_EDGE_REASON } from '../../core/ingestion/scope-resolution/value-ref-edges.js';
-import { DEFERRED_IMPORT_REASON_SUFFIX, TYPE_ONLY_IMPORT_REASON_SUFFIX, } from '../../core/ingestion/scope-resolution/graph-bridge/imports-to-edges.js';
+import { DART_PACKAGE_IDENTITY_REASON, DEFERRED_IMPORT_REASON_SUFFIX, TYPE_ONLY_IMPORT_REASON_SUFFIX, } from '../../core/ingestion/scope-resolution/graph-bridge/imports-to-edges.js';
 import { fnLineOf, isPdgDegradedLayerStatus, makePdgImpactErrorResult, makePdgLayerDegradedResult, pdgLayerStatus, pdgStampForMode, runImpactPDG, validateImpactMode, pdgBridgeEvidenceForImpact, betterBridgeEvidence, composeUnifiedPdgImpactResult, splitCalleeIds, } from './pdg-impact.js';
 /**
  * Candidate `type`s that label enrichment newly populates (#2687). Before that,
@@ -2230,20 +2230,25 @@ export class LocalBackend {
         // and the whole result is REPLACED by an error, so a truncated page never reaches a caller.
         const rows = await executeParameterized(repo.lbugPath, 
         // A cycle here means "these modules cannot be initialized in any order".
-        // Only edges that force initialization count, so four kinds are excluded:
+        // Only edges that force initialization count, so five kinds are excluded:
         // Swift implicit module visibility and markdown links (never code
-        // dependencies at all); imports reachable only through `import()` or a
+        // dependencies at all); Dart package-identity edges, which point at
+        // pubspec.yaml so a manifest edit invalidates importers and cannot
+        // form an init cycle; imports reachable only through `import()` or a
         // function body, which are deferred by construction — deferring is the
         // standard idiom for BREAKING an init cycle, so counting it reports the
         // fix as the bug; and imports reachable only through TypeScript
         // `import type`, which `tsc` erases outright, so no module load exists
         // to order. `imports-to-edges.ts` tags the last two with
         // DEFERRED_IMPORT_REASON_SUFFIX / TYPE_ONLY_IMPORT_REASON_SUFFIX.
+        // The Dart exclusion has to sit in this filter, before LIMIT, or the
+        // identity edges consume the 100000-row admission cap on a cycle-free graph.
         `MATCH (source:File)-[r:CodeRelation]->(target:File)
        WHERE r.type = 'IMPORTS'
          AND (r.reason IS NULL OR (
            r.reason <> 'swift-scope: implicit module visibility'
            AND r.reason <> 'markdown-link'
+           AND r.reason <> '${DART_PACKAGE_IDENTITY_REASON}'
            AND NOT r.reason ENDS WITH '${DEFERRED_IMPORT_REASON_SUFFIX}'
            AND NOT r.reason ENDS WITH '${TYPE_ONLY_IMPORT_REASON_SUFFIX}'
          ))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.13-rc.38",
+  "version": "1.6.13-rc.39",
   "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",