homegraph 1.4.1 → 1.5.1

package/dist/extraction/languages/arkts.js

@@ -3,10 +3,27 @@
  * ArkTS (.ets) extraction via ArkAnalyzer.
  *
  * Unlike tree-sitter languages, ArkTS is batch-complete: the first `.ets`
- * parse builds one Scene for the whole project, runs RTA, persists every
- * `.ets` file (nodes, edges, cross-file RTA calls) directly to the DB, then
- * returns the requested file's result. Later `.ets` hits in the same batch
- * short-circuit (orchestrator store skips via matching content hash).
+ * parse builds a Scene, runs RTA, persists every `.ets` file (nodes, edges,
+ * cross-file RTA calls) directly to the DB, then returns the requested file's
+ * result. Later `.ets` hits in the same batch short-circuit (orchestrator store
+ * skips via matching content hash).
+ *
+ * HarmonyOS multi-module projects (`build-profile.json5`) use
+ * `Scene.analyseByModule` so each HAP/HSP/HAR is the atomic unit (like a file
+ * for tree-sitter languages): symbols + ViewTree + **intra-module RTA** while
+ * the module has BODIES. Per-module RTA entries = DummyMain (Ability/Component
+ * lifecycle) **plus the module export surface** (exported functions and methods
+ * of exported classes), so non-UI libraries still grow reachable call edges.
+ * CFG does **not** stitch same-module calls (that densified past unlimited RTA).
+ * Cross-module edges come from RTA with an exact MethodSignature map, plus a
+ * CFG `%unk` bridge that recovers Class.method / free functions from stmt text,
+ * UnclearReferenceType names, or PascalCase base locals (import + unique target
+ * + fan-out blocklist). Deps load to SIGNATURES.
+ *
+ * Sync can re-index a **dirty module subset** (`primeArkTSBatch` + `changedFiles`)
+ * via `ModuleAnalysisConfig.setTargetModuleIds`, instead of rebuilding every
+ * PROJECT module. Unchanged modules stay in the DB; incoming cross-file edges
+ * into dirty files are snapshotted and re-bound like file-level sync (#899).
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -41,18 +58,30 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OHOS_API_DB_PATH_META = exports.OHOS_API_VERSION_META = exports.OHOS_API_FILE_PREFIX = exports.OhosSdkInputError = exports.ArkTSExtractor = void 0;
 exports.cleanArkTypeString = cleanArkTypeString;
 exports.normalizeArktsReturnType = normalizeArktsReturnType;
 exports.buildArkMethodSignatureFields = buildArkMethodSignatureFields;
+exports.shouldUseIsolatedArkTSBuild = shouldUseIsolatedArkTSBuild;
+exports.normalizeHarmonyModuleSrcPath = normalizeHarmonyModuleSrcPath;
+exports.listHarmonyProjectModules = listHarmonyProjectModules;
+exports.resolveDirtyHarmonyModules = resolveDirtyHarmonyModules;
 exports.isArkAnalyzerSourcePath = isArkAnalyzerSourcePath;
+exports.scanEtsFiles = scanEtsFiles;
 exports.runIsolatedArkTSBatchEntry = runIsolatedArkTSBatchEntry;
 exports.primeArkTSBatch = primeArkTSBatch;
 exports.isArkTSBatchPersisted = isArkTSBatchPersisted;
 exports.resetArkTSBatch = resetArkTSBatch;
+exports.collectExportedRtaEntryPointsFromFiles = collectExportedRtaEntryPointsFromFiles;
 exports.stateDecoratorKinds = stateDecoratorKinds;
 exports.stateTransferViaForField = stateTransferViaForField;
+exports.isUnclearArkClassSignature = isUnclearArkClassSignature;
+exports.isUnclearArkMethodSignature = isUnclearArkMethodSignature;
+exports.pickPreferredClassNodeId = pickPreferredClassNodeId;
 exports.drainArkTSIndexNotices = drainArkTSIndexNotices;
 exports.parseOhosToolsVersionFromName = parseOhosToolsVersionFromName;
 exports.isArchivePath = isArchivePath;
@@ -82,11 +111,16 @@ const child_process_1 = require("child_process");
 const arkanalyzer_1 = require("arkanalyzer");
 const db_1 = require("../../db");
 const queries_1 = require("../../db/queries");
+const directory_1 = require("../../directory");
+const project_config_1 = require("../../project-config");
 const context_1 = require("../context");
+const default_ignore_1 = require("../default-ignore");
 const extraction_version_1 = require("../extraction-version");
 const version_1 = require("../../mcp/version");
+const liveness_watchdog_1 = require("../../mcp/liveness-watchdog");
 const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
 const wasm_runtime_flags_1 = require("../wasm-runtime-flags");
+const ignore_1 = __importDefault(require("ignore"));
 /** Primitive / void return types — not stored in nodes.return_type (inference-only column). */
 const ARKTS_NON_CLASS_RETURN = new Set([
     'void',
@@ -222,16 +256,148 @@ function isStackOverflowExitCode(code) {
         return false;
     return code === 3221225725 || code === -1073741571;
 }
-function shouldUseIsolatedArkTSBuild(etsCount) {
+/**
+ * Opt-in isolated ArkTS Scene build (child process + enlarged `--stack-size`).
+ * Default is in-process: faster and avoids a Windows-only auto-isolated path that
+ * could burn minutes on failed stack-size retries before giving up. Set
+ * `HOMEGRAPH_ARKTS_ISOLATED=1` only when an in-process Scene build stack-overflows
+ * the indexer (rare Photos-scale Windows cases).
+ */
+function shouldUseIsolatedArkTSBuild() {
     const mode = process.env.HOMEGRAPH_ARKTS_ISOLATED?.trim();
-    if (mode === '1' || mode === 'true')
-        return true;
+    return mode === '1' || mode === 'true';
+}
+/**
+ * Scene eviction budget sits below the V8 heap cap (heap default 3584MB so process
+ * RSS stays near 4GB — native memory sits outside the heap). Small reserve only.
+ */
+const ARKTS_HOMEGRAPH_RESERVE_MB = 256;
+/** Default Scene `memoryLimitMB`. Override with HOMEGRAPH_ARKTS_MEMORY_LIMIT_MB. */
+function defaultArkTSSceneMemoryLimitMB() {
+    return Math.max(512, (0, wasm_runtime_flags_1.resolveMaxOldSpaceSizeMb)() - ARKTS_HOMEGRAPH_RESERVE_MB);
+}
+/**
+ * RSS limit passed to ArkAnalyzer `SceneOptions.memoryLimitMB`.
+ * When exceeded, `analyseByModule` evicts cached modules before loading the next.
+ * Set `HOMEGRAPH_ARKTS_MEMORY_LIMIT_MB=0` to disable Scene eviction.
+ */
+function resolveArkTSSceneMemoryLimitMB() {
+    const raw = process.env.HOMEGRAPH_ARKTS_MEMORY_LIMIT_MB?.trim();
+    if (raw !== undefined && raw !== '') {
+        const n = Number(raw);
+        if (Number.isFinite(n) && n >= 0)
+            return Math.floor(n);
+    }
+    return defaultArkTSSceneMemoryLimitMB();
+}
+/** Prefer modular Scene build when the project has Harmony module metadata. */
+function shouldUseModularArkTSBuild(rootDir) {
+    const mode = process.env.HOMEGRAPH_ARKTS_MODULAR?.trim();
     if (mode === '0' || mode === 'false')
         return false;
-    // Photos-scale repos on Windows: build Scene in a child with a larger stack.
-    if (process.platform === 'win32' && etsCount >= 500)
+    if (mode === '1' || mode === 'true')
         return true;
-    return false;
+    return fs.existsSync(path.join(rootDir, 'build-profile.json5'));
+}
+/** Normalize build-profile `srcPath` / relative file paths for prefix matching. */
+function normalizeHarmonyModuleSrcPath(srcPath) {
+    return srcPath.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/$/, '');
+}
+/**
+ * Read PROJECT modules from root `build-profile.json5` (name + srcPath).
+ * Returns [] when missing or unparsable — callers should fall back to full Scene.
+ */
+function listHarmonyProjectModules(rootDir) {
+    const profilePath = path.join(rootDir, 'build-profile.json5');
+    if (!fs.existsSync(profilePath))
+        return [];
+    let raw;
+    try {
+        raw = parseJson5Minimal(fs.readFileSync(profilePath, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+    if (!raw || typeof raw !== 'object')
+        return [];
+    const modules = raw.modules;
+    if (!Array.isArray(modules))
+        return [];
+    const out = [];
+    for (const entry of modules) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const rec = entry;
+        if (typeof rec.name !== 'string' || typeof rec.srcPath !== 'string')
+            continue;
+        const srcPath = normalizeHarmonyModuleSrcPath(rec.srcPath);
+        if (!srcPath)
+            continue;
+        out.push({ name: rec.name, srcPath });
+    }
+    return out;
+}
+function findLongestHarmonyModule(fileRel, modules) {
+    const file = normIndexPath(fileRel);
+    let best = null;
+    for (const mod of modules) {
+        const src = mod.srcPath;
+        if (file === src || file.startsWith(`${src}/`)) {
+            if (!best || mod.srcPath.length > best.srcPath.length)
+                best = mod;
+        }
+    }
+    return best;
+}
+/**
+ * Map changed/removed paths to Harmony modules for incremental ArkTS sync.
+ * Structural project files (`build-profile.json5`, root `oh-package.json5`) or
+ * ArkAnalyzer sources outside every module force a full rebuild.
+ */
+function resolveDirtyHarmonyModules(rootDir, changedFiles) {
+    if (!shouldUseModularArkTSBuild(rootDir)) {
+        return { mode: 'full', reason: 'non-modular ArkTS project' };
+    }
+    const modules = listHarmonyProjectModules(rootDir);
+    if (modules.length === 0) {
+        return { mode: 'full', reason: 'no PROJECT modules in build-profile.json5' };
+    }
+    const changed = [...changedFiles].map(normIndexPath).filter(Boolean);
+    if (changed.length === 0)
+        return { mode: 'none' };
+    for (const f of changed) {
+        if (f === 'build-profile.json5' || f.endsWith('/build-profile.json5')) {
+            return { mode: 'full', reason: 'build-profile.json5 changed' };
+        }
+        if (f === 'oh-package.json5') {
+            return { mode: 'full', reason: 'root oh-package.json5 changed' };
+        }
+    }
+    const dirty = new Set();
+    const unmatched = [];
+    for (const f of changed) {
+        // Virtual ArkAnalyzer paths are batch artifacts, not Harmony module sources.
+        if (f.startsWith('@'))
+            continue;
+        const isModuleMeta = f.endsWith('/module.json5') || f.endsWith('/oh-package.json5');
+        const isArkSrc = isArkAnalyzerSourcePath(f);
+        if (!isArkSrc && !isModuleMeta)
+            continue;
+        const match = findLongestHarmonyModule(f, modules);
+        if (match)
+            dirty.add(match.srcPath);
+        else if (isArkSrc)
+            unmatched.push(f);
+    }
+    if (unmatched.length > 0) {
+        return {
+            mode: 'full',
+            reason: `ArkTS sources outside modules: ${unmatched.slice(0, 5).join(', ')}`,
+        };
+    }
+    if (dirty.size === 0)
+        return { mode: 'none' };
+    return { mode: 'modules', moduleSrcPaths: [...dirty].sort() };
 }
 function homegraphDbPath(rootDir) {
     return path.join(rootDir, '.homegraph', 'homegraph.db');
@@ -239,6 +405,9 @@ function homegraphDbPath(rootDir) {
 const ARK_PROVENANCE = 'heuristic';
 /** Virtual file path for ArkAnalyzer's in-scene dummy entry (not on disk). */
 const ARKANALYZER_DUMMY_FILE = '@dummyFile.ets';
+function fieldSigKey(classSig, fieldName) {
+    return `${classSig}::${fieldName}`;
+}
 /** HarmonyOS sources indexed via ArkAnalyzer Scene batch (`.ets`, `.ts`, `.d.ts`). */
 function isArkAnalyzerSourcePath(filePath) {
     const base = path.basename(filePath);
@@ -251,8 +420,24 @@ function isEtsFileName(name) {
 function isCoLocatedArkTsFileName(name) {
     return isArkAnalyzerSourcePath(name) && !isEtsFileName(name);
 }
+/**
+ * Ignore matchers aligned with `scanDirectoryWalk`'s base set (built-in defaults
+ * + root `.gitignore` + `homegraph.json` `exclude`).
+ */
+function arktsScanIgnoreMatchers(rootDir) {
+    const matchers = [(0, default_ignore_1.buildDefaultIgnore)(rootDir)];
+    const exclude = (0, project_config_1.loadExcludePatterns)(rootDir);
+    if (exclude.length > 0)
+        matchers.push((0, ignore_1.default)().add(exclude));
+    return matchers;
+}
+function isArktsScanIgnored(relPath, isDir, matchers) {
+    const probe = isDir ? `${relPath.replace(/\/$/, '')}/` : relPath;
+    return matchers.some((ig) => ig.ignores(probe));
+}
 /** True when the tree looks like a HarmonyOS / ArkTS project (not a generic TS repo). */
 function hasHarmonyProjectMarkers(rootDir) {
+    const matchers = arktsScanIgnoreMatchers(rootDir);
     const found = [];
     function walk(dir) {
         if (found.length > 0)
@@ -266,13 +451,17 @@ function hasHarmonyProjectMarkers(rootDir) {
         }
         for (const entry of entries) {
             const full = path.join(dir, entry.name);
+            const rel = path.relative(rootDir, full).replace(/\\/g, '/');
             if (entry.isDirectory()) {
-                if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === '.homegraph') {
+                if (entry.name === '.git' || (0, directory_1.isHomeGraphDataDir)(entry.name))
+                    continue;
+                if (isArktsScanIgnored(rel, true, matchers))
                     continue;
-                }
                 walk(full);
             }
             else if (entry.isFile() && (isEtsFileName(entry.name) || entry.name === 'module.json5')) {
+                if (isArktsScanIgnored(rel, false, matchers))
+                    continue;
                 found.push(full);
                 return;
             }
@@ -306,9 +495,17 @@ function emptyResult(filePath, message, severity) {
         durationMs: 0,
     };
 }
+/**
+ * Enumerate ArkAnalyzer sources under `rootDir`, using the same ignore rules as
+ * `scanDirectory` (defaults like `build/`/`dist/`, root `.gitignore`, exclude).
+ * Previously this walk only skipped `node_modules`/`.git`/`.homegraph`, so
+ * HarmonyOS build-output `.ets` files got written into the DB and non-git
+ * `homegraph status` reported them as Pending Removed.
+ */
 function scanEtsFiles(rootDir) {
     const etsFiles = [];
     const coLocated = [];
+    const matchers = arktsScanIgnoreMatchers(rootDir);
     function walk(dir) {
         let entries;
         try {
@@ -319,13 +516,17 @@ function scanEtsFiles(rootDir) {
         }
         for (const entry of entries) {
             const full = path.join(dir, entry.name);
+            const rel = path.relative(rootDir, full).replace(/\\/g, '/');
             if (entry.isDirectory()) {
-                if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === '.homegraph')
+                if (entry.name === '.git' || (0, directory_1.isHomeGraphDataDir)(entry.name))
+                    continue;
+                if (isArktsScanIgnored(rel, true, matchers))
                     continue;
                 walk(full);
             }
             else if (entry.isFile()) {
-                const rel = path.relative(rootDir, full).replace(/\\/g, '/');
+                if (isArktsScanIgnored(rel, false, matchers))
+                    continue;
                 if (isEtsFileName(entry.name)) {
                     etsFiles.push(rel);
                 }
@@ -358,12 +559,15 @@ let batchBuildCommitted = false;
 function reportBatchProgress(subphase, current, total, currentFile) {
     (0, context_1.reportArkTSBatchProgress)({ subphase, current, total, currentFile });
 }
-function persistFileResult(queries, filePath, content, stats, result) {
+function persistFileResult(queries, filePath, content, stats, result, options) {
     const contentHash = hashContent(content);
     const existingFile = queries.getFileByPath(filePath);
-    if (existingFile?.contentHash === contentHash) {
+    if (!options?.force && existingFile?.contentHash === contentHash) {
         return;
     }
+    const crossFileIncomingEdges = existingFile && typeof queries.getCrossFileIncomingEdgesWithTarget === 'function'
+        ? queries.getCrossFileIncomingEdgesWithTarget(filePath)
+        : [];
     if (existingFile) {
         queries.deleteFile(filePath);
     }
@@ -378,6 +582,30 @@ function persistFileResult(queries, filePath, content, stats, result) {
             queries.insertEdges(validEdges);
         }
     }
+    if (crossFileIncomingEdges.length > 0) {
+        const newNodesByKindName = new Map();
+        for (const n of validNodes) {
+            newNodesByKindName.set(`${n.kind}\0${n.name}`, n.id);
+        }
+        const reinserted = [];
+        for (const e of crossFileIncomingEdges) {
+            const newTargetId = newNodesByKindName.get(`${e.targetKind}\0${e.targetName}`);
+            if (newTargetId) {
+                reinserted.push({
+                    source: e.source,
+                    target: newTargetId,
+                    kind: e.kind,
+                    metadata: e.metadata,
+                    line: e.line,
+                    column: e.column,
+                    provenance: e.provenance,
+                });
+            }
+        }
+        if (reinserted.length > 0) {
+            queries.insertEdges(reinserted);
+        }
+    }
     if (result.unresolvedReferences.length > 0) {
         const insertedIds = new Set(validNodes.map((n) => n.id));
         const refsWithContext = result.unresolvedReferences
@@ -403,6 +631,22 @@ function persistFileResult(queries, filePath, content, stats, result) {
     };
     queries.upsertFile(fileRecord);
 }
+/** Force-rewrite every file in an incremental module index (edges may change without content). */
+function persistIncrementalModuleResults(rootDir, queries, index) {
+    const persistTotal = index.fileResults.size;
+    let persistIndex = 0;
+    for (const [filePath, fileResult] of index.fileResults) {
+        persistIndex++;
+        reportBatchProgress('persist', persistIndex, persistTotal, filePath);
+        const isVirtual = filePath.startsWith('@');
+        const full = path.join(rootDir, filePath);
+        const content = isVirtual ? '' : fs.readFileSync(full, 'utf-8');
+        const stats = isVirtual
+            ? { size: 0, mtimeMs: Date.now() }
+            : fs.statSync(full);
+        persistFileResult(queries, filePath, content, stats, fileResult, { force: true });
+    }
+}
 async function persistBatchResultsAsync(rootDir, queries, index) {
     const entries = [...index.fileResults.entries()];
     const persistTotal = entries.length;
@@ -501,8 +745,12 @@ function spawnIsolatedArkTSBatchWorker(rootDir, dbPath, triggerFile) {
     const workerPath = path.join(__dirname, '..', 'arkts-batch-worker.js');
     let lastCode = null;
     for (const stackKb of resolveArkTSWorkerStackSizesKb()) {
-        process.stderr.write(`\n\x1b[33m    ArkTS: full Scene build in isolated process (--stack-size=${stackKb} KB, enableMethodBodyBuild=true)...\x1b[0m\n`);
-        const argv = (0, wasm_runtime_flags_1.buildRelaunchArgv)(workerPath, [rootDir, dbPath, triggerFile], [`--stack-size=${stackKb}`]);
+        process.stderr.write(`\n\x1b[33m    ArkTS: Scene build in isolated process (--stack-size=${stackKb} KB; modular if build-profile.json5)...\x1b[0m\n`);
+        const argv = (0, wasm_runtime_flags_1.buildRelaunchArgv)(workerPath, [rootDir, dbPath, triggerFile], [
+            ...process.execArgv,
+            `--stack-size=${stackKb}`,
+            (0, wasm_runtime_flags_1.maxOldSpaceSizeFlag)(),
+        ]);
         const result = (0, child_process_1.spawnSync)(process.execPath, argv, {
             stdio: 'inherit',
             env: process.env,
@@ -558,7 +806,7 @@ function runArkTSBatchFullCore(rootDir, queries, triggerFile, etsFiles, batchKey
     }
 }
 function runArkTSBatchFull(rootDir, queries, triggerFile, etsFiles, batchKey) {
-    if (shouldUseIsolatedArkTSBuild(etsFiles.length)) {
+    if (shouldUseIsolatedArkTSBuild()) {
         const dbPath = homegraphDbPath(rootDir);
         if (!fs.existsSync(dbPath)) {
             throw new Error(`ArkTS isolated build requires ${dbPath}`);
@@ -569,7 +817,8 @@ function runArkTSBatchFull(rootDir, queries, triggerFile, etsFiles, batchKey) {
             const spawned = spawnIsolatedArkTSBatchWorker(rootDir, dbPath, triggerFile);
             if (!spawned.ok) {
                 throw new Error(`ArkTS isolated Scene build failed (exit ${spawned.lastCode ?? 'unknown'}). ` +
-                    'Try HOMEGRAPH_ARKTS_STACK_SIZES_KB=65536,131072,262144');
+                    'Unset HOMEGRAPH_ARKTS_ISOLATED to use the default in-process build, ' +
+                    'or raise HOMEGRAPH_ARKTS_STACK_SIZES_KB (e.g. 65536,131072,262144)');
             }
             return markBatchCommittedAfterWorker(rootDir, triggerFile, etsFiles, batchKey);
         }
@@ -605,12 +854,28 @@ function runArkTSBatch(rootDir, queries, triggerFile) {
     return runArkTSBatchFull(rootDir, queries, normalizedTrigger, etsFiles, batchKey);
 }
 /** Async batch build with parallel file reads during persist (used by indexAll). */
-async function primeArkTSBatch(rootDir, queries, triggerFile) {
+async function primeArkTSBatch(rootDir, queries, triggerFile, options) {
     const normalizedTrigger = normIndexPath(triggerFile);
     const etsFiles = scanEtsFiles(rootDir);
-    const cached = tryReturnCachedBatch(rootDir, normalizedTrigger, etsFiles);
-    if (cached) {
-        return;
+    const changed = options?.changedFiles
+        ? [...options.changedFiles].map(normIndexPath).filter(Boolean)
+        : null;
+    if (changed) {
+        const resolution = resolveDirtyHarmonyModules(rootDir, changed);
+        if (resolution.mode === 'none') {
+            return;
+        }
+        if (resolution.mode === 'modules') {
+            await runArkTSBatchIncrementalModules(rootDir, queries, normalizedTrigger, etsFiles, resolution.moduleSrcPaths);
+            return;
+        }
+        // mode === 'full': fall through to full rebuild (ignore in-memory cache).
+    }
+    else {
+        const cached = tryReturnCachedBatch(rootDir, normalizedTrigger, etsFiles);
+        if (cached) {
+            return;
+        }
     }
     const batchKey = etsFiles.length > 0 ? computeBatchKey(rootDir, etsFiles) : '';
     batchTriggerFile = null;
@@ -620,7 +885,7 @@ async function primeArkTSBatch(rootDir, queries, triggerFile) {
         batchBuildCommitted = false;
         return;
     }
-    if (shouldUseIsolatedArkTSBuild(etsFiles.length)) {
+    if (shouldUseIsolatedArkTSBuild()) {
         runArkTSBatchFull(rootDir, queries, normalizedTrigger, etsFiles, batchKey);
         return;
     }
@@ -646,6 +911,56 @@ async function primeArkTSBatch(rootDir, queries, triggerFile) {
         (0, context_1.setArktsBatchRunning)(false);
     }
 }
+async function runArkTSBatchIncrementalModules(rootDir, queries, triggerFile, etsFiles, moduleSrcPaths) {
+    // Isolated worker has no module-subset protocol yet — fall back to full.
+    if (shouldUseIsolatedArkTSBuild()) {
+        const batchKey = etsFiles.length > 0 ? computeBatchKey(rootDir, etsFiles) : '';
+        runArkTSBatchFull(rootDir, queries, triggerFile, etsFiles, batchKey);
+        return;
+    }
+    batchTriggerFile = null;
+    batchPersistedPaths = new Set();
+    (0, context_1.setArktsBatchRunning)(true);
+    try {
+        reportBatchProgress('scene', 0, etsFiles.length);
+        const index = buildArkTSIndexByModule(rootDir, etsFiles, { targetModuleSrcPaths: moduleSrcPaths });
+        if (index.fileResults.size === 0) {
+            const fatal = index.errors.find((e) => e.severity === 'error');
+            // Fall back to full project batch when the subset produced nothing.
+            const batchKey = etsFiles.length > 0 ? computeBatchKey(rootDir, etsFiles) : '';
+            if (fatal) {
+                process.stderr.write(`\n\x1b[33m    ArkTS: incremental modules failed (${fatal.message}); full rebuild\x1b[0m\n`);
+            }
+            const full = buildArkTSIndex(rootDir, etsFiles);
+            if (full.fileResults.size === 0) {
+                throw new Error(fatal?.message ?? 'ArkTS incremental batch produced no indexed files');
+            }
+            queries.deleteArkTSCrossFileCallEdges();
+            await persistBatchResultsAsync(rootDir, queries, full);
+            if (full.crossFileEdges.length > 0) {
+                const valid = full.crossFileEdges.filter((e) => full.nodeIds.has(e.source) && full.nodeIds.has(e.target));
+                if (valid.length > 0)
+                    queries.insertEdges(valid);
+            }
+            commitArkTSBatch(rootDir, batchKey, etsFiles, full, triggerFile);
+            return;
+        }
+        persistIncrementalModuleResults(rootDir, queries, index);
+        if (index.crossFileEdges.length > 0) {
+            const valid = index.crossFileEdges.filter((e) => index.nodeIds.has(e.source) && index.nodeIds.has(e.target));
+            if (valid.length > 0) {
+                queries.insertEdges(valid);
+            }
+        }
+        // Unique key so a partial index is never mistaken for a full-project cache hit.
+        const batchKey = `incremental:${moduleSrcPaths.join(',')}`;
+        commitArkTSBatch(rootDir, batchKey, etsFiles, index, triggerFile);
+        process.stderr.write(`\n\x1b[33m    ArkTS: incremental module reindex done (${moduleSrcPaths.join(', ')})\x1b[0m\n`);
+    }
+    finally {
+        (0, context_1.setArktsBatchRunning)(false);
+    }
+}
 /** True when this `.ets` file was already written by the in-memory ArkTS batch. */
 function isArkTSBatchPersisted(filePath) {
     return batchPersistedPaths.has(normIndexPath(filePath));
@@ -965,20 +1280,22 @@ function arkEdge(source, target, kind, extra) {
         ...extra,
     };
 }
-function collectComponentScope(scene) {
+function collectComponentScopeFromFiles(files) {
     const scope = [];
-    for (const cls of scene.getClasses()) {
-        if (cls.isDefaultArkClass())
-            continue;
-        if (cls.hasComponentDecorator()) {
-            scope.push(cls);
+    for (const file of files) {
+        for (const cls of file.getClasses()) {
+            if (cls.isDefaultArkClass())
+                continue;
+            if (cls.hasComponentDecorator()) {
+                scope.push(cls);
+            }
         }
     }
     return scope;
 }
-function collectNonUiRtaEntryPoints(scene) {
+function collectNonUiRtaEntryPointsFromFiles(files) {
     const entries = [];
-    for (const file of scene.getFiles()) {
+    for (const file of files) {
         const defaultClass = file.getDefaultClass();
         for (const method of defaultClass.getMethods()) {
             if (shouldSkipArkMethod(method))
@@ -991,14 +1308,152 @@ function collectNonUiRtaEntryPoints(scene) {
     }
     return entries;
 }
+/**
+ * Methods another module can call into: module `export` surface as RTA entries.
+ * - exported function/method → itself
+ * - exported class/struct → all of its non-skip methods (with body)
+ * Skips `export … from` re-exports (not this module's IR).
+ */
+function collectExportedRtaEntryPointsFromFiles(files) {
+    const seen = new Set();
+    const out = [];
+    const addMethod = (method) => {
+        if (shouldSkipArkMethod(method))
+            return;
+        try {
+            if (!method.getCfg())
+                return;
+        }
+        catch {
+            return;
+        }
+        try {
+            const sig = method.getSignature();
+            const key = sig.toString();
+            if (seen.has(key))
+                return;
+            seen.add(key);
+            out.push(sig);
+        }
+        catch {
+            // signature unavailable
+        }
+    };
+    const addClass = (cls) => {
+        try {
+            for (const method of cls.getMethods(true)) {
+                addMethod(method);
+            }
+        }
+        catch {
+            // class IR unavailable
+        }
+    };
+    const visitExportInfos = (infos) => {
+        for (const info of infos) {
+            try {
+                if (info.getFrom?.())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            let arkExport;
+            try {
+                arkExport = info.getArkExport?.() ?? null;
+            }
+            catch {
+                continue;
+            }
+            if (!arkExport || typeof arkExport !== 'object')
+                continue;
+            const exp = arkExport;
+            // Prefer ExportType when present (METHOD=2, CLASS=1, NAME_SPACE=0).
+            let exportType;
+            try {
+                exportType = exp.getExportType?.();
+            }
+            catch {
+                exportType = undefined;
+            }
+            if (exportType === 2 || (exportType === undefined && typeof exp.getDeclaringArkClass === 'function' && typeof exp.getCfg === 'function')) {
+                addMethod(arkExport);
+                continue;
+            }
+            if (exportType === 1 || (exportType === undefined && typeof exp.getMethods === 'function')) {
+                addClass(arkExport);
+                continue;
+            }
+            if (exportType === 0 || typeof exp.getClasses === 'function') {
+                try {
+                    for (const cls of exp.getClasses?.() ?? []) {
+                        addClass(cls);
+                    }
+                }
+                catch {
+                    // ignore
+                }
+                const nested = exp.getExportInfos?.();
+                if (nested)
+                    visitExportInfos(nested);
+            }
+        }
+    };
+    for (const file of files) {
+        try {
+            visitExportInfos(file.getExportInfos());
+        }
+        catch {
+            // ignore
+        }
+        try {
+            for (const ns of file.getNamespaces()) {
+                try {
+                    visitExportInfos(ns.getExportInfos());
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return out;
+}
+/** Merge RTA entry signatures, preserving order and dropping duplicates. */
+function mergeRtaEntryPoints(...groups) {
+    const seen = new Set();
+    const out = [];
+    for (const group of groups) {
+        for (const sig of group) {
+            try {
+                const key = sig.toString();
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                out.push(sig);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    return out;
+}
 function resolveRtaEntryPoints(scene) {
+    return resolveRtaEntryPointsFromFiles(scene, scene.getFiles());
+}
+/** RTA entries scoped to the given files (one Harmony module while it is loaded). */
+function resolveRtaEntryPointsFromFiles(scene, files) {
     const explicit = scene.getEntryPoints();
     if (explicit.length > 0) {
         return { entryPoints: explicit, dummyMain: null };
     }
-    if (sceneHasArkUiEntries(scene)) {
+    if (filesHaveArkUiEntries(files)) {
         try {
-            const componentScope = collectComponentScope(scene);
+            const componentScope = collectComponentScopeFromFiles(files);
             const dummy = new arkanalyzer_1.DummyMainCreater(scene, undefined, componentScope.length > 0 ? componentScope : undefined, true);
             dummy.createDummyMain();
             const dummyMain = dummy.getDummyMain();
@@ -1008,11 +1463,11 @@ function resolveRtaEntryPoints(scene) {
             // fall through
         }
     }
-    const fallback = collectNonUiRtaEntryPoints(scene);
+    const fallback = collectNonUiRtaEntryPointsFromFiles(files);
     return { entryPoints: fallback, dummyMain: null };
 }
-function sceneHasArkUiEntries(scene) {
-    for (const file of scene.getFiles()) {
+function filesHaveArkUiEntries(files) {
+    for (const file of files) {
         for (const cls of file.getClasses()) {
             if (cls.isDefaultArkClass())
                 continue;
@@ -1049,92 +1504,437 @@ function viewTreeLineFromStmt(stmt) {
     return stmt?.getOriginFullPosition()?.getFirstLine() ?? 1;
 }
 function isViewTreeClassSignature(sig) {
-    return sig instanceof arkanalyzer_1.ClassSignature;
+    // Prefer instanceof; duck-type fallback if duplicate arkanalyzer copies break instanceof.
+    if (sig instanceof arkanalyzer_1.ClassSignature)
+        return true;
+    if (sig instanceof arkanalyzer_1.MethodSignature)
+        return false;
+    const anySig = sig;
+    // Require ClassSignature shape — MethodSignature-like and other sigs must not enter getClass().
+    return (typeof anySig.getClassName === 'function' &&
+        typeof anySig.getDeclaringFileSignature === 'function' &&
+        typeof anySig.getMethodSubSignature !== 'function');
 }
-function walkViewTree(node, visit) {
-    visit(node);
-    for (const child of node.children) {
-        walkViewTree(child, visit);
+/** Skip anonymous / synthetic Ark names for name→id fallback maps. */
+function isUsableArkTypeName(name) {
+    return !!name && !name.startsWith('%') && !name.startsWith('<');
+}
+/** Escape a literal for use inside a RegExp source. */
+function escapeRegExpLiteral(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * ArkUI framework IR receivers — `View.create` / `Column.pop` / `If.branch`
+ * are synthesizer noise, not project call sites. Never seed name-match from them.
+ */
+const ARKUI_IR_CALL_RECEIVERS = new Set([
+    'View',
+    'If',
+    'ForEach',
+    'LazyForEach',
+    'Repeat',
+    'Column',
+    'Row',
+    'Stack',
+    'Flex',
+    'Grid',
+    'List',
+    'Swiper',
+    'Tabs',
+    'TabContent',
+    'Button',
+    'Text',
+    'Image',
+    'Scroll',
+    'WaterFlow',
+    'RelativeContainer',
+    'Blank',
+    'Divider',
+    'Span',
+    'Canvas',
+    'XComponent',
+]);
+const ARKUI_IR_CALL_METHODS = new Set(['create', 'pop', 'branch', 'iterator']);
+const ARKTS_STDLIB_CALL_RECEIVERS = new Set([
+    'Array',
+    'Map',
+    'Set',
+    'Object',
+    'Promise',
+    'JSON',
+    'String',
+    'Number',
+    'Boolean',
+    'Error',
+    'Date',
+    'Math',
+    'RegExp',
+    'Symbol',
+]);
+function isJunkArkCallSeed(className, methodName) {
+    if (ARKTS_STDLIB_CALL_RECEIVERS.has(className))
+        return true;
+    if (ARKUI_IR_CALL_RECEIVERS.has(className) && ARKUI_IR_CALL_METHODS.has(methodName)) {
+        return true;
     }
+    return false;
 }
-function indexViewTreeForClass(ctx, cls, result, relativePath) {
-    if (!cls.hasViewTree())
-        return;
-    const viewTree = cls.getViewTree();
-    if (!viewTree)
-        return;
-    const root = viewTree.getRoot();
-    if (!root)
-        return;
-    const classNodeId = ctx.resolveClassNodeId(cls);
-    if (!classNodeId)
-        return;
-    const buildMethod = cls.getMethods(true).find((m) => m.getName() === 'build');
-    if (!buildMethod)
-        return;
-    const buildId = ctx.ensureMethodNode(buildMethod, relativePath, result, classNodeId);
-    if (!buildId)
-        return;
-    const seen = new Set();
-    const link = (source, target, kind, via, line) => {
-        const key = `${source}>${target}>${kind}>${via}`;
-        if (seen.has(key))
-            return;
-        seen.add(key);
-        ctx.addEdge(result, source, target, kind, relativePath, via, line);
-    };
-    for (const [field] of viewTree.getStateValues()) {
-        const fieldId = ctx.fieldToId.get(field);
-        if (fieldId) {
-            ctx.markFieldStateDecorators?.(field, fieldId, result);
-            const line = field.getOriginFullPosition?.()?.getFirstLine?.() ??
-                buildMethod.getImplOriginFullPosition()?.getFirstLine() ??
-                1;
-            link(fieldId, buildId, 'references', 'state-binding', line);
-        }
+/**
+ * CFG must not name-link these across modules: each is a unique `Class::method`
+ * key that still fans out to tens of thousands of invoke sites (singletons,
+ * loggers, constructors) — far denser than RTA reachability on unlimited indexes.
+ */
+const ARKTS_CFG_CROSS_MODULE_METHOD_BLOCKLIST = new Set([
+    'getInstance',
+    'constructor',
+    'toString',
+    'valueOf',
+    'showInfo',
+    'showError',
+    'showWarn',
+    'showDebug',
+    'show',
+    'create',
+    'pop',
+    'push',
+    'splice',
+    'isEmpty',
+    'getContext',
+    'copyFrom',
+    // High fan-out helpers seen densifying same-module CFG on scene_board
+    'getGridOccupyStatus',
+    'isInStatusForGrid',
+    'isInStatus',
+    'getStatus',
+    'isOccupied',
+    'isFree',
+    'markStatus',
+    'markGridForCellAndSpan',
+    'createRelativePath',
+    'dealWantParams',
+    'getPreviewContentWidth',
+    'getIconArray',
+    'getSizeX',
+    'getSizeY',
+]);
+/**
+ * When ArkAnalyzer leaves a cross-module static call as `%unk/.use()`, recover
+ * `Lib.use` from the invoke's original source. Only PascalCase receivers — so
+ * `obj.foo()` / `this.bar()` stay unresolved rather than bare-method magnets.
+ *
+ * Trust short snippets only. Allow `return` / simple `const|let|var x =` prefixes
+ * (`const x = Lib.use(b)` is the common modular IR original-text shape).
+ */
+function recoverClassMethodFromStmt(stmt, methodName) {
+    if (!stmt || !methodName)
+        return null;
+    let text;
+    try {
+        text = stmt.getOriginalText?.();
     }
-    walkViewTree(root, (node) => {
-        const sig = node.signature;
-        if (sig) {
-            if (isViewTreeClassSignature(sig)) {
-                const childCls = ctx.scene.getClass(sig);
-                if (childCls) {
-                    const childId = ctx.resolveClassNodeId(childCls);
-                    if (childId) {
-                        const firstAttr = node.attributes.values().next().value;
-                        const line = firstAttr
-                            ? viewTreeLineFromStmt(firstAttr[0])
-                            : buildMethod.getImplOriginFullPosition()?.getFirstLine() ?? 1;
-                        link(buildId, childId, 'references', 'child-component', line);
-                    }
-                }
-            }
-            else {
-                const builderMethod = ctx.scene.getMethod(sig);
-                if (builderMethod) {
-                    const builderId = ctx.ensureMethodNode(builderMethod, relativePath, result, classNodeId);
+    catch {
+        text = undefined;
+    }
+    if (!text)
+        return null;
+    const trimmed = text.trim();
+    if (trimmed.length === 0 || trimmed.length > 160)
+        return null;
+    // Mock / matcher wrappers are not real call seeds.
+    if (/^(?:when|mock|spyOn)\s*\(/i.test(trimmed))
+        return null;
+    const re = new RegExp(`(?:^|(?:return\\s+)|(?:(?:const|let|var)\\s+[\\w$]+\\s*=\\s*))([A-Z][\\w$]*)\\.${escapeRegExpLiteral(methodName)}\\s*\\(`);
+    const m = trimmed.match(re);
+    return m?.[1] ? `${m[1]}.${methodName}` : null;
+}
+/**
+ * Free-function call left as `%unk/.getOpaque()`: short text still contains
+ * `getOpaque(` (not `Class.getOpaque`). Caller must import-gate + unique name.
+ */
+function recoverFreeFunctionFromStmt(stmt, methodName) {
+    if (!stmt || !methodName)
+        return null;
+    if (!/^[a-z][\w$]*$/.test(methodName))
+        return null;
+    let text;
+    try {
+        text = stmt.getOriginalText?.();
+    }
+    catch {
+        text = undefined;
+    }
+    if (!text)
+        return null;
+    const trimmed = text.trim();
+    if (trimmed.length === 0 || trimmed.length > 160)
+        return null;
+    if (/^(?:when|mock|spyOn)\s*\(/i.test(trimmed))
+        return null;
+    // Reject Class.method — that path belongs to recoverClassMethodFromStmt.
+    if (new RegExp(`[A-Z][\\w$]*\\.${escapeRegExpLiteral(methodName)}\\s*\\(`).test(trimmed)) {
+        return null;
+    }
+    const re = new RegExp(`(?:^|[^\\w.$])${escapeRegExpLiteral(methodName)}\\s*\\(`);
+    return re.test(trimmed) ? methodName : null;
+}
+/**
+ * Instance invoke whose MethodSignature is `%unk` may still carry a typed base:
+ * ClassType (full sig) or UnclearReferenceType (type name string only — common
+ * when deps are SIGNATURES-only).
+ */
+function recoverClassMethodFromInstanceType(invoke, methodName) {
+    if (!invoke || !methodName)
+        return null;
+    try {
+        const base = invoke.getBase?.();
+        if (!base)
+            return null;
+        const type = base.getType?.();
+        if (!type)
+            return null;
+        const fromClassSig = type.getClassSignature?.()?.getClassName?.() ??
+            '';
+        if (isUsableArkTypeName(fromClassSig) && !fromClassSig.includes('%')) {
+            return `${fromClassSig}.${methodName}`;
+        }
+        // UnclearReferenceType: getName() === "Base" (no file path).
+        const fromName = type.getName?.() ??
+            '';
+        if (isUsableArkTypeName(fromName) && !fromName.includes('%') && /^[A-Z]/.test(fromName)) {
+            return `${fromName}.${methodName}`;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Modular IR often models `Lib.use` as an instance invoke with base Local named
+ * `Lib` and type unknown — recover from the PascalCase base name.
+ */
+function recoverClassMethodFromBaseName(invoke, methodName) {
+    if (!invoke || !methodName)
+        return null;
+    try {
+        const base = invoke.getBase?.();
+        if (!base)
+            return null;
+        const baseName = base.getName?.() ?? '';
+        if (!isUsableArkTypeName(baseName) || !/^[A-Z]/.test(baseName) || baseName.includes('%')) {
+            return null;
+        }
+        return `${baseName}.${methodName}`;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Cross-module `%unk` invoke → `Class.method`, free function name, or
+ * `instantiates` class. Never emit a bare instance-method name alone.
+ */
+function callReferenceNameFromSig(sig, opts) {
+    try {
+        const methodName = sig.getMethodSubSignature()?.getMethodName?.() ?? '';
+        if (!methodName || methodName.startsWith('%') || methodName.startsWith('<'))
+            return null;
+        const className = sig.getDeclaringClassSignature()?.getClassName?.() ?? '';
+        if (isUsableArkTypeName(className) && !className.includes('%')) {
+            if (methodName === 'constructor') {
+                return { name: className, kind: 'instantiates' };
+            }
+            if (isJunkArkCallSeed(className, methodName))
+                return null;
+            return { name: `${className}.${methodName}`, kind: 'calls' };
+        }
+        if (methodName === 'constructor')
+            return null;
+        const recovered = recoverClassMethodFromStmt(opts?.stmt, methodName) ??
+            recoverClassMethodFromInstanceType(opts?.invoke, methodName) ??
+            recoverClassMethodFromBaseName(opts?.invoke, methodName);
+        if (recovered) {
+            const dot = recovered.indexOf('.');
+            if (dot > 0 && isJunkArkCallSeed(recovered.slice(0, dot), recovered.slice(dot + 1))) {
+                return null;
+            }
+            return { name: recovered, kind: 'calls' };
+        }
+        const free = recoverFreeFunctionFromStmt(opts?.stmt, methodName);
+        if (free)
+            return { name: free, kind: 'calls', freeFunction: true };
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * True when a ClassSignature still has ArkAnalyzer's placeholder file
+ * (`%unk`) — common on ViewTree stubs after a dependency was evicted before
+ * type inference could rewrite `new LiveCardListView` to a real file path.
+ */
+function isUnclearArkClassSignature(sig) {
+    try {
+        const fileSig = sig.getDeclaringFileSignature();
+        const fileName = fileSig.getFileName();
+        const projectName = fileSig.getProjectName();
+        if (fileName === '%unk' || projectName === '%unk')
+            return true;
+        if (fileName.includes('%unk') || projectName.includes('%unk'))
+            return true;
+        return sig.toString().includes('%unk');
+    }
+    catch {
+        return true;
+    }
+}
+function isUnclearArkMethodSignature(sig) {
+    try {
+        return isUnclearArkClassSignature(sig.getDeclaringClassSignature());
+    }
+    catch {
+        return true;
+    }
+}
+/** Among candidate node ids, prefer a single `component` over same-name struct/class. */
+function pickPreferredClassNodeId(candidateIds, isComponent) {
+    const ids = [...candidateIds];
+    if (ids.length === 0)
+        return null;
+    if (ids.length === 1)
+        return ids[0] ?? null;
+    const components = ids.filter((id) => isComponent(id));
+    if (components.length === 1)
+        return components[0] ?? null;
+    return null;
+}
+/** Walk ViewTree with cycle protection (shared/cloned nodes can form graphs). */
+function walkViewTree(node, visit, seen = new Set()) {
+    if (seen.has(node))
+        return;
+    seen.add(node);
+    visit(node);
+    for (const child of node.children) {
+        walkViewTree(child, visit, seen);
+    }
+}
+function indexViewTreeForClass(ctx, cls, result, relativePath) {
+    if (!cls.hasViewTree())
+        return;
+    const viewTree = cls.getViewTree();
+    if (!viewTree)
+        return;
+    const root = viewTree.getRoot();
+    if (!root)
+        return;
+    const classNodeId = ctx.resolveClassNodeId(cls);
+    if (!classNodeId)
+        return;
+    const buildMethod = cls.getMethods(true).find((m) => m.getName() === 'build');
+    if (!buildMethod)
+        return;
+    const buildId = ctx.ensureMethodNode(buildMethod, relativePath, result, classNodeId);
+    if (!buildId)
+        return;
+    const seen = new Set();
+    const link = (source, target, kind, via, line) => {
+        const key = `${source}>${target}>${kind}>${via}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        ctx.addEdge(result, source, target, kind, relativePath, via, line);
+    };
+    for (const [field] of viewTree.getStateValues()) {
+        const fieldId = ctx.resolveFieldNodeId(field);
+        if (fieldId) {
+            ctx.markFieldStateDecorators?.(field, fieldId, result);
+            const line = field.getOriginFullPosition?.()?.getFirstLine?.() ??
+                buildMethod.getImplOriginFullPosition()?.getFirstLine() ??
+                1;
+            link(fieldId, buildId, 'references', 'state-binding', line);
+        }
+    }
+    walkViewTree(root, (node) => {
+        const sig = node.signature;
+        if (sig) {
+            try {
+                if (isViewTreeClassSignature(sig)) {
+                    // Stub or live: prefer already-indexed sig→id (works after dep unload);
+                    // %unk stubs also fall back to class name / parent-file import.
+                    // Then fall back to live IR object maps when the class is still resident.
+                    // Guard getClass — a mis-typed signature must not abort the whole ViewTree walk.
+                    let childCls = null;
+                    try {
+                        childCls = ctx.scene.getClass(sig);
+                    }
+                    catch {
+                        childCls = null;
+                    }
+                    const childId = ctx.resolveClassIdBySig(sig, cls) ??
+                        (childCls ? ctx.resolveClassNodeId(childCls) : null);
+                    if (childId) {
+                        let line = buildMethod.getImplOriginFullPosition()?.getFirstLine() ?? 1;
+                        try {
+                            const firstAttr = node.attributes?.values()?.next()?.value;
+                            if (firstAttr)
+                                line = viewTreeLineFromStmt(firstAttr[0]);
+                        }
+                        catch {
+                            // keep build() line
+                        }
+                        link(buildId, childId, 'references', 'child-component', line);
+                    }
+                }
+                else {
+                    // MethodSignature: builder stub (sig only) or live ArkMethod.
+                    let builderMethod = null;
+                    try {
+                        builderMethod = ctx.scene.getMethod(sig);
+                    }
+                    catch {
+                        builderMethod = null;
+                    }
+                    const builderId = ctx.resolveMethodIdBySig(sig, cls) ??
+                        (builderMethod
+                            ? ctx.ensureMethodNode(builderMethod, relativePath, result, classNodeId)
+                            : null);
                     if (builderId) {
-                        link(buildId, builderId, 'references', 'builder', builderMethod.getImplOriginFullPosition()?.getFirstLine() ?? 1);
+                        const line = builderMethod
+                            ? builderMethod.getImplOriginFullPosition()?.getFirstLine() ?? 1
+                            : buildMethod.getImplOriginFullPosition()?.getFirstLine() ?? 1;
+                        link(buildId, builderId, 'references', 'builder', line);
                     }
                 }
             }
+            catch {
+                // Skip this node's signature edge; keep walking siblings/children.
+            }
         }
         if (node.stateValuesTransfer) {
             for (const [childField, parentValue] of node.stateValuesTransfer) {
-                const childFieldId = ctx.fieldToId.get(childField);
+                const childFieldId = ctx.resolveFieldNodeId(childField);
                 if (parentValue instanceof arkanalyzer_1.ArkField) {
                     const via = stateTransferViaForField(childField);
                     if (!via || !childFieldId)
                         continue;
                     ctx.markFieldStateDecorators?.(childField, childFieldId, result);
-                    const parentFieldId = ctx.fieldToId.get(parentValue);
+                    const parentFieldId = ctx.resolveFieldNodeId(parentValue);
                     if (parentFieldId) {
                         ctx.markFieldStateDecorators?.(parentValue, parentFieldId, result);
                         link(parentFieldId, childFieldId, 'references', via, childField.getOriginFullPosition()?.getFirstLine() ?? 1);
                     }
                 }
                 else if (parentValue instanceof arkanalyzer_1.ArkMethod) {
-                    const builderId = ctx.ensureMethodNode(parentValue, relativePath, result, classNodeId);
+                    let builderId = ctx.ensureMethodNode(parentValue, relativePath, result, classNodeId);
+                    if (!builderId) {
+                        try {
+                            builderId = ctx.resolveMethodIdBySig(parentValue.getSignature());
+                        }
+                        catch {
+                            builderId = null;
+                        }
+                    }
                     if (childFieldId && builderId) {
                         link(builderId, childFieldId, 'references', 'builder-param', childField.getOriginFullPosition()?.getFirstLine() ?? 1);
                     }
@@ -1146,12 +1946,15 @@ function indexViewTreeForClass(ctx, cls, result, relativePath) {
                 continue;
             const line = viewTreeLineFromStmt(stmt);
             for (const v of values) {
-                if (!(v instanceof arkanalyzer_1.MethodSignature))
+                const isMethodSig = v instanceof arkanalyzer_1.MethodSignature ||
+                    (v != null &&
+                        typeof v.getMethodSubSignature === 'function');
+                if (!isMethodSig)
                     continue;
-                const handler = ctx.scene.getMethod(v);
-                if (!handler)
-                    continue;
-                const handlerId = ctx.ensureMethodNode(handler, relativePath, result, classNodeId);
+                const methodSig = v;
+                const handler = ctx.scene.getMethod(methodSig);
+                const handlerId = ctx.resolveMethodIdBySig(methodSig, cls) ??
+                    (handler ? ctx.ensureMethodNode(handler, relativePath, result, classNodeId) : null);
                 if (handlerId)
                     link(buildId, handlerId, 'references', attr, line);
             }
@@ -1166,100 +1969,536 @@ class ArkTSAdapter {
     classToId = new Map();
     componentToId = new Map();
     fieldToId = new Map();
+    /** Stable across module unload — signature string → HomeGraph node id. */
+    methodSigToId = new Map();
+    classSigToId = new Map();
+    fieldSigToId = new Map();
+    /**
+     * Name → candidate node ids for ViewTree stub stitch when the signature is still
+     * `@%unk/%unk: ClassName` after dependency eviction. Prefer `component` over
+     * same-name struct/class; ambiguous multi-component names use the importer.
+     */
+    classNameToIds = new Map();
+    classIdFilePath = new Map();
+    classIdIsComponent = new Map();
+    /** `ClassName::methodName` → candidate method node ids (unclear MethodSignature stubs). */
+    methodNameKeyToIds = new Map();
+    /** Bare default-class function name → ids (unique import-gated CFG bridge). */
+    functionNameToIds = new Map();
+    methodIdFilePath = new Map();
+    emittedEdgeKeys = new Set();
     nodeIds = new Set();
     fileResults = new Map();
     crossFileEdges = [];
+    /** Per-module `@dummyMain@…` created during analyseByModule (for scene aggregator). */
+    moduleDummyMains = [];
     constructor(rootDir, scannedFiles) {
         this.rootDir = rootDir;
         this.scanned = new Set(scannedFiles);
     }
     build(scene) {
         this.scene = scene;
-        const { entryPoints, dummyMain } = resolveRtaEntryPoints(scene);
         for (const arkFile of scene.getFiles()) {
-            const relativePath = normalizeRelPath(this.rootDir, arkFile.getFilePath());
-            if (!this.scanned.has(relativePath))
-                continue;
-            if (!isArkAnalyzerSourcePath(relativePath))
+            this.indexScannedFile(arkFile);
+        }
+        this.indexViewTreesFromFiles(scene.getFiles());
+        this.finalizeCallGraph(scene);
+        return this.toBatchIndex();
+    }
+    /**
+     * Index one Harmony module while loaded (baseline = this module):
+     * symbols → rebind resident deps → ViewTree/RTA from this module (B→A via
+     * live IR or sig→id maps for already-indexed unloaded deps).
+     */
+    indexModule(module, scene) {
+        this.scene = scene;
+        const files = [...module.getFilesMap().values()];
+        const moduleFiles = new Set(files.map((f) => normalizeRelPath(this.rootDir, f.getFilePath())).filter(Boolean));
+        for (const arkFile of files) {
+            this.indexScannedFile(arkFile);
+        }
+        // Rebind still-resident deps so live getClass/getMethod works when topo kept them warm.
+        this.bindLiveMapsFromResident(scene);
+        // Incremental / first-in-topo: populate sig→id maps from other loaded modules
+        // (deps at SIGNATURES) without persisting those files into this batch.
+        this.seedMapsFromOtherLoadedFiles(scene, moduleFiles);
+        this.indexViewTreesFromFiles(files);
+        this.ingestModuleCallGraph(scene, module, files, moduleFiles);
+        // CFG: only narrow `%unk` cross-module bridge (no same-module CFG calls).
+        this.stitchModuleCfgCallsAndRefs(files, moduleFiles);
+        // Drop live IR object keys so ArkAnalyzer can GC unloaded modules; keep sig→id maps.
+        this.releaseLiveIrMaps();
+    }
+    /**
+     * Index symbols from already-loaded non-target modules into sig/name maps only.
+     * Used so incremental BODIES targets can still resolve cross-module RTA/ViewTree
+     * edges against deps that stay at SIGNATURES (and are not re-persisted).
+     */
+    seedMapsFromOtherLoadedFiles(scene, excludeFiles) {
+        const seeded = [];
+        for (const mod of scene.getModules()) {
+            let filesMap;
+            try {
+                filesMap = mod.getFilesMap();
+            }
+            catch {
                 continue;
-            this.indexFile(arkFile);
+            }
+            for (const arkFile of filesMap.values()) {
+                const rel = normalizeRelPath(this.rootDir, arkFile.getFilePath());
+                if (!rel || excludeFiles.has(rel) || this.fileResults.has(rel))
+                    continue;
+                if (!this.scanned.has(rel) || !isArkAnalyzerSourcePath(rel))
+                    continue;
+                this.indexScannedFile(arkFile);
+                if (this.fileResults.has(rel))
+                    seeded.push(rel);
+            }
+        }
+        for (const rel of seeded) {
+            this.fileResults.delete(rel);
         }
-        for (const cls of scene.getClasses()) {
-            if (!cls.hasViewTree())
+    }
+    bindLiveMapsFromResident(scene) {
+        const cache = scene.getModuleCache();
+        if (!cache)
+            return;
+        const files = [];
+        for (const id of cache.getLoadedModules()) {
+            const mod = scene.getModule(id);
+            if (!mod || mod.getModuleType() === arkanalyzer_1.ModuleType.SDK)
+                continue;
+            if (mod.getLoadState() < arkanalyzer_1.ModuleLoadState.SIGNATURES)
                 continue;
-            const arkFile = cls.getDeclaringArkFile();
+            files.push(...mod.getFilesMap().values());
+        }
+        if (files.length > 0)
+            this.bindLiveMapsFromFiles(files);
+    }
+    /** Re-attach live Ark* objects to already-indexed HomeGraph node ids (sig maps). */
+    bindLiveMapsFromFiles(files) {
+        for (const arkFile of files) {
             const relativePath = normalizeRelPath(this.rootDir, arkFile.getFilePath());
             if (!this.scanned.has(relativePath) || !isArkAnalyzerSourcePath(relativePath))
                 continue;
-            const result = this.fileResults.get(relativePath);
-            if (!result)
-                continue;
+            this.bindLiveClass(arkFile.getDefaultClass());
+            for (const cls of arkFile.getClasses()) {
+                this.bindLiveClass(cls);
+            }
+            for (const ns of arkFile.getNamespaces()) {
+                this.bindLiveNamespace(ns);
+            }
+        }
+    }
+    bindLiveNamespace(ns) {
+        this.bindLiveClass(ns.getDefaultClass());
+        for (const cls of ns.getClasses()) {
+            this.bindLiveClass(cls);
+        }
+        for (const child of ns.getNamespaces()) {
+            this.bindLiveNamespace(child);
+        }
+    }
+    bindLiveClass(cls) {
+        try {
+            const classSig = cls.getSignature().toString();
+            const classId = this.classSigToId.get(classSig);
+            if (classId) {
+                this.classToId.set(cls, classId);
+                if (cls.hasComponentDecorator()) {
+                    this.componentToId.set(cls, classId);
+                }
+            }
+            for (const method of cls.getMethods(true)) {
+                try {
+                    const mid = this.methodSigToId.get(method.getSignature().toString());
+                    if (mid)
+                        this.methodToId.set(method, mid);
+                }
+                catch {
+                    // skip
+                }
+            }
+            for (const field of cls.getFields()) {
+                const fid = this.fieldSigToId.get(fieldSigKey(classSig, field.getName()));
+                if (fid)
+                    this.fieldToId.set(field, fid);
+            }
+        }
+        catch {
+            // signature unavailable
+        }
+    }
+    finalizeCallGraph(scene) {
+        this.scene = scene;
+        // Modular path: intra-module RTA already ran per module. Do NOT run a
+        // scene aggregator RTA — that re-walks overlapping reachable sets and was
+        // a major wall-clock cost. Cross-module gaps link only via exact
+        // signature / unique Class.method maps (no unresolved name-match seeds).
+        if (this.moduleDummyMains.length > 0) {
             try {
-                indexViewTreeForClass(this.viewTreeContext(), cls, result, relativePath);
+                for (const m of this.moduleDummyMains) {
+                    this.indexArkanalyzerDummyMain(m);
+                }
             }
-            catch (e) {
-                const message = e instanceof Error ? e.message : String(e);
-                result.errors.push({
-                    message: `ViewTree indexing skipped for ${cls.getName()}: ${message}`,
-                    filePath: relativePath,
-                    severity: 'warning',
-                });
+            catch {
+                // ignore
             }
+            return;
         }
+        const { entryPoints, dummyMain } = resolveRtaEntryPoints(scene);
         if (dummyMain) {
             this.indexArkanalyzerDummyMain(dummyMain);
         }
+        if (entryPoints.length === 0)
+            return;
         let callGraph;
         try {
-            callGraph =
-                entryPoints.length > 0 ? scene.makeCallGraphRTA(entryPoints) : null;
+            callGraph = scene.makeCallGraphRTA(entryPoints);
         }
         catch {
-            callGraph = null;
+            return;
         }
-        if (callGraph) {
-            for (const edge of callGraph.getCallEdges()) {
-                const caller = callGraph.getArkMethodByFuncID(edge.getSrcID());
-                const callee = callGraph.getArkMethodByFuncID(edge.getDstID());
-                if (!caller || !callee)
-                    continue;
-                if (shouldSkipArkMethod(caller) &&
-                    !isAnonymousArkMethod(caller) &&
-                    !caller.getDeclaringArkClass().isDefaultArkClass() &&
-                    !caller.isGenerated()) {
-                    continue;
-                }
-                const callerId = this.resolveMethodNodeId(caller);
-                const calleeId = this.resolveMethodNodeId(callee);
-                if (!callerId || !calleeId)
+        this.ingestCallGraph(callGraph, null);
+    }
+    ingestModuleCallGraph(scene, module, files, moduleFiles) {
+        let entryPoints = [];
+        let dummyMain = null;
+        try {
+            // Prefer AA's forModule when present; otherwise DIY with the public ctor
+            // (module-scoped name + this module's classes).
+            const forModule = arkanalyzer_1.DummyMainCreater.forModule;
+            let creater;
+            if (typeof forModule === 'function') {
+                creater = forModule(scene, module, true);
+            }
+            else {
+                const classScope = collectComponentScopeFromFiles(files);
+                const moduleName = module.getModuleName() || 'module';
+                creater = new arkanalyzer_1.DummyMainCreater(scene, `@dummyMain@${moduleName}`, classScope.length > 0 ? classScope : undefined, true);
+            }
+            creater.createDummyMain();
+            dummyMain = creater.getDummyMain();
+            if (dummyMain) {
+                entryPoints = [dummyMain.getSignature()];
+                this.moduleDummyMains.push(dummyMain);
+            }
+        }
+        catch {
+            // Fall back to file-scoped DummyMain (components only) if creation fails.
+            const resolved = resolveRtaEntryPointsFromFiles(scene, files);
+            entryPoints = resolved.entryPoints;
+            dummyMain = resolved.dummyMain;
+        }
+        if (dummyMain) {
+            this.indexArkanalyzerDummyMain(dummyMain);
+        }
+        // Export surface = cross-module call-ins; seed them as RTA entries so
+        // non-UI libraries (Manager.getInstance → …) grow intra-module edges
+        // without waiting for a Component DummyMain to reach them.
+        entryPoints = mergeRtaEntryPoints(entryPoints, collectExportedRtaEntryPointsFromFiles(files));
+        if (entryPoints.length === 0)
+            return;
+        let callGraph;
+        try {
+            callGraph = scene.makeCallGraphRTA(entryPoints);
+        }
+        catch {
+            return;
+        }
+        this.ingestCallGraph(callGraph, moduleFiles);
+    }
+    /**
+     * Keep ArkAnalyzer RTA edges whose **caller** is in the current module.
+     *
+     * - Same-module: live IR id, exact MethodSignature map, or unique Class.method
+     *   name fallback (path-drift).
+     * - Cross-module: **exact MethodSignature string or live callee only** — no
+     *   Class.method name fallback (that + CFG densified scene_board to ~400k
+     *   ark calls vs ~76k on an unlimited RTA index).
+     */
+    ingestCallGraph(callGraph, moduleFiles) {
+        for (const edge of callGraph.getCallEdges()) {
+            const callerArk = callGraph.getArkMethodByFuncID(edge.getSrcID());
+            const calleeArk = callGraph.getArkMethodByFuncID(edge.getDstID());
+            const callerSig = callGraph.getMethodByFuncID(edge.getSrcID());
+            const calleeSig = callGraph.getMethodByFuncID(edge.getDstID());
+            if (callerArk &&
+                shouldSkipArkMethod(callerArk) &&
+                !isAnonymousArkMethod(callerArk) &&
+                !callerArk.getDeclaringArkClass().isDefaultArkClass() &&
+                !callerArk.isGenerated()) {
+                continue;
+            }
+            const callerFile = (callerArk ? relPathForArkFile(this.rootDir, callerArk.getDeclaringArkFile()) : null) ??
+                (callerSig ? this.relPathFromMethodSignature(callerSig) : null) ??
+                '';
+            if (moduleFiles && callerFile && !moduleFiles.has(callerFile)) {
+                continue;
+            }
+            const calleeFile = (calleeArk ? relPathForArkFile(this.rootDir, calleeArk.getDeclaringArkFile()) : null) ??
+                (calleeSig ? this.relPathFromMethodSignature(calleeSig) : null);
+            const callerId = (callerArk ? this.resolveMethodNodeId(callerArk) : null) ??
+                (callerSig ? this.resolveMethodIdBySigExact(callerSig) : null);
+            if (!callerId)
+                continue;
+            const sameModule = !!moduleFiles && !!calleeFile && moduleFiles.has(calleeFile);
+            const dispatch = edge.hasDirectCall() ? 'direct' : 'indirect';
+            // Full-scene path (no moduleFiles): keep prior resolveMethodIdBySig behavior.
+            if (!moduleFiles) {
+                const calleeId = (calleeArk ? this.resolveMethodNodeId(calleeArk) : null) ??
+                    (calleeSig ? this.resolveMethodIdBySig(calleeSig) : null);
+                if (!calleeId)
                     continue;
-                const callerFile = relPathForArkFile(this.rootDir, caller.getDeclaringArkFile());
-                const callEdge = arkEdge(callerId, calleeId, 'calls', {
-                    metadata: {
-                        synthesizedBy: 'arkanalyzer',
-                        dispatch: edge.hasDirectCall() ? 'direct' : 'indirect',
-                        sourceFile: callerFile,
-                        rtaEntry: caller.isGenerated?.() && caller.getName() === '@dummyMain'
-                            ? '@dummyMain'
-                            : undefined,
-                    },
-                });
-                const callerResult = this.fileResults.get(callerFile);
-                if (callerResult && this.nodeInFile(calleeId, callerFile)) {
-                    callerResult.edges.push(callEdge);
+                this.emitArkCallEdge(callerId, calleeId, callerFile, dispatch, callerArk);
+                continue;
+            }
+            if (!sameModule) {
+                const calleeId = (calleeArk ? this.resolveMethodNodeId(calleeArk) : null) ??
+                    (calleeSig ? this.resolveMethodIdBySigExact(calleeSig) : null);
+                if (calleeId) {
+                    this.emitArkCallEdge(callerId, calleeId, callerFile, dispatch, callerArk);
                 }
-                else {
-                    this.crossFileEdges.push(callEdge);
+                continue;
+            }
+            const calleeId = (calleeArk ? this.resolveMethodNodeId(calleeArk) : null) ??
+                (calleeSig ? this.resolveMethodIdBySig(calleeSig) : null);
+            if (!calleeId)
+                continue;
+            this.emitArkCallEdge(callerId, calleeId, callerFile, dispatch, callerArk);
+        }
+    }
+    /**
+     * CFG call stitch (modular): no same-module CFG call edges (those were the
+     * ~150k `direct` flood past unlimited RTA). Only the narrow cross-module
+     * `%unk` bridge for `return Lib.use(…)`-style static calls.
+     */
+    stitchModuleCfgCallsAndRefs(files, _moduleFiles) {
+        for (const arkFile of files) {
+            const callerFile = normalizeRelPath(this.rootDir, arkFile.getFilePath());
+            const visitClass = (cls) => {
+                for (const method of cls.getMethods(true)) {
+                    if (shouldSkipArkMethod(method) &&
+                        !isAnonymousArkMethod(method) &&
+                        !method.isGenerated()) {
+                        continue;
+                    }
+                    const callerId = this.resolveMethodNodeId(method) ??
+                        (() => {
+                            try {
+                                return this.methodSigToId.get(method.getSignature().toString()) ?? null;
+                            }
+                            catch {
+                                return null;
+                            }
+                        })();
+                    if (!callerId)
+                        continue;
+                    let cfg;
+                    try {
+                        cfg = method.getCfg();
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!cfg)
+                        continue;
+                    for (const stmt of cfg.getStmts()) {
+                        let invoke;
+                        try {
+                            invoke = stmt.getInvokeExpr();
+                        }
+                        catch {
+                            continue;
+                        }
+                        if (!invoke)
+                            continue;
+                        let calleeSig;
+                        try {
+                            calleeSig = invoke.getMethodSignature();
+                        }
+                        catch {
+                            continue;
+                        }
+                        if (!calleeSig)
+                            continue;
+                        // Skip clear same-module paths — RTA owns those. Only `%unk` /
+                        // missing-path invokes may take the narrow cross-module bridge.
+                        const calleeFile = this.relPathFromMethodSignature(calleeSig);
+                        if (calleeFile)
+                            continue;
+                        this.tryLinkCfgCrossModuleUnk(callerId, callerFile, calleeSig, method, stmt, invoke, arkFile);
+                    }
                 }
+            };
+            visitClass(arkFile.getDefaultClass());
+            for (const cls of arkFile.getClasses())
+                visitClass(cls);
+            const walkNs = (ns) => {
+                visitClass(ns.getDefaultClass());
+                for (const cls of ns.getClasses())
+                    visitClass(cls);
+                for (const child of ns.getNamespaces())
+                    walkNs(child);
+            };
+            for (const ns of arkFile.getNamespaces())
+                walkNs(ns);
+        }
+    }
+    emitArkCallEdge(callerId, calleeId, callerFile, dispatch, callerArk) {
+        const edgeKey = `${callerId}\0${calleeId}\0calls\0${dispatch}`;
+        if (this.emittedEdgeKeys.has(edgeKey))
+            return;
+        if (this.emittedEdgeKeys.has(`${callerId}\0${calleeId}\0calls\0direct`))
+            return;
+        if (this.emittedEdgeKeys.has(`${callerId}\0${calleeId}\0calls\0indirect`))
+            return;
+        this.emittedEdgeKeys.add(edgeKey);
+        const callEdge = arkEdge(callerId, calleeId, 'calls', {
+            metadata: {
+                synthesizedBy: 'arkanalyzer',
+                dispatch,
+                sourceFile: callerFile || undefined,
+                rtaEntry: callerArk?.isGenerated?.() && callerArk.getName() === '@dummyMain'
+                    ? '@dummyMain'
+                    : undefined,
+            },
+        });
+        const callerResult = callerFile ? this.fileResults.get(callerFile) : undefined;
+        if (callerResult && this.nodeInFile(calleeId, callerFile)) {
+            callerResult.edges.push(callEdge);
+        }
+        else {
+            this.crossFileEdges.push(callEdge);
+        }
+    }
+    /**
+     * CFG `%unk` bridge: recover Class.method / free function from invoke crumbs
+     * (stmt text, UnclearReferenceType name, PascalCase base local), require
+     * import + unique indexed target, skip fan-out blocklist. No unresolved refs.
+     */
+    tryLinkCfgCrossModuleUnk(callerId, callerFile, calleeSig, callerArk, stmt, invoke, arkFile) {
+        // Only for unclear / %unk signatures — clear typed cross-module invokes
+        // stay RTA-only so we do not densify past unlimited RTA.
+        if (!isUnclearArkMethodSignature(calleeSig)) {
+            try {
+                const className = calleeSig.getDeclaringClassSignature()?.getClassName?.() ?? '';
+                if (isUsableArkTypeName(className) && !className.includes('%'))
+                    return;
             }
+            catch {
+                // treat as unclear
+            }
+        }
+        const parsed = callReferenceNameFromSig(calleeSig, { stmt, invoke });
+        if (!parsed || parsed.kind !== 'calls')
+            return;
+        if (parsed.freeFunction) {
+            const fnName = parsed.name;
+            if (!fnName || ARKTS_CFG_CROSS_MODULE_METHOD_BLOCKLIST.has(fnName))
+                return;
+            if (!this.fileImportsLocalName(arkFile, fnName))
+                return;
+            const calleeId = this.resolveFunctionIdByName(fnName);
+            if (!calleeId)
+                return;
+            this.emitArkCallEdge(callerId, calleeId, callerFile, 'direct', callerArk);
+            return;
+        }
+        const dot = parsed.name.indexOf('.');
+        if (dot <= 0)
+            return;
+        const className = parsed.name.slice(0, dot);
+        const methodName = parsed.name.slice(dot + 1);
+        if (!className || !methodName)
+            return;
+        if (ARKTS_CFG_CROSS_MODULE_METHOD_BLOCKLIST.has(methodName))
+            return;
+        if (isJunkArkCallSeed(className, methodName))
+            return;
+        if (!this.fileImportsLocalName(arkFile, className))
+            return;
+        const calleeId = this.resolveMethodIdByName(className, methodName);
+        if (!calleeId)
+            return;
+        this.emitArkCallEdge(callerId, calleeId, callerFile, 'direct', callerArk);
+    }
+    fileImportsLocalName(arkFile, localName) {
+        try {
+            return !!arkFile.getImportInfoBy(localName);
         }
+        catch {
+            return false;
+        }
+    }
+    /** Exact MethodSignature.toString() → node id (no Class.method name fallback). */
+    resolveMethodIdBySigExact(sig) {
+        try {
+            return this.methodSigToId.get(sig.toString()) ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Project-relative path from a MethodSignature's declaring file (may be %unk). */
+    relPathFromMethodSignature(sig) {
+        try {
+            const fileName = sig.getDeclaringClassSignature().getDeclaringFileSignature().getFileName();
+            if (!fileName || fileName === '%unk' || fileName.includes('%unk'))
+                return null;
+            return normalizeRelPath(this.rootDir, fileName);
+        }
+        catch {
+            return null;
+        }
+    }
+    releaseLiveIrMaps() {
+        this.methodToId.clear();
+        this.classToId.clear();
+        this.componentToId.clear();
+        this.fieldToId.clear();
+    }
+    toBatchIndex(errors = []) {
         return {
             fileResults: this.fileResults,
             crossFileEdges: this.crossFileEdges,
             nodeIds: this.nodeIds,
-            errors: [],
+            errors: [...errors],
         };
     }
+    indexScannedFile(arkFile) {
+        const relativePath = normalizeRelPath(this.rootDir, arkFile.getFilePath());
+        if (!this.scanned.has(relativePath))
+            return;
+        if (!isArkAnalyzerSourcePath(relativePath))
+            return;
+        this.indexFile(arkFile);
+    }
+    indexViewTreesFromFiles(files) {
+        for (const arkFile of files) {
+            const relativePath = normalizeRelPath(this.rootDir, arkFile.getFilePath());
+            if (!this.scanned.has(relativePath) || !isArkAnalyzerSourcePath(relativePath))
+                continue;
+            const result = this.fileResults.get(relativePath);
+            if (!result)
+                continue;
+            for (const cls of arkFile.getClasses()) {
+                if (!cls.hasViewTree())
+                    continue;
+                try {
+                    indexViewTreeForClass(this.viewTreeContext(), cls, result, relativePath);
+                }
+                catch (e) {
+                    const message = e instanceof Error ? e.message : String(e);
+                    result.errors.push({
+                        message: `ViewTree indexing skipped for ${cls.getName()}: ${message}`,
+                        filePath: relativePath,
+                        severity: 'warning',
+                    });
+                }
+            }
+        }
+    }
     /** Index ArkAnalyzer's in-scene @dummyMain (DummyMainCreater output), not a HomeGraph synthetic node. */
     indexArkanalyzerDummyMain(dummyMain) {
         const result = this.ensureFileResult(ARKANALYZER_DUMMY_FILE, 1);
@@ -1414,6 +2653,13 @@ class ArkTSAdapter {
         });
         this.addNode(result, classNode);
         this.classToId.set(cls, classNode.id);
+        try {
+            this.classSigToId.set(cls.getSignature().toString(), classNode.id);
+        }
+        catch {
+            // signature unavailable
+        }
+        this.rememberClassName(displayName, classNode.id, relativePath, false);
         result.edges.push(arkEdge(parentId, classNode.id, 'contains'));
         this.indexDecorators(result, classNode.id, cls, relativePath, language, line);
         if (cls.isAnonymousClass()) {
@@ -1434,6 +2680,13 @@ class ArkTSAdapter {
             const componentNode = makeNode(relativePath, language, 'component', displayName, qn, line, endLine, col, { ...modelModifiersToNodeExtras(cls) });
             this.addNode(result, componentNode);
             this.componentToId.set(cls, componentNode.id);
+            try {
+                this.classSigToId.set(cls.getSignature().toString(), componentNode.id);
+            }
+            catch {
+                // signature unavailable
+            }
+            this.rememberClassName(displayName, componentNode.id, relativePath, true);
             result.edges.push(arkEdge(classNode.id, componentNode.id, 'contains'));
         }
         const superName = cls.getSuperClassName();
@@ -1518,6 +2771,12 @@ class ArkTSAdapter {
         });
         this.addNode(result, fieldNode);
         this.fieldToId.set(field, fieldNode.id);
+        try {
+            this.fieldSigToId.set(fieldSigKey(cls.getSignature().toString(), name), fieldNode.id);
+        }
+        catch {
+            // signature unavailable
+        }
         result.edges.push(arkEdge(parentId, fieldNode.id, 'contains'));
         this.indexDecorators(result, fieldNode.id, field, relativePath, language, line);
     }
@@ -1536,6 +2795,9 @@ class ArkTSAdapter {
             addEdge: (result, source, target, kind, callerFile, via, line) => this.addViewTreeEdge(result, source, target, kind, callerFile, via, line),
             ensureMethodNode: (method, relativePath, result, parentId) => this.ensureMethodNode(method, relativePath, result, parentId),
             resolveClassNodeId: (cls) => this.resolveClassNodeId(cls),
+            resolveClassIdBySig: (sig, importer) => this.resolveClassIdBySig(sig, importer),
+            resolveMethodIdBySig: (sig, importer) => this.resolveMethodIdBySig(sig, importer),
+            resolveFieldNodeId: (field) => this.resolveFieldNodeId(field),
             markFieldStateDecorators: (field, fieldNodeId, result) => {
                 const kinds = stateDecoratorKinds(field);
                 if (kinds.length === 0)
@@ -1547,7 +2809,170 @@ class ArkTSAdapter {
         };
     }
     resolveClassNodeId(cls) {
-        return this.componentToId.get(cls) ?? this.classToId.get(cls) ?? null;
+        const live = this.componentToId.get(cls) ?? this.classToId.get(cls);
+        if (live)
+            return live;
+        try {
+            return this.classSigToId.get(cls.getSignature().toString()) ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    rememberClassName(name, nodeId, filePath, isComponent) {
+        if (!isUsableArkTypeName(name))
+            return;
+        let set = this.classNameToIds.get(name);
+        if (!set) {
+            set = new Set();
+            this.classNameToIds.set(name, set);
+        }
+        set.add(nodeId);
+        this.classIdFilePath.set(nodeId, filePath);
+        if (isComponent)
+            this.classIdIsComponent.set(nodeId, true);
+    }
+    rememberMethodName(className, methodName, nodeId, filePath) {
+        const key = `${className}::${methodName}`;
+        let set = this.methodNameKeyToIds.get(key);
+        if (!set) {
+            set = new Set();
+            this.methodNameKeyToIds.set(key, set);
+        }
+        set.add(nodeId);
+        this.methodIdFilePath.set(nodeId, filePath);
+    }
+    rememberFunctionName(functionName, nodeId, filePath) {
+        if (!isUsableArkTypeName(functionName) || !/^[a-z]/.test(functionName))
+            return;
+        let set = this.functionNameToIds.get(functionName);
+        if (!set) {
+            set = new Set();
+            this.functionNameToIds.set(functionName, set);
+        }
+        set.add(nodeId);
+        this.methodIdFilePath.set(nodeId, filePath);
+    }
+    resolveFunctionIdByName(functionName) {
+        const ids = this.functionNameToIds.get(functionName);
+        if (!ids || ids.size !== 1)
+            return null;
+        return [...ids][0] ?? null;
+    }
+    resolveClassIdByName(className, importer) {
+        const ids = this.classNameToIds.get(className);
+        if (!ids || ids.size === 0)
+            return null;
+        let candidates = [...ids];
+        // Same-file components (ForEach item builders, local @Component) have no import —
+        // prefer ids from the importer's file before treating the name as ambiguous.
+        if (importer) {
+            try {
+                const importerPath = normalizeRelPath(this.rootDir, importer.getDeclaringArkFile().getFilePath());
+                const sameFile = candidates.filter((id) => this.classIdFilePath.get(id) === importerPath);
+                if (sameFile.length > 0)
+                    candidates = sameFile;
+            }
+            catch {
+                // keep full candidate set
+            }
+        }
+        const preferred = pickPreferredClassNodeId(candidates, (id) => !!this.classIdIsComponent.get(id));
+        if (preferred)
+            return preferred;
+        if (!importer)
+            return null;
+        try {
+            const importInfo = importer.getDeclaringArkFile().getImportInfoBy(className);
+            if (!importInfo)
+                return null;
+            const exportInfo = importInfo.getLazyExportInfo?.() ?? null;
+            const arkExport = exportInfo?.getArkExport?.() ?? null;
+            if (arkExport instanceof arkanalyzer_1.ArkClass) {
+                const byLive = this.resolveClassNodeId(arkExport);
+                if (byLive)
+                    return byLive;
+            }
+            const from = importInfo.getFrom?.();
+            if (!from)
+                return null;
+            const fromBase = path.basename(from).replace(/\.(ets|ts|d\.ts)$/i, '');
+            const byPath = [...ids].filter((id) => {
+                const fp = this.classIdFilePath.get(id);
+                if (!fp)
+                    return false;
+                const norm = fp.replace(/\\/g, '/');
+                const fromNorm = from.replace(/\\/g, '/');
+                return (norm.includes(fromNorm) ||
+                    fromNorm.includes(norm) ||
+                    path.basename(norm, path.extname(norm)) === fromBase ||
+                    path.basename(norm, path.extname(norm)) === className);
+            });
+            return pickPreferredClassNodeId(byPath, (id) => !!this.classIdIsComponent.get(id));
+        }
+        catch {
+            return null;
+        }
+    }
+    resolveMethodIdByName(className, methodName) {
+        const key = `${className}::${methodName}`;
+        const ids = this.methodNameKeyToIds.get(key);
+        if (!ids || ids.size !== 1)
+            return null;
+        return [...ids][0] ?? null;
+    }
+    resolveClassIdBySig(sig, importer) {
+        try {
+            const exact = this.classSigToId.get(sig.toString());
+            if (exact)
+                return exact;
+        }
+        catch {
+            // fall through to name fallback when possible
+        }
+        // Name fallback for %unk stubs AND clear-but-unmapped sig strings (path drift).
+        // Same-file / import disambiguation happens inside resolveClassIdByName.
+        try {
+            const className = sig.getClassName();
+            return className ? this.resolveClassIdByName(className, importer) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    resolveMethodIdBySig(sig, _importer) {
+        try {
+            const exact = this.methodSigToId.get(sig.toString());
+            if (exact)
+                return exact;
+        }
+        catch {
+            // fall through
+        }
+        // Name fallback for %unk stubs AND path-drifted but clear signatures so
+        // RTA edges to signature-only / unloaded callees still map to indexed nodes.
+        try {
+            const className = sig.getDeclaringClassSignature().getClassName();
+            const methodName = sig.getMethodSubSignature().getMethodName();
+            if (!className || !methodName)
+                return null;
+            return this.resolveMethodIdByName(className, methodName);
+        }
+        catch {
+            return null;
+        }
+    }
+    resolveFieldNodeId(field) {
+        const live = this.fieldToId.get(field);
+        if (live)
+            return live;
+        try {
+            const classSig = field.getDeclaringArkClass().getSignature().toString();
+            return this.fieldSigToId.get(fieldSigKey(classSig, field.getName())) ?? null;
+        }
+        catch {
+            return null;
+        }
     }
     /** Parent node id for a method: owning class/component, or file for default-class methods. */
     resolveMethodParentId(method, relativePath, result) {
@@ -1570,6 +2995,16 @@ class ArkTSAdapter {
         const existing = this.methodToId.get(method);
         if (existing)
             return existing;
+        try {
+            const bySig = this.methodSigToId.get(method.getSignature().toString());
+            if (bySig) {
+                this.methodToId.set(method, bySig);
+                return bySig;
+            }
+        }
+        catch {
+            // fall through
+        }
         if (shouldSkipArkMethod(method) && !isAnonymousArkMethod(method))
             return null;
         const displayName = arkMethodDisplayName(method);
@@ -1594,6 +3029,10 @@ class ArkTSAdapter {
         return this.methodToId.get(method) ?? null;
     }
     addViewTreeEdge(result, source, target, kind, callerFile, via, line) {
+        const edgeKey = `${source}\0${target}\0${kind}\0${via}`;
+        if (this.emittedEdgeKeys.has(edgeKey))
+            return;
+        this.emittedEdgeKeys.add(edgeKey);
         const edge = arkEdge(source, target, kind, {
             metadata: {
                 synthesizedBy: 'viewtree',
@@ -1612,6 +3051,16 @@ class ArkTSAdapter {
         const existing = this.methodToId.get(method);
         if (existing)
             return existing;
+        try {
+            const bySig = this.methodSigToId.get(method.getSignature().toString());
+            if (bySig) {
+                this.methodToId.set(method, bySig);
+                return bySig;
+            }
+        }
+        catch {
+            // fall through
+        }
         if (shouldSkipArkMethod(method) && !isAnonymousArkMethod(method))
             return null;
         const displayName = arkMethodDisplayName(method);
@@ -1638,6 +3087,24 @@ class ArkTSAdapter {
         });
         this.addNode(result, methodNode);
         this.methodToId.set(method, methodNode.id);
+        try {
+            this.methodSigToId.set(method.getSignature().toString(), methodNode.id);
+        }
+        catch {
+            // signature unavailable
+        }
+        try {
+            const ownerName = classDisplayName(cls);
+            if (isUsableArkTypeName(ownerName) && isUsableArkTypeName(displayName)) {
+                this.rememberMethodName(ownerName, displayName, methodNode.id, relativePath);
+            }
+            else if (cls.isDefaultArkClass() && kind === 'function') {
+                this.rememberFunctionName(displayName, methodNode.id, relativePath);
+            }
+        }
+        catch {
+            // class name unavailable
+        }
         result.edges.push(arkEdge(parentId, methodNode.id, 'contains'));
         this.indexDecorators(result, methodNode.id, method, relativePath, language, line);
         this.indexNativeNapiCalls(method, methodNode.id, relativePath, language, result);
@@ -1714,10 +3181,11 @@ function drainArkTSIndexNotices() {
     arktsIndexNotices = [];
     return out;
 }
-function buildSceneConfig(rootDir) {
+function buildSceneConfig(rootDir, extra) {
     return (0, arkanalyzer_1.buildSceneConfigFromProject)(rootDir, process.env.OHOS_SDK_HOME, {
         supportFileExts: ['.ets', '.ts', '.d.ts'],
         enableMethodBodyBuild: true,
+        ...(extra?.memoryLimitMB !== undefined ? { memoryLimitMB: extra.memoryLimitMB } : {}),
     });
 }
 function tryBuildArkScene(rootDir) {
@@ -1742,22 +3210,158 @@ function emptyArkTSBatchIndex(errors) {
         errors,
     };
 }
-function buildArkTSIndex(rootDir, scannedFiles) {
-    const { scene, errors } = tryBuildArkScene(rootDir);
-    if (!scene) {
-        return emptyArkTSBatchIndex(errors);
-    }
+/**
+ * Harmony multi-module path: load each PROJECT module to BODIES, index into
+ * HomeGraph structures in the callback, let ArkAnalyzer evict under memoryLimitMB.
+ * When `targetModuleSrcPaths` is set, only those modules are BODIES targets
+ * (deps still load at SIGNATURES) — used for incremental sync.
+ *
+ * Runs with the #850 liveness watchdog suspended: ArkAnalyzer's native BODIES
+ * load between module callbacks routinely exceeds the 60s heartbeat window on
+ * large Harmony projects, and there is no JS yield point inside that span.
+ */
+function buildArkTSIndexByModule(rootDir, scannedFiles, options) {
+    return (0, liveness_watchdog_1.runWithoutLivenessWatchdog)(() => buildArkTSIndexByModuleInner(rootDir, scannedFiles, options));
+}
+function buildArkTSIndexByModuleInner(rootDir, scannedFiles, options) {
+    const errors = [];
+    const memoryLimitMB = resolveArkTSSceneMemoryLimitMB();
+    const sceneConfig = buildSceneConfig(rootDir, { memoryLimitMB });
+    const scene = new arkanalyzer_1.Scene();
+    const adapter = new ArkTSAdapter(rootDir, scannedFiles);
+    let modulesIndexed = 0;
+    const targetSrc = options?.targetModuleSrcPaths?.map(normalizeHarmonyModuleSrcPath);
+    const targetSrcSet = targetSrc && targetSrc.length > 0 ? new Set(targetSrc) : null;
     try {
-        const adapter = new ArkTSAdapter(rootDir, scannedFiles);
-        const index = adapter.build(scene);
-        index.errors.push(...errors);
+        scene.config(sceneConfig);
+        const config = new arkanalyzer_1.ModuleAnalysisConfig();
+        config.setLoadLevel(arkanalyzer_1.ModuleDepthLevel.BODIES);
+        // SIGNATURES is enough for ViewTree stubs / types; BODIES on deps caused
+        // each module's RTA to re-walk shared library CFGs (multi-hour indexes).
+        config.setDependencyLoadLevel(arkanalyzer_1.ModuleDepthLevel.SIGNATURES);
+        if (targetSrcSet) {
+            // Prep + SDK only (no PROJECT targets) so we can resolve ModuleIDs.
+            scene.analyseByModule(() => { }, new arkanalyzer_1.ModuleAnalysisConfig());
+            const wantAbs = new Set([...targetSrcSet].map((src) => {
+                const resolved = path.resolve(rootDir, src);
+                try {
+                    return fs.realpathSync(resolved).toLowerCase();
+                }
+                catch {
+                    return resolved.toLowerCase();
+                }
+            }));
+            const ids = [];
+            for (const mod of scene.getModules()) {
+                if (mod.getModuleType() !== arkanalyzer_1.ModuleType.PROJECT)
+                    continue;
+                let modAbs;
+                try {
+                    modAbs = fs.realpathSync(mod.getModulePath());
+                }
+                catch {
+                    modAbs = path.resolve(mod.getModulePath());
+                }
+                if (wantAbs.has(modAbs.toLowerCase())) {
+                    ids.push(scene.getModuleId(mod));
+                }
+            }
+            if (ids.length === 0) {
+                errors.push({
+                    message: `ArkTS incremental: no modules matched [${[...targetSrcSet].join(', ')}]`,
+                    severity: 'warning',
+                });
+                return emptyArkTSBatchIndex(errors);
+            }
+            config.setTargetModuleIds(ids);
+            process.stderr.write(`\n\x1b[33m    ArkTS: analyseByModule incremental (${ids.length} module(s)→BODIES, deps→SIGNATURES, memoryLimitMB=${memoryLimitMB})...\x1b[0m\n`);
+        }
+        else {
+            config.setIncludeType(arkanalyzer_1.ModuleType.PROJECT, true);
+            process.stderr.write(`\n\x1b[33m    ArkTS: analyseByModule (PROJECT→BODIES, deps→SIGNATURES, memoryLimitMB=${memoryLimitMB}, maxOldSpace=${(0, wasm_runtime_flags_1.resolveMaxOldSpaceSizeMb)()})...\x1b[0m\n`);
+        }
+        scene.analyseByModule((module, scn) => {
+            adapter.indexModule(module, scn);
+            modulesIndexed++;
+            const name = module.getModuleName() || path.basename(module.getModulePath());
+            process.stderr.write(`\x1b[33m    ArkTS: indexed module ${modulesIndexed}: ${name}\x1b[0m\n`);
+        }, config);
+        if (modulesIndexed === 0) {
+            errors.push({
+                message: 'ArkTS analyseByModule found no PROJECT modules (check build-profile.json5); falling back to full Scene build',
+                severity: 'warning',
+            });
+            return emptyArkTSBatchIndex(errors);
+        }
+        try {
+            adapter.finalizeCallGraph(scene);
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            errors.push({
+                message: `ArkTS modular leftover RTA skipped: ${message}`,
+                severity: 'warning',
+            });
+        }
+        const index = adapter.toBatchIndex(errors);
+        if (index.fileResults.size === 0) {
+            errors.push({
+                message: 'ArkTS analyseByModule indexed modules but no scanned source files matched',
+                severity: 'warning',
+            });
+            return emptyArkTSBatchIndex(errors);
+        }
         return index;
     }
     catch (e) {
         const message = e instanceof Error ? e.message : String(e);
-        errors.push({ message: `ArkTS adapter failed: ${message}`, severity: 'error' });
+        errors.push({
+            message: `ArkTS analyseByModule failed: ${message}; falling back to full Scene build`,
+            severity: 'warning',
+        });
         return emptyArkTSBatchIndex(errors);
     }
+    finally {
+        try {
+            scene.dispose();
+        }
+        catch {
+            // ignore dispose failures
+        }
+    }
+}
+function buildArkTSIndexFull(rootDir, scannedFiles, priorErrors = []) {
+    // Full Scene build is the same opaque native stall as analyseByModule.
+    return (0, liveness_watchdog_1.runWithoutLivenessWatchdog)(() => {
+        const { scene, errors } = tryBuildArkScene(rootDir);
+        const allErrors = [...priorErrors, ...errors];
+        if (!scene) {
+            return emptyArkTSBatchIndex(allErrors);
+        }
+        try {
+            const adapter = new ArkTSAdapter(rootDir, scannedFiles);
+            const index = adapter.build(scene);
+            index.errors.push(...allErrors);
+            return index;
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            allErrors.push({ message: `ArkTS adapter failed: ${message}`, severity: 'error' });
+            return emptyArkTSBatchIndex(allErrors);
+        }
+    });
+}
+function buildArkTSIndex(rootDir, scannedFiles) {
+    if (shouldUseModularArkTSBuild(rootDir)) {
+        const modular = buildArkTSIndexByModule(rootDir, scannedFiles);
+        const fatal = modular.errors.find((e) => e.severity === 'error');
+        if (modular.fileResults.size > 0 && !fatal) {
+            return modular;
+        }
+        // Warnings like "no PROJECT modules" / modular failure → full Scene fallback.
+        return buildArkTSIndexFull(rootDir, scannedFiles, modular.errors);
+    }
+    return buildArkTSIndexFull(rootDir, scannedFiles);
 }
 // =============================================================================
 // OHOS SDK input resolution + prebuilt API database indexing