homegraph 1.5.1 → 1.5.2

package/dist/extraction/languages/arkts.js

@@ -75,7 +75,9 @@ exports.scanEtsFiles = scanEtsFiles;
 exports.runIsolatedArkTSBatchEntry = runIsolatedArkTSBatchEntry;
 exports.primeArkTSBatch = primeArkTSBatch;
 exports.isArkTSBatchPersisted = isArkTSBatchPersisted;
+exports.isArkTSBatchCommitted = isArkTSBatchCommitted;
 exports.resetArkTSBatch = resetArkTSBatch;
+exports.shrinkArkTSBatchPostParse = shrinkArkTSBatchPostParse;
 exports.collectExportedRtaEntryPointsFromFiles = collectExportedRtaEntryPointsFromFiles;
 exports.stateDecoratorKinds = stateDecoratorKinds;
 exports.stateTransferViaForField = stateTransferViaForField;
@@ -99,7 +101,12 @@ exports.parseJson5Minimal = parseJson5Minimal;
 exports.normalizeOhosApiVersion = normalizeOhosApiVersion;
 exports.detectOhosCompileSdkVersion = detectOhosCompileSdkVersion;
 exports.isOhosArktsProject = isOhosArktsProject;
+exports.readOhosSdkPlatformVersion = readOhosSdkPlatformVersion;
+exports.discoverLocalOhosSdkCandidates = discoverLocalOhosSdkCandidates;
+exports.findLocalOhosSdkForVersion = findLocalOhosSdkForVersion;
+exports.resolveOhosApiVersionForProject = resolveOhosApiVersionForProject;
 exports.ensureOhosApiDb = ensureOhosApiDb;
+exports.attachExistingOhosApiDbForProject = attachExistingOhosApiDbForProject;
 exports.bindOhosApiDbForProject = bindOhosApiDbForProject;
 exports.restoreOhosApiDbAttach = restoreOhosApiDbAttach;
 const crypto = __importStar(require("crypto"));
@@ -647,6 +654,27 @@ function persistIncrementalModuleResults(rootDir, queries, index) {
         persistFileResult(queries, filePath, content, stats, fileResult, { force: true });
     }
 }
+/**
+ * Persist a module slice then drop it from the in-memory map (streaming modular build).
+ * Returns the number of files written.
+ */
+function persistAndDropModuleSlice(rootDir, queries, slice, streamedPersistedPaths, persistOrdinal) {
+    if (slice.size === 0)
+        return 0;
+    for (const [filePath, fileResult] of slice) {
+        persistOrdinal.done++;
+        reportBatchProgress('persist', Math.min(persistOrdinal.done, persistOrdinal.totalHint), persistOrdinal.totalHint, 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 });
+        streamedPersistedPaths.add(normIndexPath(filePath));
+    }
+    return slice.size;
+}
 async function persistBatchResultsAsync(rootDir, queries, index) {
     const entries = [...index.fileResults.entries()];
     const persistTotal = entries.length;
@@ -694,18 +722,89 @@ function persistBatchResultsSync(rootDir, queries, index) {
     }
 }
 function commitArkTSBatch(rootDir, batchKey, etsFiles, index, triggerFile) {
-    batchPersistedPaths = new Set([...index.fileResults.keys()].map(normIndexPath));
+    const streamed = index.streamedPersistedPaths;
+    batchPersistedPaths =
+        streamed && streamed.size > 0
+            ? new Set([...streamed].map(normIndexPath))
+            : new Set([...index.fileResults.keys()].map(normIndexPath));
     persistedBatch = { ...index, rootDir, batchKey, etsFiles };
     batchTriggerFile = normIndexPath(triggerFile);
-    if (index.fileResults.size > 0) {
+    if (batchPersistedPaths.size > 0 || index.fileResults.size > 0) {
         batchBuildCommitted = true;
     }
     return persistedBatch;
 }
+/**
+ * Drop in-memory ExtractionResults / edges after they are in SQLite.
+ * Keep path sets so `isArkTSBatchPersisted` still skips re-parse; matches the
+ * isolated-worker commit shape (empty fileResults).
+ */
+function releaseArkTSBatchHeavyPayload() {
+    if (!persistedBatch)
+        return;
+    persistedBatch.fileResults.clear();
+    persistedBatch.crossFileEdges = [];
+    persistedBatch.nodeIds.clear();
+    persistedBatch.errors = [];
+}
+/** Best-effort reclaim after Scene / batch teardown (needs `node --expose-gc`). */
+function tryForceGc() {
+    const gc = globalThis.gc;
+    if (typeof gc === 'function') {
+        try {
+            gc();
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+/**
+ * Unload every module's IR then dispose Scene globals. Plain `scene.dispose()`
+ * only clears SDK helpers / moduleCache — project ArkFiles stay reachable and
+ * pin multi-GB RSS into Parsing/Resolving.
+ */
+function releaseArkAnalyzerScene(scene) {
+    try {
+        for (const mod of scene.getModules()) {
+            try {
+                scene.disposeModule(mod);
+                mod.setFileDepGraph(undefined);
+                mod.clearFilesMap();
+                mod.setLoadState(arkanalyzer_1.ModuleLoadState.NOT_LOADED);
+            }
+            catch {
+                // per-module best-effort
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    try {
+        scene.dispose();
+    }
+    catch {
+        // ignore
+    }
+    tryForceGc();
+}
+/**
+ * ArkAnalyzer 1.0.92 keeps INDEX hollow on {@link ModuleBuilder} as a private
+ * method (public eviction paths call it internally). HomeGraph needs the same
+ * post-ingest hollow; call through a narrow cast until a public API exists.
+ */
+function hollowModuleToIndex(builder, moduleId) {
+    builder.downgradeModule(moduleId, arkanalyzer_1.ModuleDepthLevel.INDEX);
+}
 function tryReturnCachedBatch(rootDir, triggerFile, etsFiles) {
     const normalizedTrigger = normIndexPath(triggerFile);
+    // Only reuse when payload is still in memory. After
+    // releaseArkTSBatchHeavyPayload(), fileResults is empty — fall through to
+    // rebuild (same as isolated-worker commit) rather than return a hollow cache.
     if (persistedBatch &&
         persistedBatch.rootDir === rootDir &&
+        persistedBatch.fileResults.size > 0 &&
         batchPersistedPaths.has(normalizedTrigger)) {
         return persistedBatch;
     }
@@ -799,6 +898,8 @@ function runArkTSBatchFullCore(rootDir, queries, triggerFile, etsFiles, batchKey
                 queries.insertEdges(valid);
             }
         }
+        // Keep payload in memory for ArkTSExtractor.extract() same-batch hits.
+        // indexAll uses primeArkTSBatch → releaseArkTSBatchHeavyPayload after persist.
         return commitArkTSBatch(rootDir, batchKey, etsFiles, index, triggerFile);
     }
     finally {
@@ -850,6 +951,27 @@ function runArkTSBatch(rootDir, queries, triggerFile) {
     if (cached) {
         return cached;
     }
+    // indexAll releases the in-memory payload after SQLite persist. A later
+    // ArkTSExtractor hit must NOT rebuild the entire Scene (looks like a restart).
+    if (batchBuildCommitted &&
+        persistedBatch &&
+        persistedBatch.rootDir === rootDir &&
+        batchPersistedPaths.has(normalizedTrigger)) {
+        return {
+            fileResults: new Map(),
+            crossFileEdges: [],
+            nodeIds: new Set(),
+            errors: [
+                {
+                    message: 'ArkTS batch already persisted this run; in-memory payload released',
+                    severity: 'warning',
+                },
+            ],
+            rootDir,
+            batchKey: persistedBatch.batchKey,
+            etsFiles: persistedBatch.etsFiles,
+        };
+    }
     const batchKey = etsFiles.length > 0 ? computeBatchKey(rootDir, etsFiles) : '';
     return runArkTSBatchFull(rootDir, queries, normalizedTrigger, etsFiles, batchKey);
 }
@@ -892,13 +1014,25 @@ async function primeArkTSBatch(rootDir, queries, triggerFile, options) {
     (0, context_1.setArktsBatchRunning)(true);
     try {
         reportBatchProgress('scene', 0, etsFiles.length);
-        const index = buildArkTSIndex(rootDir, etsFiles);
-        if (index.fileResults.size === 0) {
+        const streamModular = shouldUseModularArkTSBuild(rootDir);
+        if (streamModular) {
+            // Clear stale cross-file RTA edges before streaming module persists.
+            queries.deleteArkTSCrossFileCallEdges();
+        }
+        const index = buildArkTSIndex(rootDir, etsFiles, {
+            streamQueries: streamModular ? queries : undefined,
+        });
+        const streamed = index.streamedPersistedPaths?.size ?? 0;
+        if (index.fileResults.size === 0 && streamed === 0) {
             const fatal = index.errors.find((e) => e.severity === 'error');
             throw new Error(fatal?.message ?? 'ArkTS batch produced no indexed files');
         }
-        queries.deleteArkTSCrossFileCallEdges();
-        await persistBatchResultsAsync(rootDir, queries, index);
+        if (!streamModular) {
+            queries.deleteArkTSCrossFileCallEdges();
+        }
+        if (index.fileResults.size > 0) {
+            await persistBatchResultsAsync(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) {
@@ -906,6 +1040,8 @@ async function primeArkTSBatch(rootDir, queries, triggerFile, options) {
             }
         }
         commitArkTSBatch(rootDir, batchKey, etsFiles, index, normalizedTrigger);
+        releaseArkTSBatchHeavyPayload();
+        tryForceGc();
     }
     finally {
         (0, context_1.setArktsBatchRunning)(false);
@@ -923,8 +1059,13 @@ async function runArkTSBatchIncrementalModules(rootDir, queries, triggerFile, et
     (0, context_1.setArktsBatchRunning)(true);
     try {
         reportBatchProgress('scene', 0, etsFiles.length);
-        const index = buildArkTSIndexByModule(rootDir, etsFiles, { targetModuleSrcPaths: moduleSrcPaths });
-        if (index.fileResults.size === 0) {
+        queries.deleteArkTSCrossFileCallEdges();
+        const index = buildArkTSIndexByModule(rootDir, etsFiles, {
+            targetModuleSrcPaths: moduleSrcPaths,
+            streamQueries: queries,
+        });
+        const streamed = index.streamedPersistedPaths?.size ?? 0;
+        if (index.fileResults.size === 0 && streamed === 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) : '';
@@ -932,20 +1073,26 @@ async function runArkTSBatchIncrementalModules(rootDir, queries, triggerFile, et
                 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) {
+            if (full.fileResults.size === 0 && (full.streamedPersistedPaths?.size ?? 0) === 0) {
                 throw new Error(fatal?.message ?? 'ArkTS incremental batch produced no indexed files');
             }
             queries.deleteArkTSCrossFileCallEdges();
-            await persistBatchResultsAsync(rootDir, queries, full);
+            if (full.fileResults.size > 0) {
+                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);
+            releaseArkTSBatchHeavyPayload();
+            tryForceGc();
             return;
         }
-        persistIncrementalModuleResults(rootDir, queries, index);
+        if (index.fileResults.size > 0) {
+            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) {
@@ -955,6 +1102,8 @@ async function runArkTSBatchIncrementalModules(rootDir, queries, triggerFile, et
         // 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);
+        releaseArkTSBatchHeavyPayload();
+        tryForceGc();
         process.stderr.write(`\n\x1b[33m    ArkTS: incremental module reindex done (${moduleSrcPaths.join(', ')})\x1b[0m\n`);
     }
     finally {
@@ -965,6 +1114,10 @@ async function runArkTSBatchIncrementalModules(rootDir, queries, triggerFile, et
 function isArkTSBatchPersisted(filePath) {
     return batchPersistedPaths.has(normIndexPath(filePath));
 }
+/** True after a successful ArkTS batch was committed to SQLite this index run. */
+function isArkTSBatchCommitted() {
+    return batchBuildCommitted;
+}
 /** Clear cached batch state (tests and full re-index). */
 function resetArkTSBatch() {
     persistedBatch = null;
@@ -973,6 +1126,16 @@ function resetArkTSBatch() {
     batchBuildCommitted = false;
     arktsIndexNotices = [];
 }
+/**
+ * After parse workers no longer need skip-path metadata beyond
+ * `batchPersistedPaths`, drop the heavy path-list / batchKey strings.
+ */
+function shrinkArkTSBatchPostParse() {
+    if (!persistedBatch)
+        return;
+    persistedBatch.etsFiles = [];
+    persistedBatch.batchKey = '';
+}
 class ArkTSExtractor {
     filePath;
     constructor(filePath, _source) {
@@ -2028,6 +2191,9 @@ class ArkTSAdapter {
         this.stitchModuleCfgCallsAndRefs(files, moduleFiles);
         // Drop live IR object keys so ArkAnalyzer can GC unloaded modules; keep sig→id maps.
         this.releaseLiveIrMaps();
+        // Edges for this module are already in fileResults / crossFileEdges — drop
+        // the string dedupe set so it does not grow across the whole project.
+        this.emittedEdgeKeys.clear();
     }
     /**
      * Index symbols from already-loaded non-target modules into sig/name maps only.
@@ -2466,6 +2632,30 @@ class ArkTSAdapter {
             errors: [...errors],
         };
     }
+    /**
+     * Remove and return ExtractionResults for the given paths so callers can
+     * persist+GC mid-Scene (streaming modular build). Keeps sig→id maps / nodeIds.
+     */
+    takeFileResults(paths) {
+        const out = new Map();
+        for (const raw of paths) {
+            const p = normIndexPath(raw);
+            const result = this.fileResults.get(p);
+            if (!result)
+                continue;
+            out.set(p, result);
+            this.fileResults.delete(p);
+        }
+        return out;
+    }
+    /** Re-insert a previously taken file result (stream persist failure recovery). */
+    putFileResult(filePath, result) {
+        this.fileResults.set(normIndexPath(filePath), result);
+    }
+    /** All paths currently held in fileResults (for final flush). */
+    fileResultPaths() {
+        return [...this.fileResults.keys()];
+    }
     indexScannedFile(arkFile) {
         const relativePath = normalizeRelPath(this.rootDir, arkFile.getFilePath());
         if (!this.scanned.has(relativePath))
@@ -3219,6 +3409,8 @@ function emptyArkTSBatchIndex(errors) {
  * 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.
+ * When `streamQueries` is set, each module's ExtractionResults are written to
+ * SQLite immediately and dropped from RAM (cross-file call edges stay until end).
  */
 function buildArkTSIndexByModule(rootDir, scannedFiles, options) {
     return (0, liveness_watchdog_1.runWithoutLivenessWatchdog)(() => buildArkTSIndexByModuleInner(rootDir, scannedFiles, options));
@@ -3232,6 +3424,13 @@ function buildArkTSIndexByModuleInner(rootDir, scannedFiles, options) {
     let modulesIndexed = 0;
     const targetSrc = options?.targetModuleSrcPaths?.map(normalizeHarmonyModuleSrcPath);
     const targetSrcSet = targetSrc && targetSrc.length > 0 ? new Set(targetSrc) : null;
+    const streamQueries = options?.streamQueries;
+    const streamedPersistedPaths = new Set();
+    const scannedList = [...scannedFiles].map(normIndexPath);
+    const persistOrdinal = {
+        done: 0,
+        totalHint: Math.max(1, scannedList.filter((f) => isArkAnalyzerSourcePath(f)).length),
+    };
     try {
         scene.config(sceneConfig);
         const config = new arkanalyzer_1.ModuleAnalysisConfig();
@@ -3274,18 +3473,83 @@ function buildArkTSIndexByModuleInner(rootDir, scannedFiles, options) {
                 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`);
+            process.stderr.write(`\n\x1b[33m    ArkTS: analyseByModule incremental (${ids.length} module(s)→BODIES, deps→SIGNATURES, memoryLimitMB=${memoryLimitMB}${streamQueries ? ', streamPersist' : ''})...\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`);
+            process.stderr.write(`\n\x1b[33m    ArkTS: analyseByModule (PROJECT→BODIES, deps→SIGNATURES, memoryLimitMB=${memoryLimitMB}, maxOldSpace=${(0, wasm_runtime_flags_1.resolveMaxOldSpaceSizeMb)()}${streamQueries ? ', streamPersist' : ''})...\x1b[0m\n`);
         }
         scene.analyseByModule((module, scn) => {
+            const moduleFileRels = [...module.getFilesMap().values()]
+                .map((f) => normalizeRelPath(rootDir, f.getFilePath()))
+                .filter((p) => p && isArkAnalyzerSourcePath(p))
+                .map(normIndexPath);
             adapter.indexModule(module, scn);
+            // HomeGraph already captured this module's symbols/edges. Hollow every
+            // currently-loaded module still above INDEX (target + oh_modules /
+            // SIGNATURES deps left in ModuleCache). Topo order means PROJECT deps of
+            // the current target are often already INDEX from their own callback, so
+            // BFS-from-self alone left depHollowed=0; sweeping the cache catches the
+            // fat non-target SIGNATURES that memoryLimitMB rarely evicts under a large
+            // soft budget. INDEX keeps export-reachable shells; loadModule upgrades
+            // when a later target needs SIGNATURES/BODIES.
+            let depHollowed = 0;
+            try {
+                const builder = new arkanalyzer_1.ModuleBuilder(scn);
+                const selfId = scn.getModuleId(module);
+                hollowModuleToIndex(builder, selfId);
+                const cache = scn.getModuleCache();
+                if (cache) {
+                    for (const modId of cache.getLoadedModules()) {
+                        if (modId === selfId)
+                            continue;
+                        const depMod = builder.getModule(modId);
+                        if (!depMod || depMod.getLoadState() <= arkanalyzer_1.ModuleLoadState.INDEX)
+                            continue;
+                        hollowModuleToIndex(builder, modId);
+                        depHollowed++;
+                    }
+                }
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                errors.push({
+                    message: `ArkTS post-index INDEX hollow failed for ${module.getModuleName() || module.getModulePath()}: ${message}`,
+                    severity: 'warning',
+                });
+            }
+            if (streamQueries) {
+                // Persist this module's file bodies now; keep @dummyFile until finalize.
+                const slicePaths = moduleFileRels.filter((p) => p !== ARKANALYZER_DUMMY_FILE);
+                const slice = adapter.takeFileResults(slicePaths);
+                try {
+                    persistAndDropModuleSlice(rootDir, streamQueries, slice, streamedPersistedPaths, persistOrdinal);
+                }
+                catch (e) {
+                    const message = e instanceof Error ? e.message : String(e);
+                    errors.push({
+                        message: `ArkTS stream persist failed for ${module.getModuleName() || module.getModulePath()}: ${message}`,
+                        severity: 'error',
+                    });
+                    throw e;
+                }
+            }
             modulesIndexed++;
             const name = module.getModuleName() || path.basename(module.getModulePath());
-            process.stderr.write(`\x1b[33m    ArkTS: indexed module ${modulesIndexed}: ${name}\x1b[0m\n`);
+            const st = arkanalyzer_1.ModuleLoadState[module.getLoadState()] ?? String(module.getLoadState());
+            const depNote = depHollowed > 0 ? `, hollowed ${depHollowed} deps` : '';
+            process.stderr.write(`\x1b[33m    ArkTS: indexed module ${modulesIndexed}: ${name} → ${st}${depNote}${streamQueries ? ` (streamed ${moduleFileRels.length} files)` : ''}\x1b[0m\n`);
         }, config);
+        if (process.env.HOMEGRAPH_ARKTS_DIAG === '1') {
+            const sceneDiag = scene;
+            const ev = typeof sceneDiag.getModuleEvictionStats === 'function'
+                ? sceneDiag.getModuleEvictionStats()
+                : null;
+            const mu = process.memoryUsage();
+            const cacheN = scene.getModuleCache()?.size?.() ?? scene.getModuleCache()?.getLoadedModules?.()?.length ?? -1;
+            process.stderr.write(`\x1b[36m    ArkTS DIAG eviction: ${JSON.stringify(ev)} cacheLoaded=${cacheN} ` +
+                `heapUsedMB=${(mu.heapUsed / 1024 / 1024).toFixed(1)} rssMB=${(mu.rss / 1024 / 1024).toFixed(1)}\x1b[0m\n`);
+        }
         if (modulesIndexed === 0) {
             errors.push({
                 message: 'ArkTS analyseByModule found no PROJECT modules (check build-profile.json5); falling back to full Scene build',
@@ -3303,8 +3567,15 @@ function buildArkTSIndexByModuleInner(rootDir, scannedFiles, options) {
                 severity: 'warning',
             });
         }
+        if (streamQueries) {
+            const leftover = adapter.takeFileResults(adapter.fileResultPaths());
+            persistAndDropModuleSlice(rootDir, streamQueries, leftover, streamedPersistedPaths, persistOrdinal);
+        }
         const index = adapter.toBatchIndex(errors);
-        if (index.fileResults.size === 0) {
+        if (streamQueries) {
+            index.streamedPersistedPaths = streamedPersistedPaths;
+        }
+        if (index.fileResults.size === 0 && streamedPersistedPaths.size === 0) {
             errors.push({
                 message: 'ArkTS analyseByModule indexed modules but no scanned source files matched',
                 severity: 'warning',
@@ -3323,7 +3594,7 @@ function buildArkTSIndexByModuleInner(rootDir, scannedFiles, options) {
     }
     finally {
         try {
-            scene.dispose();
+            releaseArkAnalyzerScene(scene);
         }
         catch {
             // ignore dispose failures
@@ -3349,13 +3620,26 @@ function buildArkTSIndexFull(rootDir, scannedFiles, priorErrors = []) {
             allErrors.push({ message: `ArkTS adapter failed: ${message}`, severity: 'error' });
             return emptyArkTSBatchIndex(allErrors);
         }
+        finally {
+            try {
+                releaseArkAnalyzerScene(scene);
+            }
+            catch {
+                // ignore
+            }
+        }
     });
 }
-function buildArkTSIndex(rootDir, scannedFiles) {
+function buildArkTSIndex(rootDir, scannedFiles, options) {
     if (shouldUseModularArkTSBuild(rootDir)) {
-        const modular = buildArkTSIndexByModule(rootDir, scannedFiles);
+        const modular = buildArkTSIndexByModule(rootDir, scannedFiles, {
+            streamQueries: options?.streamQueries,
+        });
         const fatal = modular.errors.find((e) => e.severity === 'error');
-        if (modular.fileResults.size > 0 && !fatal) {
+        const hasOutput = modular.fileResults.size > 0 ||
+            (modular.streamedPersistedPaths?.size ?? 0) > 0 ||
+            modular.nodeIds.size > 0;
+        if (hasOutput && !fatal) {
             return modular;
         }
         // Warnings like "no PROJECT modules" / modular failure → full Scene fallback.
@@ -3520,7 +3804,7 @@ function extractOhosSdkArchive(archivePath) {
 function ohosApiDbFilename(version) {
     return `ohos-api-${version}.db`;
 }
-/** npm package name — one package per API version (e.g. homegraph-ohos-api-db-6.0.1). */
+/** Metadata / publish id — one package per API version (e.g. homegraph-ohos-api-db-6.0.1). */
 function ohosApiDbPackageName(version) {
     return `homegraph-ohos-api-db-${version}`;
 }
@@ -3668,7 +3952,7 @@ async function indexOhosApiDb(options) {
     }
 }
 // =============================================================================
-// OHOS API db consumer: compileSdkVersion detect, npm fetch, ATTACH for queries
+// OHOS API db consumer: compileSdkVersion detect, local SDK build, ATTACH
 // =============================================================================
 exports.OHOS_API_FILE_PREFIX = 'ohos-sdk:';
 exports.OHOS_API_VERSION_META = 'ohos_api_version';
@@ -3810,75 +4094,291 @@ function hasEtsUnder(dir, depth) {
     }
     return false;
 }
-/** Install npm package if local db is missing; non-throwing on failure. */
-function ensureOhosApiDb(version) {
-    const dbPath = ohosApiDbInstallPath(version);
-    if (fs.existsSync(dbPath)) {
-        return {
-            version,
-            dbPath,
-            packageName: ohosApiDbPackageName(version),
-            installed: false,
-        };
+/** Read platformVersion from sdk-pkg.json / oh-uni-package.json under an SDK home. */
+function readOhosSdkPlatformVersion(sdkHome) {
+    const pkgPaths = [
+        path.join(sdkHome, 'sdk-pkg.json'),
+        path.join(sdkHome, 'openharmony', 'ets', 'oh-uni-package.json'),
+        path.join(sdkHome, 'openharmony', 'oh-uni-package.json'),
+    ];
+    for (const pkgPath of pkgPaths) {
+        if (!fs.existsSync(pkgPath))
+            continue;
+        try {
+            const raw = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            const data = raw.data && typeof raw.data === 'object'
+                ? raw.data
+                : raw;
+            const v = normalizeOhosApiVersion(data.platformVersion) ||
+                normalizeOhosApiVersion(data.version) ||
+                normalizeOhosApiVersion(raw.platformVersion) ||
+                normalizeOhosApiVersion(raw.version);
+            if (v)
+                return v;
+        }
+        catch {
+            /* try next */
+        }
     }
-    const packageName = ohosApiDbPackageName(version);
-    const installDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hg-ohos-npm-'));
+    return normalizeOhosApiVersion(path.basename(sdkHome));
+}
+/** Expand a user/env path into concrete sdk/default-style homes that contain openharmony/ets. */
+function expandLocalOhosSdkHomes(input) {
+    const resolved = path.resolve(input);
+    if (!fs.existsSync(resolved))
+        return [];
+    const homes = [];
+    const push = (p) => {
+        if (hasOpenHarmonyEts(p))
+            homes.push(p);
+    };
+    push(resolved);
+    push(path.join(resolved, 'default'));
+    push(path.join(resolved, 'sdk', 'default'));
+    const viaFind = findOhosSdkHome(resolved);
+    if (viaFind)
+        homes.push(viaFind);
+    let entries;
     try {
-        (0, child_process_1.execFileSync)('npm', ['install', '--no-save', packageName], {
-            cwd: installDir,
-            stdio: 'pipe',
-            timeout: 180_000,
-            env: { ...process.env, npm_config_loglevel: 'error' },
-        });
+        entries = fs.readdirSync(resolved, { withFileTypes: true });
+    }
+    catch {
+        return [...new Set(homes)];
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name === 'node_modules' || entry.name === '.git')
+            continue;
+        const child = path.join(resolved, entry.name);
+        push(child);
+        push(path.join(child, 'default'));
+    }
+    return [...new Set(homes)];
+}
+function localOhosSdkSearchRoots() {
+    const roots = [];
+    for (const key of ['HOMEGRAPH_OHOS_SDK', 'OHOS_SDK_HOME', 'DEVECO_SDK_HOME', 'HOS_SDK_HOME']) {
+        const v = process.env[key]?.trim();
+        if (v)
+            roots.push(v);
+    }
+    const home = os.homedir();
+    if (process.platform === 'win32') {
+        const lad = process.env.LOCALAPPDATA;
+        if (lad) {
+            roots.push(path.join(lad, 'OpenHarmony', 'Sdk'));
+            roots.push(path.join(lad, 'Huawei', 'Sdk'));
+        }
+        roots.push(path.join('C:\\', 'Program Files', 'Huawei', 'DevEco Studio', 'sdk'));
+        roots.push(path.join(home, 'Huawei', 'Sdk'));
+        roots.push(path.join(home, 'OpenHarmony', 'Sdk'));
+    }
+    else if (process.platform === 'darwin') {
+        roots.push(path.join(home, 'Library', 'Huawei', 'Sdk'));
+        roots.push(path.join(home, 'Library', 'OpenHarmony', 'Sdk'));
+        roots.push('/Applications/DevEco-Studio.app/Contents/sdk');
+    }
+    else {
+        roots.push(path.join(home, 'Huawei', 'Sdk'));
+        roots.push(path.join(home, 'OpenHarmony', 'Sdk'));
+    }
+    return roots;
+}
+/** Discover local DevEco / OpenHarmony SDK homes (env vars + common install paths). */
+function discoverLocalOhosSdkCandidates() {
+    const out = [];
+    const seen = new Set();
+    for (const root of localOhosSdkSearchRoots()) {
+        for (const sdkHome of expandLocalOhosSdkHomes(root)) {
+            if (seen.has(sdkHome))
+                continue;
+            seen.add(sdkHome);
+            out.push({ sdkHome, version: readOhosSdkPlatformVersion(sdkHome) });
+        }
+    }
+    return out;
+}
+/**
+ * Pick a local SDK home.
+ * When `preferredVersion` is set, require an exact platformVersion match.
+ * When unset, return the first candidate that has a readable version (else any).
+ */
+function findLocalOhosSdkForVersion(preferredVersion) {
+    const candidates = discoverLocalOhosSdkCandidates();
+    if (candidates.length === 0)
+        return null;
+    if (preferredVersion) {
+        return candidates.find((c) => c.version === preferredVersion) ?? null;
+    }
+    return candidates.find((c) => c.version) ?? candidates[0];
+}
+/**
+ * Resolve the API db version for a project: build-profile / env first, else local SDK.
+ */
+function resolveOhosApiVersionForProject(projectRoot) {
+    const fromProject = detectOhosCompileSdkVersion(projectRoot);
+    if (fromProject)
+        return fromProject;
+    return findLocalOhosSdkForVersion(null)?.version ?? null;
+}
+function attachOhosApiDbBinding(queries, binding) {
+    try {
+        queries.attachOhosApiDb(binding.dbPath);
+        queries.setMetadata(exports.OHOS_API_VERSION_META, binding.version);
+        queries.setMetadata(exports.OHOS_API_DB_PATH_META, binding.dbPath);
+        return binding;
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         return {
-            code: 'ohos_api_install_failed',
-            message: `Could not fetch ${packageName} (${msg}). ` +
-                'Explore will use project code only until the matching API db is available.',
+            code: 'ohos_api_db_missing',
+            message: `Failed to attach OHOS API db at ${binding.dbPath}: ${msg}`,
         };
     }
-    finally {
-        fs.rmSync(installDir, { recursive: true, force: true });
+}
+/**
+ * Build (or reuse) ~/.homegraph/api/ohos-api-<version>.db from a local SDK.
+ * Never throws — missing SDK / build failure returns a warning.
+ */
+async function ensureOhosApiDb(version, options = {}) {
+    const dbPath = ohosApiDbInstallPath(version);
+    const packageName = ohosApiDbPackageName(version);
+    if (fs.existsSync(dbPath)) {
+        return { version, dbPath, packageName, installed: false };
     }
-    if (!fs.existsSync(dbPath)) {
+    if (options.build === false || process.env.HOMEGRAPH_OHOS_API_SKIP === '1') {
         return {
             code: 'ohos_api_db_missing',
-            message: `${packageName} was fetched but ${ohosApiDbFilename(version)} is missing under ~/.homegraph/api/. ` +
+            message: `${ohosApiDbFilename(version)} is not under ~/.homegraph/api/ yet. ` +
+                'Re-run `homegraph init -i` / `homegraph index` with a local OHOS SDK, or `homegraph index-api <sdk>`. ' +
                 'Explore will use project code only.',
         };
     }
-    return { version, dbPath, packageName, installed: true };
+    let sdkHome = null;
+    if (options.sdkHomeHint) {
+        const hintHomes = expandLocalOhosSdkHomes(options.sdkHomeHint);
+        const match = hintHomes.find((h) => readOhosSdkPlatformVersion(h) === version) ?? hintHomes[0];
+        if (match && hasOpenHarmonyEts(match))
+            sdkHome = match;
+    }
+    if (!sdkHome) {
+        sdkHome = findLocalOhosSdkForVersion(version)?.sdkHome ?? null;
+    }
+    if (!sdkHome) {
+        return {
+            code: 'ohos_api_sdk_missing',
+            message: `Local OHOS SDK for API ${version} not found (set OHOS_SDK_HOME / DEVECO_SDK_HOME / HOMEGRAPH_OHOS_SDK, ` +
+                'or install the matching DevEco SDK). SDK API lookup disabled; project indexing continues normally.',
+        };
+    }
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    options.onProgress?.({
+        phase: 'ohos-api',
+        current: 0,
+        total: 1,
+        currentFile: version,
+    });
+    try {
+        const result = await indexOhosApiDb({
+            sdkHome,
+            version,
+            outputPath: dbPath,
+            onProgress: options.onProgress
+                ? (progress) => {
+                    options.onProgress?.({
+                        phase: 'ohos-api',
+                        current: progress.current,
+                        total: progress.total || 1,
+                        currentFile: progress.currentFile
+                            ? `${version} ${path.basename(progress.currentFile)}`
+                            : version,
+                        subphase: progress.subphase,
+                    });
+                }
+                : undefined,
+        });
+        if (!result.success || !fs.existsSync(dbPath)) {
+            try {
+                fs.unlinkSync(dbPath);
+            }
+            catch {
+                /* ignore */
+            }
+            const detail = result.errors
+                .filter((e) => e.severity === 'error')
+                .map((e) => e.message)
+                .join('; ');
+            return {
+                code: 'ohos_api_build_failed',
+                message: `Failed to build OHOS API db for ${version} from ${sdkHome}` +
+                    (detail ? ` (${detail})` : '') +
+                    '. SDK API lookup disabled; project indexing continues normally.',
+            };
+        }
+        options.onProgress?.({
+            phase: 'ohos-api',
+            current: 1,
+            total: 1,
+            currentFile: version,
+        });
+        return { version, dbPath, packageName, installed: true };
+    }
+    catch (err) {
+        try {
+            if (fs.existsSync(dbPath))
+                fs.unlinkSync(dbPath);
+        }
+        catch {
+            /* ignore */
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            code: 'ohos_api_build_failed',
+            message: `Failed to build OHOS API db for ${version} from ${sdkHome} (${msg}). ` +
+                'SDK API lookup disabled; project indexing continues normally.',
+        };
+    }
+}
+/**
+ * Attach a prebuilt API db if present — never builds. Used on open / wireLayers.
+ */
+function attachExistingOhosApiDbForProject(projectRoot, queries, languages) {
+    if (!isOhosArktsProject(projectRoot, languages))
+        return null;
+    const version = resolveOhosApiVersionForProject(projectRoot);
+    if (!version)
+        return null;
+    const dbPath = ohosApiDbInstallPath(version);
+    if (!fs.existsSync(dbPath))
+        return null;
+    return attachOhosApiDbBinding(queries, {
+        version,
+        dbPath,
+        packageName: ohosApiDbPackageName(version),
+        installed: false,
+    });
 }
-/** Detect version, ensure db, persist metadata, ATTACH — never throws. */
-function bindOhosApiDbForProject(projectRoot, queries, languages) {
+/**
+ * Detect version, build from local SDK when needed, persist metadata, ATTACH — never throws.
+ * Pass `{ build: true }` (default) after init/index; `{ build: false }` on open.
+ */
+async function bindOhosApiDbForProject(projectRoot, queries, languages, options = {}) {
     if (!isOhosArktsProject(projectRoot, languages))
         return null;
-    const version = detectOhosCompileSdkVersion(projectRoot);
+    const version = resolveOhosApiVersionForProject(projectRoot);
     if (!version) {
         return {
             code: 'ohos_api_version_unknown',
-            message: 'HarmonyOS project detected but compileSdkVersion not found in build-profile.json5. ' +
+            message: 'HarmonyOS project detected but compileSdkVersion was not found in build-profile.json5 ' +
+                'and no local OHOS SDK was discovered (set OHOS_SDK_HOME / DEVECO_SDK_HOME). ' +
                 'SDK API lookup disabled; project indexing continues normally.',
         };
     }
-    const ensured = ensureOhosApiDb(version);
+    const ensured = await ensureOhosApiDb(version, options);
     if ('code' in ensured)
         return ensured;
-    try {
-        queries.attachOhosApiDb(ensured.dbPath);
-        queries.setMetadata(exports.OHOS_API_VERSION_META, ensured.version);
-        queries.setMetadata(exports.OHOS_API_DB_PATH_META, ensured.dbPath);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return {
-            code: 'ohos_api_db_missing',
-            message: `Failed to attach OHOS API db at ${ensured.dbPath}: ${msg}`,
-        };
-    }
-    return ensured;
+    return attachOhosApiDbBinding(queries, ensured);
 }
 /** Re-ATTACH from project metadata after reopen / new QueryBuilder. */
 function restoreOhosApiDbAttach(queries) {