homegraph 1.5.1 → 1.5.3

package/dist/extraction/languages/arkts.js

@@ -75,9 +75,13 @@ 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.fieldDecoratorEntries = fieldDecoratorEntries;
+exports.fieldDecoratorsEncoded = fieldDecoratorsEncoded;
 exports.stateTransferViaForField = stateTransferViaForField;
 exports.isUnclearArkClassSignature = isUnclearArkClassSignature;
 exports.isUnclearArkMethodSignature = isUnclearArkMethodSignature;
@@ -99,7 +103,13 @@ 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.tryDownloadOhosApiDbFromNpm = tryDownloadOhosApiDbFromNpm;
 exports.ensureOhosApiDb = ensureOhosApiDb;
+exports.attachExistingOhosApiDbForProject = attachExistingOhosApiDbForProject;
 exports.bindOhosApiDbForProject = bindOhosApiDbForProject;
 exports.restoreOhosApiDbAttach = restoreOhosApiDbAttach;
 const crypto = __importStar(require("crypto"));
@@ -115,9 +125,12 @@ 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 generated_detection_1 = require("../generated-detection");
 const extraction_version_1 = require("../extraction-version");
 const version_1 = require("../../mcp/version");
 const liveness_watchdog_1 = require("../../mcp/liveness-watchdog");
+const migrate_semantics_1 = require("../../arkui/migrate-semantics");
+const migrate_passage_1 = require("../../arkui/migrate-passage");
 const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
 const wasm_runtime_flags_1 = require("../wasm-runtime-flags");
 const ignore_1 = __importDefault(require("ignore"));
@@ -473,11 +486,16 @@ function hasHarmonyProjectMarkers(rootDir) {
 function normIndexPath(filePath) {
     return filePath.replace(/\\/g, '/');
 }
-/** Member calls through a native `.so` binding: `sdk.Asset_setCropRect(`. */
+/** Photos-style member calls: `sdk.Asset_setCropRect(`. */
 const NAPI_MEMBER_CALL_RE = /\.\s*([A-Z][A-Za-z0-9_]*(?:_[A-Za-z0-9_]+)+)\s*\(/g;
+/** `libFoo.so` module path from ArkAnalyzer import infos. */
+const LIB_SO_MODULE_RE = /^lib[A-Za-z0-9_]+\.so$/;
 function isNapiSymbolName(name) {
     return /^[A-Z][A-Za-z0-9_]*_[A-Za-z0-9_]+$/.test(name);
 }
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 let persistedBatch = null;
 /** File that triggered the most recent batch persist (for indexAll edge stats). */
 let batchTriggerFile = null;
@@ -628,6 +646,7 @@ function persistFileResult(queries, filePath, content, stats, result, options) {
         indexedAt: Date.now(),
         nodeCount: result.nodes.length,
         errors: result.errors.length > 0 ? result.errors : undefined,
+        generated: (0, generated_detection_1.detectGeneratedFile)(filePath, content),
     };
     queries.upsertFile(fileRecord);
 }
@@ -647,6 +666,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 +734,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;
     }
@@ -789,7 +900,9 @@ function runArkTSBatchFullCore(rootDir, queries, triggerFile, etsFiles, batchKey
         const index = buildArkTSIndex(rootDir, etsFiles);
         if (index.fileResults.size === 0) {
             const fatal = index.errors.find((e) => e.severity === 'error');
-            throw new Error(fatal?.message ?? 'ArkTS batch produced no indexed files');
+            const detail = index.errors.map((e) => `[${e.severity}] ${e.message}`).join(' | ');
+            throw new Error(fatal?.message ??
+                `ArkTS batch produced no indexed files${detail ? ` (${detail})` : ' (no Scene/adapter errors recorded)'}`);
         }
         queries.deleteArkTSCrossFileCallEdges();
         persistBatchResultsSync(rootDir, queries, index);
@@ -799,6 +912,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 +965,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 +1028,27 @@ 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');
+            const detail = index.errors.map((e) => `[${e.severity}] ${e.message}`).join(' | ');
+            throw new Error(fatal?.message ??
+                `ArkTS batch produced no indexed files${detail ? ` (${detail})` : ' (no Scene/adapter errors recorded)'}`);
+        }
+        if (!streamModular) {
+            queries.deleteArkTSCrossFileCallEdges();
+        }
+        if (index.fileResults.size > 0) {
+            await persistBatchResultsAsync(rootDir, queries, index);
         }
-        queries.deleteArkTSCrossFileCallEdges();
-        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 +1056,8 @@ async function primeArkTSBatch(rootDir, queries, triggerFile, options) {
             }
         }
         commitArkTSBatch(rootDir, batchKey, etsFiles, index, normalizedTrigger);
+        releaseArkTSBatchHeavyPayload();
+        tryForceGc();
     }
     finally {
         (0, context_1.setArktsBatchRunning)(false);
@@ -923,8 +1075,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 +1089,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 +1118,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 +1130,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 +1142,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) {
@@ -1035,8 +1214,33 @@ const FIELD_CATEGORY = {
 };
 /** {@link ModifierType.CONST} — not re-exported from the arkanalyzer npm entry. */
 const MODIFIER_CONST = 128;
+/**
+ * Project-relative path for an ArkAnalyzer absolute file path.
+ *
+ * ArkAnalyzer returns realpath'd absolutes (macOS: `/private/var/...`), while
+ * HomeGraph's `rootDir` from `mkdtemp` / callers is often the unresolved form
+ * (`/var/...`). Without canonicalizing both sides, `path.relative` escapes the
+ * project (`../../../../private/var/.../file.ets`) and every file is skipped
+ * by the `scanned` set → empty batch / "no indexed files".
+ */
 function normalizeRelPath(rootDir, absolutePath) {
-    return path.relative(rootDir, absolutePath).replace(/\\/g, '/');
+    const root = realpathExisting(rootDir);
+    const abs = realpathExisting(absolutePath);
+    return path.relative(root, abs).replace(/\\/g, '/');
+}
+/** `realpathSync` when the path (or its dirname) exists; otherwise `path.resolve`. */
+function realpathExisting(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        try {
+            return path.join(fs.realpathSync(path.dirname(p)), path.basename(p));
+        }
+        catch {
+            return path.resolve(p);
+        }
+    }
 }
 /** Map ArkAnalyzer synthetic files (e.g. @dummyFile) to our virtual indexed path. */
 function resolveArkanalyzerVirtualPath(arkFile) {
@@ -1492,6 +1696,52 @@ function stateDecoratorKinds(field) {
         return [];
     return [...decs].map((d) => d.getKind()).filter(Boolean);
 }
+/** All field decorators with optional string args (Provide('theme') → theme). */
+function fieldDecoratorEntries(field) {
+    const out = [];
+    const seen = new Set();
+    const push = (kind, arg) => {
+        if (!kind || seen.has(kind))
+            return;
+        seen.add(kind);
+        out.push(arg ? { kind, arg } : { kind });
+    };
+    try {
+        for (const d of field.getDecorators?.() ?? []) {
+            push(d.getKind(), (0, migrate_semantics_1.parseDecoratorArgFromContent)(d.getContent?.() ?? ''));
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    if (out.length === 0) {
+        for (const kind of stateDecoratorKinds(field))
+            push(kind);
+    }
+    return out;
+}
+/** Encoded decorators list for node.decorators (bare kinds + Kind@arg). */
+function fieldDecoratorsEncoded(field) {
+    return (0, migrate_semantics_1.encodeDecoratorEntries)(fieldDecoratorEntries(field));
+}
+function modelDecoratorEntries(model) {
+    const out = [];
+    const seen = new Set();
+    try {
+        for (const d of model.getDecorators?.() ?? []) {
+            const kind = d.getKind();
+            if (!kind || seen.has(kind))
+                continue;
+            seen.add(kind);
+            const arg = (0, migrate_semantics_1.parseDecoratorArgFromContent)(d.getContent?.() ?? '');
+            out.push(arg ? { kind, arg } : { kind });
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return out;
+}
 /** Child @Prop / @Link — edge `via` uses the decorator name as-is. */
 function stateTransferViaForField(field) {
     for (const kind of stateDecoratorKinds(field)) {
@@ -1838,12 +2088,12 @@ function indexViewTreeForClass(ctx, cls, result, relativePath) {
     if (!buildId)
         return;
     const seen = new Set();
-    const link = (source, target, kind, via, line) => {
+    const link = (source, target, kind, via, line, extraMeta) => {
         const key = `${source}>${target}>${kind}>${via}`;
         if (seen.has(key))
             return;
         seen.add(key);
-        ctx.addEdge(result, source, target, kind, relativePath, via, line);
+        ctx.addEdge(result, source, target, kind, relativePath, via, line, extraMeta);
     };
     for (const [field] of viewTree.getStateValues()) {
         const fieldId = ctx.resolveFieldNodeId(field);
@@ -1911,32 +2161,62 @@ function indexViewTreeForClass(ctx, cls, result, relativePath) {
                 // Skip this node's signature edge; keep walking siblings/children.
             }
         }
-        if (node.stateValuesTransfer) {
-            for (const [childField, parentValue] of node.stateValuesTransfer) {
-                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.resolveFieldNodeId(parentValue);
-                    if (parentFieldId) {
-                        ctx.markFieldStateDecorators?.(parentValue, parentFieldId, result);
-                        link(parentFieldId, childFieldId, 'references', via, childField.getOriginFullPosition()?.getFirstLine() ?? 1);
-                    }
+        // Data passages for migrate snapshot (+ Prop/Link edges for explore).
+        try {
+            const passages = (0, migrate_passage_1.collectPassagesForViewTreeNode)(node, ctx.scene, cls);
+            for (const p of passages) {
+                const toId = ctx.resolveFieldNodeId(p.toField);
+                if (!toId)
+                    continue;
+                ctx.markFieldStateDecorators?.(p.toField, toId, result);
+                let fromId = null;
+                if (p.fromField) {
+                    fromId = ctx.resolveFieldNodeId(p.fromField);
+                    if (fromId)
+                        ctx.markFieldStateDecorators?.(p.fromField, fromId, result);
                 }
-                else if (parentValue instanceof arkanalyzer_1.ArkMethod) {
-                    let builderId = ctx.ensureMethodNode(parentValue, relativePath, result, classNodeId);
-                    if (!builderId) {
-                        try {
-                            builderId = ctx.resolveMethodIdBySig(parentValue.getSignature());
-                        }
-                        catch {
-                            builderId = null;
+                if (!fromId && p.fromIsParentComponent)
+                    fromId = classNodeId;
+                if (!fromId)
+                    continue;
+                const line = p.toField.getOriginFullPosition()?.getFirstLine() ?? 1;
+                link(fromId, toId, 'references', p.via || 'data-passage', line, {
+                    passageType: p.passageType,
+                    valueType: p.valueType,
+                    forcesMigration: p.forcesMigration,
+                    parentExpression: p.parentExpression,
+                });
+            }
+        }
+        catch {
+            // Fall back to legacy Prop/Link-only transfer below.
+            if (node.stateValuesTransfer) {
+                for (const [childField, parentValue] of node.stateValuesTransfer) {
+                    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.resolveFieldNodeId(parentValue);
+                        if (parentFieldId) {
+                            ctx.markFieldStateDecorators?.(parentValue, parentFieldId, result);
+                            link(parentFieldId, childFieldId, 'references', via, childField.getOriginFullPosition()?.getFirstLine() ?? 1);
                         }
                     }
-                    if (childFieldId && builderId) {
-                        link(builderId, childFieldId, 'references', 'builder-param', childField.getOriginFullPosition()?.getFirstLine() ?? 1);
+                    else if (parentValue instanceof arkanalyzer_1.ArkMethod) {
+                        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);
+                        }
                     }
                 }
             }
@@ -1992,6 +2272,12 @@ class ArkTSAdapter {
     crossFileEdges = [];
     /** Per-module `@dummyMain@…` created during analyseByModule (for scene aggregator). */
     moduleDummyMains = [];
+    /**
+     * Local import binding names from `lib*.so` per relative file path.
+     * Filled before method bodies are scanned so `multimodalinput.getTidByName(`
+     * can emit NAPI call refs (not only photos-style `Class_method` names).
+     */
+    soImportBindingsByFile = new Map();
     constructor(rootDir, scannedFiles) {
         this.rootDir = rootDir;
         this.scanned = new Set(scannedFiles);
@@ -2028,6 +2314,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 +2755,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))
@@ -2498,6 +2811,70 @@ class ArkTSAdapter {
                 }
             }
         }
+        this.indexObservedClassRefs();
+    }
+    /**
+     * State / Param fields whose type names an @Observed / @ObservedV2 class →
+     * `references` via `observed-ref` (arkui-migrate).
+     */
+    indexObservedClassRefs() {
+        const observedByName = new Map();
+        for (const [, result] of this.fileResults) {
+            for (const n of result.nodes) {
+                if (n.kind !== 'class' && n.kind !== 'struct')
+                    continue;
+                const decs = n.decorators ?? [];
+                if (!decs.some((d) => migrate_semantics_1.OBSERVATION_DECORATORS.has(d.split('@')[0])))
+                    continue;
+                const arr = observedByName.get(n.name) ?? [];
+                arr.push(n.id);
+                observedByName.set(n.name, arr);
+            }
+        }
+        if (observedByName.size === 0)
+            return;
+        for (const [relativePath, result] of this.fileResults) {
+            for (const field of result.nodes) {
+                if (field.kind !== 'property' && field.kind !== 'field')
+                    continue;
+                const typeStr = field.signature ?? '';
+                const bare = typeStr.replace(/<.*>/, '').split(/[.\s|]/).filter(Boolean).pop();
+                if (!bare)
+                    continue;
+                const targets = observedByName.get(bare);
+                if (!targets || targets.length === 0)
+                    continue;
+                // Prefer unique name; if ambiguous, same-file first
+                let targetId = targets[0];
+                if (targets.length > 1) {
+                    const sameFile = targets.find((id) => {
+                        const n = result.nodes.find((x) => x.id === id);
+                        return n?.filePath === relativePath;
+                    });
+                    if (sameFile)
+                        targetId = sameFile;
+                    else
+                        continue; // ambiguous cross-file — skip (precision > recall)
+                }
+                const edgeKey = `${field.id}\0${targetId}\0observed-ref`;
+                if (this.emittedEdgeKeys.has(edgeKey))
+                    continue;
+                this.emittedEdgeKeys.add(edgeKey);
+                const edge = arkEdge(field.id, targetId, 'references', {
+                    metadata: {
+                        synthesizedBy: 'arkui-migrate',
+                        via: 'observed-ref',
+                        registeredAt: `${relativePath}:${field.startLine}`,
+                    },
+                });
+                if (this.nodeInFile(targetId, relativePath)) {
+                    result.edges.push(edge);
+                }
+                else {
+                    this.crossFileEdges.push(edge);
+                }
+            }
+        }
     }
     /** Index ArkAnalyzer's in-scene @dummyMain (DummyMainCreater output), not a HomeGraph synthetic node. */
     indexArkanalyzerDummyMain(dummyMain) {
@@ -2547,6 +2924,8 @@ class ArkTSAdapter {
         }
         const result = this.ensureFileResult(relativePath, lineCount);
         const fileId = `file:${relativePath}`;
+        // Before methods: record `lib*.so` bindings so body NAPI call scan can see them.
+        this.collectSoImportBindings(relativePath, arkFile);
         for (const ns of arkFile.getNamespaces()) {
             this.indexNamespace(relativePath, language, result, ns, fileId);
         }
@@ -2555,6 +2934,59 @@ class ArkTSAdapter {
         this.indexTypeAliases(relativePath, language, result, arkFile, undefined, fileId);
         this.indexModuleLocals(relativePath, language, result, arkFile, undefined, fileId);
         this.indexImports(relativePath, language, result, arkFile, fileId);
+        this.indexStorageApiKeys(relativePath, arkFile, result);
+    }
+    /** AppStorage / LocalStorage / … literal keys → arkui-migrate edges from each component. */
+    indexStorageApiKeys(relativePath, arkFile, result) {
+        let code = '';
+        try {
+            code = arkFile.getCode() ?? '';
+        }
+        catch {
+            return;
+        }
+        if (!code)
+            return;
+        const hits = (0, migrate_semantics_1.scanStorageApiKeys)(code);
+        if (hits.length === 0)
+            return;
+        const componentIds = result.nodes
+            .filter((n) => n.kind === 'component' && n.filePath === relativePath)
+            .map((n) => n.id);
+        if (componentIds.length === 0)
+            return;
+        for (const hit of hits) {
+            const line = (0, migrate_semantics_1.lineOfOffset)(code, hit.index);
+            for (const compId of componentIds) {
+                const edgeKey = `${compId}\0storage-api\0${hit.channel}\0${hit.key}`;
+                if (this.emittedEdgeKeys.has(edgeKey))
+                    continue;
+                this.emittedEdgeKeys.add(edgeKey);
+                result.edges.push(arkEdge(compId, compId, 'references', {
+                    metadata: {
+                        synthesizedBy: 'arkui-migrate',
+                        via: 'storage-api',
+                        channel: hit.channel,
+                        key: hit.key,
+                        method: hit.method,
+                        registeredAt: `${relativePath}:${line}`,
+                    },
+                }));
+            }
+        }
+    }
+    collectSoImportBindings(relativePath, arkFile) {
+        const set = new Set();
+        for (const importInfo of arkFile.getImportInfos()) {
+            const modulePath = importInfo.getFrom();
+            if (!modulePath || !LIB_SO_MODULE_RE.test(modulePath))
+                continue;
+            const clause = importInfo.getImportClauseName();
+            if (clause)
+                set.add(clause);
+        }
+        if (set.size > 0)
+            this.soImportBindingsByFile.set(relativePath, set);
     }
     indexModuleLocals(relativePath, language, result, arkFile, ns, parentId) {
         const declaringClass = ns ? ns.getDefaultClass() : arkFile.getDefaultClass();
@@ -2648,8 +3080,10 @@ class ArkTSAdapter {
         const qn = buildClassQualifiedName(cls);
         const kind = classNodeKind(cls);
         const { line, endLine, col } = linesFromPosition(cls.getOriginFullPosition());
+        const classDecs = (0, migrate_semantics_1.encodeDecoratorEntries)(modelDecoratorEntries(cls));
         const classNode = makeNode(relativePath, language, kind, displayName, qn, line, endLine, col, {
             ...modelModifiersToNodeExtras(cls),
+            ...(classDecs.length > 0 ? { decorators: classDecs } : {}),
         });
         this.addNode(result, classNode);
         this.classToId.set(cls, classNode.id);
@@ -2677,7 +3111,10 @@ class ArkTSAdapter {
             }
         }
         if (cls.hasComponentDecorator()) {
-            const componentNode = makeNode(relativePath, language, 'component', displayName, qn, line, endLine, col, { ...modelModifiersToNodeExtras(cls) });
+            const componentNode = makeNode(relativePath, language, 'component', displayName, qn, line, endLine, col, {
+                ...modelModifiersToNodeExtras(cls),
+                ...(classDecs.length > 0 ? { decorators: classDecs } : {}),
+            });
             this.addNode(result, componentNode);
             this.componentToId.set(cls, componentNode.id);
             try {
@@ -2763,10 +3200,10 @@ class ArkTSAdapter {
             return;
         const { line, endLine, col } = linesFromPosition(field.getOriginFullPosition());
         const qn = buildFieldQualifiedName(field);
-        const stateDecs = stateDecoratorKinds(field);
+        const encodedDecs = fieldDecoratorsEncoded(field);
         const fieldNode = makeNode(relativePath, language, kind, name, qn, line, endLine, col, {
             signature: field.getType()?.toString(),
-            ...(stateDecs.length > 0 ? { decorators: stateDecs } : {}),
+            ...(encodedDecs.length > 0 ? { decorators: encodedDecs } : {}),
             ...modelModifiersToNodeExtras(field),
         });
         this.addNode(result, fieldNode);
@@ -2792,19 +3229,19 @@ class ArkTSAdapter {
             classToId: this.classToId,
             fieldToId: this.fieldToId,
             nodeIds: this.nodeIds,
-            addEdge: (result, source, target, kind, callerFile, via, line) => this.addViewTreeEdge(result, source, target, kind, callerFile, via, line),
+            addEdge: (result, source, target, kind, callerFile, via, line, extraMeta) => this.addViewTreeEdge(result, source, target, kind, callerFile, via, line, extraMeta),
             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)
+                const encoded = fieldDecoratorsEncoded(field);
+                if (encoded.length === 0)
                     return;
                 const node = result.nodes.find((n) => n.id === fieldNodeId);
                 if (node)
-                    node.decorators = kinds;
+                    node.decorators = encoded;
             },
         };
     }
@@ -3028,7 +3465,7 @@ class ArkTSAdapter {
         this.indexMethod(relativePath, 'arkts', result, method, parentId, kind, displayName);
         return this.methodToId.get(method) ?? null;
     }
-    addViewTreeEdge(result, source, target, kind, callerFile, via, line) {
+    addViewTreeEdge(result, source, target, kind, callerFile, via, line, extraMeta) {
         const edgeKey = `${source}\0${target}\0${kind}\0${via}`;
         if (this.emittedEdgeKeys.has(edgeKey))
             return;
@@ -3038,6 +3475,7 @@ class ArkTSAdapter {
                 synthesizedBy: 'viewtree',
                 via,
                 registeredAt: `${callerFile}:${line}`,
+                ...(extraMeta ?? {}),
             },
         });
         if (this.nodeInFile(target, callerFile)) {
@@ -3115,17 +3553,14 @@ class ArkTSAdapter {
             return;
         const baseLine = method.getImplOriginFullPosition()?.getFirstLine() ?? 1;
         const seenAtLine = new Set();
-        NAPI_MEMBER_CALL_RE.lastIndex = 0;
-        let m;
-        while ((m = NAPI_MEMBER_CALL_RE.exec(code)) !== null) {
-            const symbol = m[1];
-            if (!isNapiSymbolName(symbol))
-                continue;
-            const lineOffset = code.slice(0, m.index).split('\n').length - 1;
+        const pushCall = (symbol, matchIndex) => {
+            if (!symbol)
+                return;
+            const lineOffset = code.slice(0, matchIndex).split('\n').length - 1;
             const line = baseLine + lineOffset;
             const dedupKey = `${symbol}:${line}`;
             if (seenAtLine.has(dedupKey))
-                continue;
+                return;
             seenAtLine.add(dedupKey);
             result.unresolvedReferences.push({
                 fromNodeId,
@@ -3136,6 +3571,35 @@ class ArkTSAdapter {
                 filePath: relativePath,
                 language,
             });
+        };
+        // Photos-style `Class_method` on any receiver.
+        NAPI_MEMBER_CALL_RE.lastIndex = 0;
+        let m;
+        while ((m = NAPI_MEMBER_CALL_RE.exec(code)) !== null) {
+            const symbol = m[1];
+            if (!isNapiSymbolName(symbol))
+                continue;
+            pushCall(symbol, m.index);
+        }
+        // `import x from 'libFoo.so'` → `x.draw(` / `x.getTidByName(` (camelCase OK).
+        const soBindings = this.soImportBindingsByFile.get(relativePath);
+        if (soBindings) {
+            for (const binding of soBindings) {
+                const re = new RegExp(`\\b${escapeRegExp(binding)}\\s*\\.\\s*([A-Za-z_][A-Za-z0-9_]*)\\s*\\(`, 'g');
+                while ((m = re.exec(code)) !== null) {
+                    pushCall(m[1], m.index);
+                }
+            }
+            // define_class / instance path: `this.inst?.addVerticalRuler(` — receiver is
+            // not the import binding. Only in files that already import a lib*.so.
+            const anyMemberRe = /\?\.\s*([A-Za-z_][A-Za-z0-9_]*)\s*\(|\.\s*([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
+            while ((m = anyMemberRe.exec(code)) !== null) {
+                const symbol = m[1] ?? m[2];
+                if (!symbol)
+                    continue;
+                // Skip photos-style names already handled above; keep camelCase / plain ids.
+                pushCall(symbol, m.index);
+            }
         }
     }
     indexImports(relativePath, language, result, arkFile, fileId) {
@@ -3219,6 +3683,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 +3698,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 +3747,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 +3841,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 +3868,7 @@ function buildArkTSIndexByModuleInner(rootDir, scannedFiles, options) {
     }
     finally {
         try {
-            scene.dispose();
+            releaseArkAnalyzerScene(scene);
         }
         catch {
             // ignore dispose failures
@@ -3349,13 +3894,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 +4078,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 +4226,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 +4368,367 @@ 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)) {
+/** 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 */
+        }
+    }
+    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 {
+        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 {
-            version,
-            dbPath,
-            packageName: ohosApiDbPackageName(version),
-            installed: false,
+            code: 'ohos_api_db_missing',
+            message: `Failed to attach OHOS API db at ${binding.dbPath}: ${msg}`,
         };
     }
+}
+/** Last-resort prebuilt npm package when the project's API version cannot be obtained. */
+const OHOS_API_FALLBACK_VERSION = '6.1.0';
+function runNpmPack(args, cwd) {
+    const inv = process.platform === 'win32'
+        ? { cmd: 'cmd.exe', args: ['/d', '/s', '/c', ['npm', ...args].join(' ')] }
+        : { cmd: 'npm', args };
+    (0, child_process_1.execFileSync)(inv.cmd, inv.args, {
+        cwd,
+        stdio: 'pipe',
+        timeout: 180_000,
+        windowsHide: true,
+        env: process.env,
+    });
+}
+/**
+ * Fetch `homegraph-ohos-api-db-<version>` from npm and copy the db into
+ * `~/.homegraph/api/`. Returns null when downloads are disabled, the package
+ * is missing, or install fails. Opt out: HOMEGRAPH_OHOS_API_NO_DOWNLOAD=1.
+ */
+function tryDownloadOhosApiDbFromNpm(version) {
+    if (process.env.HOMEGRAPH_OHOS_API_NO_DOWNLOAD === '1')
+        return null;
+    const dbPath = ohosApiDbInstallPath(version);
     const packageName = ohosApiDbPackageName(version);
-    const installDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hg-ohos-npm-'));
+    if (fs.existsSync(dbPath)) {
+        return { version, dbPath, packageName, installed: false };
+    }
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'hg-ohos-api-npm-'));
     try {
-        (0, child_process_1.execFileSync)('npm', ['install', '--no-save', packageName], {
-            cwd: installDir,
+        runNpmPack(['pack', packageName, '--silent'], tmp);
+        const tgz = fs.readdirSync(tmp).find((f) => f.endsWith('.tgz'));
+        if (!tgz)
+            return null;
+        const extractDir = path.join(tmp, 'extract');
+        fs.mkdirSync(extractDir, { recursive: true });
+        (0, child_process_1.execFileSync)('tar', ['-xzf', path.join(tmp, tgz), '-C', extractDir], {
             stdio: 'pipe',
-            timeout: 180_000,
-            env: { ...process.env, npm_config_loglevel: 'error' },
+            timeout: 60_000,
+            windowsHide: true,
         });
+        const dbName = ohosApiDbFilename(version);
+        const src = [
+            path.join(extractDir, 'package', dbName),
+            path.join(extractDir, dbName),
+        ].find((p) => fs.existsSync(p)) ?? null;
+        if (!src)
+            return null;
+        fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+        fs.copyFileSync(src, dbPath);
+        return { version, dbPath, packageName, installed: true };
     }
-    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.',
-        };
+    catch {
+        return null;
     }
     finally {
-        fs.rmSync(installDir, { recursive: true, force: true });
+        try {
+            fs.rmSync(tmp, { recursive: true, force: true });
+        }
+        catch {
+            /* ignore */
+        }
     }
-    if (!fs.existsSync(dbPath)) {
+}
+/**
+ * Build (or reuse) ~/.homegraph/api/ohos-api-<version>.db from a local SDK,
+ * then npm prebuilts. Never throws — missing SDK / build / download failure
+ * returns a warning.
+ *
+ * Order: existing db → local SDK build → npm pack for that version →
+ * npm pack homegraph-ohos-api-db-6.1.0 fallback.
+ */
+async function ensureOhosApiDb(version, options = {}) {
+    const dbPath = ohosApiDbInstallPath(version);
+    const packageName = ohosApiDbPackageName(version);
+    // 1. Local db for the requested version
+    if (fs.existsSync(dbPath)) {
+        return { version, dbPath, packageName, installed: false };
+    }
+    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 };
+    // 2. Build from a local DevEco / OpenHarmony SDK
+    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) {
+        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)) {
+                options.onProgress?.({
+                    phase: 'ohos-api',
+                    current: 1,
+                    total: 1,
+                    currentFile: version,
+                });
+                return { version, dbPath, packageName, installed: true };
+            }
+            try {
+                fs.unlinkSync(dbPath);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        catch {
+            try {
+                if (fs.existsSync(dbPath))
+                    fs.unlinkSync(dbPath);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    // 3. Download prebuilt for the requested version from npm
+    const fromNpm = tryDownloadOhosApiDbFromNpm(version);
+    if (fromNpm)
+        return fromNpm;
+    // 4. Last resort: homegraph-ohos-api-db-6.1.0
+    if (version !== OHOS_API_FALLBACK_VERSION) {
+        const fallbackPath = ohosApiDbInstallPath(OHOS_API_FALLBACK_VERSION);
+        if (fs.existsSync(fallbackPath)) {
+            return {
+                version: OHOS_API_FALLBACK_VERSION,
+                dbPath: fallbackPath,
+                packageName: ohosApiDbPackageName(OHOS_API_FALLBACK_VERSION),
+                installed: false,
+            };
+        }
+        const fallback = tryDownloadOhosApiDbFromNpm(OHOS_API_FALLBACK_VERSION);
+        if (fallback)
+            return fallback;
+    }
+    return {
+        code: 'ohos_api_sdk_missing',
+        message: `OHOS API db for ${version} unavailable (no local SDK build, npm ${packageName} failed` +
+            (version !== OHOS_API_FALLBACK_VERSION
+                ? `, and fallback ${ohosApiDbPackageName(OHOS_API_FALLBACK_VERSION)} failed`
+                : '') +
+            '). Set OHOS_SDK_HOME / DEVECO_SDK_HOME or install the matching DevEco SDK. ' +
+            '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) {