gitnexus 1.6.13-rc.40 → 1.6.13-rc.41

package/dist/core/graph/edge-reasons.d.ts

@@ -24,3 +24,15 @@
 export declare const GLOBAL_NAME_FALLBACK_REASON = "global-name-fallback";
 /** True when this edge's target was guessed by name rather than resolved. */
 export declare const isHeuristicEdgeReason: (reason: string) => boolean;
+/**
+ * An IMPORTS edge from a File to the `Module` node of the compiler module it
+ * belongs to, for languages where every file of a module sees every other
+ * file's declarations with no `import` (whole-module visibility).
+ *
+ * One edge per member file instead of one per ordered file pair: the pairwise
+ * form is n·(n−1) edges and exhausted V8's Map limit on large modules (#3355).
+ * Consumers that need "files that see this file" follow the hub: two files are
+ * co-members when both have a membership edge to the same `Module` node
+ * (`queryImportersBatch`).
+ */
+export declare const MODULE_MEMBERSHIP_REASON = "module-membership";

package/dist/core/graph/edge-reasons.js

@@ -32,3 +32,15 @@ export const GLOBAL_NAME_FALLBACK_REASON = 'global-name-fallback';
 const HEURISTIC_EDGE_REASONS = new Set([GLOBAL_NAME_FALLBACK_REASON]);
 /** True when this edge's target was guessed by name rather than resolved. */
 export const isHeuristicEdgeReason = (reason) => HEURISTIC_EDGE_REASONS.has(reason);
+/**
+ * An IMPORTS edge from a File to the `Module` node of the compiler module it
+ * belongs to, for languages where every file of a module sees every other
+ * file's declarations with no `import` (whole-module visibility).
+ *
+ * One edge per member file instead of one per ordered file pair: the pairwise
+ * form is n·(n−1) edges and exhausted V8's Map limit on large modules (#3355).
+ * Consumers that need "files that see this file" follow the hub: two files are
+ * co-members when both have a membership edge to the same `Module` node
+ * (`queryImportersBatch`).
+ */
+export const MODULE_MEMBERSHIP_REASON = 'module-membership';

package/dist/core/ingestion/import-resolvers/configs/swift.d.ts

@@ -22,9 +22,10 @@
  * `allFileList` entries, and the per-target file ORDER follows
  * `allFileList`.
  *
- * Import-config fans a file to every matching declared target. Grouping
- * (`groupSwiftFilesBySpmTarget`) is first-target-wins. That divergence
- * is intentional.
+ * Import-config fans a file to every matching declared target. Module
+ * grouping (`groupSwiftFilesByModule`) anchors target paths at the repo root
+ * and picks the deepest. That divergence is intentional: this legacy
+ * strategy only sees the root declaration map.
  */
 import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
 /** Swift Package.swift target map resolution strategy. */

package/dist/core/ingestion/import-resolvers/configs/swift.js

@@ -22,9 +22,10 @@
  * `allFileList` entries, and the per-target file ORDER follows
  * `allFileList`.
  *
- * Import-config fans a file to every matching declared target. Grouping
- * (`groupSwiftFilesBySpmTarget`) is first-target-wins. That divergence
- * is intentional.
+ * Import-config fans a file to every matching declared target. Module
+ * grouping (`groupSwiftFilesByModule`) anchors target paths at the repo root
+ * and picks the deepest. That divergence is intentional: this legacy
+ * strategy only sees the root declaration map.
  */
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { coerceDeclaredSwiftTargets, swiftDeclaredTargetPrefix } from '../../language-config.js';

package/dist/core/ingestion/language-config.d.ts

@@ -86,6 +86,43 @@ export interface SwiftPackageConfig {
      * binary-only Package.swift does not collapse every file into `__default__`.
      */
     declaredTargets?: Map<string, string>;
+    /**
+     * Every Swift module the workspace loader found (root and nested SwiftPM
+     * targets, Xcode native targets). When present it is the authority for
+     * module membership and `import` resolution; `targets` stays for callers
+     * that only know the SwiftPM map.
+     */
+    modules?: readonly SwiftModuleSpec[];
+    /**
+     * True when every manifest and Xcode project was read completely and no
+     * module was inferred from folder names, so a name missing from `modules`
+     * is an external module (SDK or dependency), not an unread local one.
+     */
+    moduleNamesComplete?: boolean;
+    /** `sources:` / `exclude:` per target name, relative to the target directory. */
+    targetFilters?: Map<string, SwiftTargetFilter>;
+}
+/** One Swift module (compiler unit) found in the workspace. */
+export interface SwiftModuleSpec {
+    /** Stable key: a repo-relative SwiftPM target directory, or `xcode:<project>:<target>`. */
+    readonly key: string;
+    /** Module name as written in `import X`. */
+    readonly name: string;
+    /** SwiftPM: repo-relative target directory ('' is the repo root). */
+    readonly dir?: string;
+    /** Xcode: repo-relative member files. */
+    readonly files?: readonly string[];
+    /** Xcode: repo-relative synchronized folders; files below are members. */
+    readonly folders?: readonly string[];
+    /**
+     * Repo-relative paths this module leaves out: Xcode synchronized-folder
+     * exceptions, SwiftPM `exclude:`.
+     */
+    readonly excluded?: readonly string[];
+    /** SwiftPM `sources:`: repo-relative files or directories; members must be under one. */
+    readonly sources?: readonly string[];
+    /** False for SwiftPM plugins: modules, but never `import`-able. */
+    readonly importable: boolean;
 }
 /**
  * Declaration view for explicit import resolve. `origin: 'directories'`
@@ -212,12 +249,36 @@ export declare function loadComposerConfig(repoRoot: string): Promise<ComposerCo
  * windows (see below); directories are still visited breadth-first.
  */
 export declare function scanCSharpProject(repoRoot: string): Promise<CSharpProjectScan>;
-/** Heuristic Package.swift scan. Never shells out to `swift package dump-package`. */
-export declare function parseSwiftPackageManifest(source: string): {
+/** Where SwiftPM looks for a target that declares no `path:`. */
+export type SwiftTargetDirKind = 'source' | 'test' | 'plugin';
+export interface SwiftManifestParse {
+    /** Target name -> package-relative directory. */
     targets: Map<string, string>;
+    /**
+     * Targets with no `path:`. Their directory above is the conventional
+     * default; `loadSwiftPackageConfig` replaces it with the directory SwiftPM
+     * would actually pick (`Sources`, `Source`, `src`, or `srcs`).
+     */
+    implicitDirs: Map<string, SwiftTargetDirKind>;
+    /** Plugin targets: modules for grouping, never `import`-able. */
+    plugins: Set<string>;
+    /** `sources:` / `exclude:` per target name, relative to the target directory. */
+    filters: Map<string, SwiftTargetFilter>;
     complete: boolean;
-};
-export declare function loadSwiftPackageConfig(repoRoot: string): Promise<SwiftPackageConfig | null>;
+}
+/** A target's `sources:` / `exclude:` lists; absent means "no filter". */
+export interface SwiftTargetFilter {
+    readonly sources?: readonly string[];
+    readonly exclude?: readonly string[];
+}
+/** Heuristic Package.swift scan. Never shells out to `swift package dump-package`. */
+export declare function parseSwiftPackageManifest(source: string): SwiftManifestParse;
+/**
+ * Load the SwiftPM config of the package at `packageDir` (repo root when
+ * omitted). Target directories stay package-relative; see
+ * {@link loadSwiftWorkspaceConfig} for the repo-relative merge.
+ */
+export declare function loadSwiftPackageConfig(repoRoot: string, packageDir?: string): Promise<SwiftPackageConfig | null>;
 /**
  * Load the Zig build configuration a repo's `build.zig.zon` + root `build.zig`
  * declare: `.path` deps (and the roots their own build.zig names) from the
@@ -298,6 +359,38 @@ export declare function zigPackageFor(index: ZigWorkspaceIndex | null | undefine
  * `loadTsconfigPaths` and the repo-walking `loadTsconfigIndex`.
  */
 export declare function loadZigWorkspaceIndex(repoRoot: string): Promise<ZigWorkspaceIndex | null>;
+/**
+ * Normalize a `.path` value from build.zig.zon into a repo-relative form.
+ * Returns null for paths that escape the repo root (start with `..`) or
+ * are absolute — those point to files we don't index. `.` / `./` normalize
+ * to the empty string (the repo root itself). Shared with the import
+ * resolver so both sides agree on which deps are in-repo.
+ */
+/**
+ * Does this `.path` value point outside the repository BY ITS SPELLING —
+ * POSIX absolute (`/dep`), Windows drive-qualified (`C:\dep`, `C:/dep`),
+ * root-relative (`\dep`) or UNC (`\\server\share`)?
+ *
+ * Separators are normalized first so every Windows spelling is visible to the
+ * one test. Exported-in-spirit rather than inlined because it must be asked in
+ * TWO places and the two must not drift: `normalizeZigDepPath` asks it of the
+ * value it is given, and `loadZigBuildConfig` asks it of a NESTED package's
+ * value BEFORE prefixing the package directory. That second call is the whole
+ * point — prefixing turns `/dep` into `packages/app//dep`, which is relative by
+ * inspection, so the check inside `normalizeZigDepPath` no longer sees an
+ * absolute path and the empty segment is simply dropped, mapping an
+ * out-of-repo dependency onto a real in-repo directory if one happens to exist.
+ *
+ * `path.posix.join` is NOT a substitute: it strips the leading slash too
+ * (`join('packages/app/', '/dep')` is `packages/app/dep`), so it produces the
+ * same fabricated path without ever rejecting anything.
+ *
+ * A `..` prefix is deliberately NOT handled here. `../core` escapes the
+ * package but not necessarily the repo, and rebasing it is exactly what the
+ * nested-package branch exists to do; `normalizeZigDepPath` rejects the ones
+ * that still escape the ROOT after rebasing.
+ */
+export declare function isAbsoluteZigDepPath(depPath: string): boolean;
 export declare function normalizeZigDepPath(depPath: string): string | null;
 /**
  * The `root_source_file` paths a `build.zig` declares, dep-relative, with the

package/dist/core/ingestion/language-config.js

@@ -439,8 +439,15 @@ async function collectDeclaredNamespaces(filePath, declaredNamespaces, rootNames
     // import whose namespace was dropped.
     return structure.incomplete ? 'truncated' : 'ok';
 }
-const SWIFT_SOURCE_FACTORY_NAMES = ['target', 'executableTarget', 'testTarget', 'macro'];
-const SWIFT_SKIP_FACTORY_NAMES = ['binaryTarget', 'plugin', 'systemLibrary'];
+const SWIFT_SOURCE_FACTORY_NAMES = [
+    'target',
+    'executableTarget',
+    'testTarget',
+    'macro',
+    'plugin',
+];
+/** No Swift sources: a prebuilt artifact or a C module map. */
+const SWIFT_SKIP_FACTORY_NAMES = ['binaryTarget', 'systemLibrary'];
 const SWIFT_SKIP_FACTORIES = new Set(SWIFT_SKIP_FACTORY_NAMES);
 const SWIFT_FACTORY_RE = new RegExp(`\\.(${[...SWIFT_SOURCE_FACTORY_NAMES, ...SWIFT_SKIP_FACTORY_NAMES].join('|')})\\s*\\(`, 'g');
 function extractBalancedParen(source, openIndex) {
@@ -550,7 +557,8 @@ function skipSwiftWsAndComments(source, start) {
     return null;
 }
 /** First `name:` / `path:` string outside comments. Escapes and interpolations are unreadable. */
-function readSwiftFactoryField(block, field) {
+/** Where `field:`'s value starts in a factory block, or null when absent. */
+function findSwiftFactoryFieldValue(block, field) {
     let inString = null;
     let escape = false;
     let inLineComment = false;
@@ -615,18 +623,56 @@ function readSwiftFactoryField(block, field) {
             i = j - 1;
             continue;
         }
-        const valueAt = skipSwiftWsAndComments(block, colonAt + 1);
-        if (valueAt === null)
-            return { value: undefined, keyPresent: true };
-        const quote = block[valueAt];
-        if (quote !== '"' && quote !== "'")
-            return { value: undefined, keyPresent: true };
-        const parsed = readSwiftSimpleQuotedString(block, valueAt);
-        if (parsed === null)
-            return { value: undefined, keyPresent: true };
-        return { value: parsed, keyPresent: true };
+        return { valueAt: skipSwiftWsAndComments(block, colonAt + 1) };
+    }
+    return null;
+}
+function readSwiftFactoryField(block, field) {
+    const found = findSwiftFactoryFieldValue(block, field);
+    if (found === null)
+        return { value: undefined, keyPresent: false };
+    const { valueAt } = found;
+    if (valueAt === null)
+        return { value: undefined, keyPresent: true };
+    const quote = block[valueAt];
+    if (quote !== '"' && quote !== "'")
+        return { value: undefined, keyPresent: true };
+    const parsed = readSwiftSimpleQuotedString(block, valueAt);
+    return { value: parsed ?? undefined, keyPresent: true };
+}
+/**
+ * `sources:` / `exclude:` as a list of string literals. `undefined` when the
+ * key is absent; `null` when present but not a plain literal list.
+ */
+function readSwiftFactoryStringList(block, field) {
+    const found = findSwiftFactoryFieldValue(block, field);
+    if (found === null)
+        return undefined;
+    let i = found.valueAt;
+    if (i === null || block[i] !== '[')
+        return null;
+    const out = [];
+    for (;;) {
+        const at = skipSwiftWsAndComments(block, i + 1);
+        if (at === null)
+            return null;
+        if (block[at] === ']')
+            return out;
+        if (block[at] !== '"' && block[at] !== "'")
+            return null;
+        const value = readSwiftSimpleQuotedString(block, at);
+        if (value === null)
+            return null;
+        out.push(value);
+        const after = skipSwiftWsAndComments(block, at + value.length + 2);
+        if (after === null)
+            return null;
+        if (block[after] === ']')
+            return out;
+        if (block[after] !== ',')
+            return null;
+        i = after;
     }
-    return { value: undefined, keyPresent: false };
 }
 /** Quoted literal with no escapes. Any `\` (including `\u{…}` and `\(`) is unreadable. */
 function readSwiftSimpleQuotedString(source, openIndex) {
@@ -788,8 +834,11 @@ function swiftPathIsUnreadable(customPath, hasPathKey) {
 /** Heuristic Package.swift scan. Never shells out to `swift package dump-package`. */
 export function parseSwiftPackageManifest(source) {
     const targets = new Map();
+    const implicitDirs = new Map();
+    const plugins = new Set();
+    const filters = new Map();
     if (swiftManifestHasCompletenessHazard(source)) {
-        return { targets, complete: false };
+        return { targets, implicitDirs, plugins, filters, complete: false };
     }
     const packageTargets = inspectSwiftPackageTargets(source);
     SWIFT_FACTORY_RE.lastIndex = 0;
@@ -832,22 +881,59 @@ export function parseSwiftPackageManifest(source) {
             sawUnreadableFactory = true;
             continue;
         }
-        const dir = customPath ?? (kind === 'testTarget' ? `Tests/${name}` : `Sources/${name}`);
+        const sources = readSwiftFactoryStringList(block, 'sources');
+        const exclude = readSwiftFactoryStringList(block, 'exclude');
+        if (sources === null || exclude === null) {
+            sawUnreadableFactory = true;
+            continue;
+        }
+        if (sources !== undefined || exclude !== undefined) {
+            filters.set(name, {
+                ...(sources !== undefined ? { sources } : {}),
+                ...(exclude !== undefined ? { exclude } : {}),
+            });
+        }
+        const dirKind = kind === 'testTarget' ? 'test' : kind === 'plugin' ? 'plugin' : 'source';
+        if (dirKind === 'plugin')
+            plugins.add(name);
+        const dir = customPath ?? `${SWIFT_DEFAULT_TARGET_PARENT[dirKind]}/${name}`;
         const existing = targets.get(name);
         if (existing === undefined) {
             targets.set(name, dir);
+            if (customPath === undefined)
+                implicitDirs.set(name, dirKind);
         }
-        else if (customPath !== undefined && existing === `Sources/${name}`) {
+        else if (customPath !== undefined && implicitDirs.has(name)) {
             // A later `.target(name:path:)` wins over an earlier same-name
             // factory that only implied the default path.
             targets.set(name, customPath);
+            implicitDirs.delete(name);
         }
     }
     return {
         targets,
+        implicitDirs,
+        plugins,
+        filters,
         complete: !sawUnreadableFactory && !packageTargets.helperBuilt,
     };
 }
+/** Conventional parent of a target with no `path:`, before disk lookup. */
+const SWIFT_DEFAULT_TARGET_PARENT = {
+    source: 'Sources',
+    test: 'Tests',
+    plugin: 'Plugins',
+};
+/**
+ * SwiftPM's predefined parents, in its search order (`PackageBuilder`):
+ * sources in `Sources`, `Source`, `src`, `srcs`; tests in `Tests` first, then
+ * the source parents; plugins only in `Plugins`.
+ */
+const SWIFT_PREDEFINED_TARGET_PARENTS = {
+    source: ['Sources', 'Source', 'src', 'srcs'],
+    test: ['Tests', 'Sources', 'Source', 'src', 'srcs'],
+    plugin: ['Plugins'],
+};
 const SWIFT_ALL_FACTORY_NAMES = new Set([
     ...SWIFT_SOURCE_FACTORY_NAMES,
     ...SWIFT_SKIP_FACTORY_NAMES,
@@ -1189,15 +1275,16 @@ function matchSwiftSquare(source, openIndex) {
     }
     return null;
 }
-async function inferSwiftDirectoryTargets(repoRoot) {
+async function inferSwiftDirectoryTargets(repoRoot, packageDir = '') {
     const targets = new Map();
-    const sourceDirs = ['Sources', 'Package/Sources', 'src'];
+    const sourceDirs = ['Sources', 'Source', 'Package/Sources', 'src', 'srcs'];
     for (const sourceDir of sourceDirs) {
         try {
-            const fullPath = path.join(repoRoot, sourceDir);
+            const fullPath = path.join(repoRoot, packageDir, sourceDir);
             const entries = await fs.readdir(fullPath, { withFileTypes: true });
             for (const entry of entries) {
-                if (entry.isDirectory()) {
+                // First parent in SwiftPM's search order wins a repeated name.
+                if (entry.isDirectory() && !targets.has(entry.name)) {
                     targets.set(entry.name, sourceDir + '/' + entry.name);
                 }
             }
@@ -1208,33 +1295,46 @@ async function inferSwiftDirectoryTargets(repoRoot) {
     }
     return targets;
 }
-export async function loadSwiftPackageConfig(repoRoot) {
+/**
+ * Load the SwiftPM config of the package at `packageDir` (repo root when
+ * omitted). Target directories stay package-relative; see
+ * {@link loadSwiftWorkspaceConfig} for the repo-relative merge.
+ */
+export async function loadSwiftPackageConfig(repoRoot, packageDir = '') {
+    const pkgRoot = path.join(repoRoot, packageDir);
     try {
-        const source = await fs.readFile(path.join(repoRoot, 'Package.swift'), 'utf-8');
+        const source = await fs.readFile(path.join(pkgRoot, await pickSwiftManifestFile(pkgRoot)), 'utf-8');
         const parsed = parseSwiftPackageManifest(source);
         if (parsed.complete) {
             if (isDev) {
                 logger.info(`📦 Loaded ${parsed.targets.size} Swift package targets from Package.swift`);
             }
+            const parents = new Map();
+            for (const [name, kind] of parsed.implicitDirs) {
+                if (!parents.has(kind))
+                    parents.set(kind, await findSwiftPredefinedParent(pkgRoot, kind));
+                const parent = parents.get(kind);
+                if (parent != null)
+                    parsed.targets.set(name, `${parent}/${name}`);
+            }
+            // Plugins are modules (grouping) but never `import`-able.
+            const declaredTargets = new Map([...parsed.targets].filter(([name]) => !parsed.plugins.has(name)));
             if (parsed.targets.size > 0) {
                 return {
                     targets: parsed.targets,
                     origin: 'package.swift',
-                    declaredTargets: parsed.targets,
+                    declaredTargets,
+                    ...(parsed.filters.size > 0 ? { targetFilters: parsed.filters } : {}),
                 };
             }
-            const inferred = await inferSwiftDirectoryTargets(repoRoot);
-            return {
-                targets: inferred,
-                origin: 'package.swift',
-                declaredTargets: parsed.targets,
-            };
+            const inferred = await inferSwiftDirectoryTargets(repoRoot, packageDir);
+            return { targets: inferred, origin: 'package.swift', declaredTargets };
         }
     }
     catch {
         // Missing or unreadable — fall through to inferred folders.
     }
-    const inferred = await inferSwiftDirectoryTargets(repoRoot);
+    const inferred = await inferSwiftDirectoryTargets(repoRoot, packageDir);
     if (inferred.size > 0) {
         if (isDev) {
             logger.info(`📦 Inferred ${inferred.size} Swift source folders`);
@@ -1243,6 +1343,60 @@ export async function loadSwiftPackageConfig(repoRoot) {
     }
     return null;
 }
+const SWIFT_VERSIONED_MANIFEST_RE = /^Package@swift-(\d+)(?:\.(\d+))?(?:\.(\d+))?\.swift$/;
+/**
+ * The manifest SwiftPM would read in `pkgRoot`. A `Package@swift-X.Y.swift`
+ * overrides `Package.swift` for toolchains at or above X.Y; the toolchain is
+ * unknown here, so assume the newest and take the highest version present.
+ */
+async function pickSwiftManifestFile(pkgRoot) {
+    let best = 'Package.swift';
+    let bestVersion = [];
+    let names;
+    try {
+        names = await fs.readdir(pkgRoot);
+    }
+    catch {
+        return best;
+    }
+    for (const name of names) {
+        const m = SWIFT_VERSIONED_MANIFEST_RE.exec(name);
+        if (m === null)
+            continue;
+        const version = [Number(m[1]), Number(m[2] ?? 0), Number(m[3] ?? 0)];
+        if (compareVersions(version, bestVersion) > 0) {
+            best = name;
+            bestVersion = version;
+        }
+    }
+    return best;
+}
+function compareVersions(a, b) {
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const d = (a[i] ?? -1) - (b[i] ?? -1);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
+/**
+ * SwiftPM's parent directory for targets of `kind` in `pkgRoot`: the first
+ * predefined parent that exists, chosen once per package (a target missing
+ * from it is a manifest error in SwiftPM, not a fallthrough). Null when none
+ * exists.
+ */
+async function findSwiftPredefinedParent(pkgRoot, kind) {
+    for (const parent of SWIFT_PREDEFINED_TARGET_PARENTS[kind]) {
+        try {
+            if ((await fs.stat(path.join(pkgRoot, parent))).isDirectory())
+                return parent;
+        }
+        catch {
+            // Not there — try the next predefined parent.
+        }
+    }
+    return null;
+}
 /**
  * Load the Zig build configuration a repo's `build.zig.zon` + root `build.zig`
  * declare: `.path` deps (and the roots their own build.zig names) from the
@@ -1563,7 +1717,7 @@ async function findZigPackageDirs(repoRoot) {
  * nested-package branch exists to do; `normalizeZigDepPath` rejects the ones
  * that still escape the ROOT after rebasing.
  */
-function isAbsoluteZigDepPath(depPath) {
+export function isAbsoluteZigDepPath(depPath) {
     const normalized = depPath.replace(/\\/g, '/');
     return normalized.startsWith('/') || /^[A-Za-z]:\//.test(normalized);
 }

package/dist/core/ingestion/languages/swift/implicit-imports.d.ts

@@ -1,37 +1,35 @@
 /**
- * Swift same-module implicit IMPORTS-edge emission for the
- * `emitImplicitImportEdges` hook.
+ * Swift same-module implicit IMPORTS for the `emitImplicitImportEdges` hook.
  *
- * Swift gives every file in a module (an SPM target) visibility of every
- * other file's top-level declarations WITHOUT any `import` statement
- * (whole-module visibility). The legacy DAG models this with File→File
- * IMPORTS edges via `wireSwiftImplicitImports`; under registry-primary
- * that wirer's `addImportEdge` is gated off, and the scope-resolution
- * import pipeline (`emitImportEdges`) only materializes edges from
- * finalized `ImportEdge`s — of which there are none here, because there
- * is no syntactic `import`. This hook emits the missing edges directly.
+ * Swift gives every file in a module visibility of every other file's
+ * top-level declarations WITHOUT any `import` statement (whole-module
+ * visibility). There is no syntactic `import`, so the finalized-ImportEdge
+ * pipeline (`emitImportEdges`) has nothing to materialize; this hook records
+ * module membership directly.
  *
- * Module identity: Swift has no in-source `package X` marker. Module
- * membership is the SPM target *subtree* (`Sources/<Target>/…`), threaded
- * in via the SPM target map (`resolutionConfig` → `coerceSwiftTargets`)
- * and grouped by `groupSwiftFilesBySpmTarget`. The helper preserves the
- * legacy `groupSwiftFilesByTarget` bucketing contract for ordinary layouts
- * while intentionally fixing #2931's repeated-prefix edge case. With no
- * target map (no Package.swift and no scanned `Sources/*`) the map is null
- * and all files form one `__default__` module (single-Xcode-project
- * assumption). An inferred folder map must keep sibling folders isolated.
- * Every pair of distinct `.swift`
- * files in the same module gets a directed IMPORTS edge in both directions
- * (whole-module visibility is symmetric).
+ * Representation: one `Module` node per Swift module with at least two member
+ * files, and one File → Module IMPORTS edge per member, reason
+ * `MODULE_MEMBERSHIP_REASON`. This is how the compiler sees it — a file
+ * imports its own module — and it is linear. The earlier File → File form
+ * wrote n·(n−1) edges per module and exhausted V8's 2^24 Map limit on a 5,200
+ * file module (#3355). "Files that see file B" is now "files with a
+ * membership edge to a Module that B also has one to"; incremental importer
+ * expansion follows that rule (`queryImportersBatch`).
  *
- * Node identity + edge construction mirror the generic `emitImportEdges`
- * convention (`graph-bridge/imports-to-edges.ts`): `generateId('File', path)`
- * for endpoints and `generateId('IMPORTS', key)` for the relationship id,
- * deduped by `(sourceFile -> targetFile)`. Re-invocation idempotency comes
- * from `graph.addRelationship` id-dedup (the same `IMPORTS` id is produced
- * for a given ordered pair), so no local `seen` set is needed.
+ * A file compiled into several Xcode targets gets an edge to each module.
+ *
+ * The Module node's `filePath` is the target directory (SwiftPM), the
+ * `.xcodeproj` bundle (Xcode), or '.' (`__default__`). Incremental writeback
+ * keys rows by `filePath`: a rewritten member file pulls that key into the
+ * write set across its membership edge, so the Module node and every
+ * membership edge are deleted and rewritten together.
+ *
+ * Idempotent: node and edge ids are derived from the module key and the
+ * member path, and `graph.addNode` / `graph.addRelationship` dedupe by id.
  */
-import type { ParsedFile } from '../../../../_shared/index.js';
+import { type ParsedFile } from '../../../../_shared/index.js';
 import type { KnowledgeGraph } from '../../../graph/types.js';
 import type { GraphNodeLookup } from '../../scope-resolution/graph-bridge/node-lookup.js';
+/** Graph id of the `Module` node for a Swift module key. */
+export declare function swiftModuleNodeId(moduleKey: string): string;
 export declare function emitSwiftImplicitImportEdges(graph: KnowledgeGraph, parsedFiles: readonly ParsedFile[], _nodeLookup: GraphNodeLookup, resolutionConfig?: unknown): void;