arkanalyzer 1.0.91 → 1.0.92

package/lib/frontend/common/ModuleBuilder.js

@@ -63,6 +63,9 @@ const getAllFiles_1 = require("../../utils/getAllFiles");
 const SdkUtils_1 = require("../../core/common/SdkUtils");
 const ArktsFrontend_1 = require("../arktsFrontend/ArktsFrontend");
 const ModelUtils_1 = require("../../core/common/ModelUtils");
+const ArkClass_1 = require("../../core/model/ArkClass");
+const ArkMethod_1 = require("../../core/model/ArkMethod");
+const ArkNamespace_1 = require("../../core/model/ArkNamespace");
 const ModuleUtils_1 = require("../../utils/ModuleUtils");
 const Scene_1 = require("../../Scene");
 const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ModuleBuilder');
@@ -793,16 +796,14 @@ class ModuleBuilder {
      */
     depthLevelToLoadState(level) {
         switch (level) {
-            case ModuleDepth_1.ModuleDepthLevel.META:
-                return ArkModule_1.ModuleLoadState.META;
-            case ModuleDepth_1.ModuleDepthLevel.IMPORTS:
-                return ArkModule_1.ModuleLoadState.IMPORTS;
+            case ModuleDepth_1.ModuleDepthLevel.INDEX:
+                return ArkModule_1.ModuleLoadState.INDEX;
             case ModuleDepth_1.ModuleDepthLevel.SIGNATURES:
                 return ArkModule_1.ModuleLoadState.SIGNATURES;
             case ModuleDepth_1.ModuleDepthLevel.BODIES:
                 return ArkModule_1.ModuleLoadState.BODIES;
             default:
-                return ArkModule_1.ModuleLoadState.META;
+                return ArkModule_1.ModuleLoadState.INDEX;
         }
     }
     /**
@@ -811,16 +812,14 @@ class ModuleBuilder {
      */
     loadStateToDepthLevel(loadState) {
         switch (loadState) {
-            case ArkModule_1.ModuleLoadState.META:
-                return ModuleDepth_1.ModuleDepthLevel.META;
-            case ArkModule_1.ModuleLoadState.IMPORTS:
-                return ModuleDepth_1.ModuleDepthLevel.IMPORTS;
+            case ArkModule_1.ModuleLoadState.INDEX:
+                return ModuleDepth_1.ModuleDepthLevel.INDEX;
             case ArkModule_1.ModuleLoadState.SIGNATURES:
                 return ModuleDepth_1.ModuleDepthLevel.SIGNATURES;
             case ArkModule_1.ModuleLoadState.BODIES:
                 return ModuleDepth_1.ModuleDepthLevel.BODIES;
             default:
-                return ModuleDepth_1.ModuleDepthLevel.META;
+                return ModuleDepth_1.ModuleDepthLevel.INDEX;
         }
     }
     /**
@@ -898,8 +897,9 @@ class ModuleBuilder {
      * @param moduleId - ID of the module to load.
      * @param depthLevel - The depth level to load the module to.
      */
-    loadModule(moduleId, depthLevel = ModuleDepth_1.ModuleDepthLevel.META) {
+    loadModule(moduleId, depthLevel = ModuleDepth_1.ModuleDepthLevel.SIGNATURES) {
         var _a, _b, _c, _d, _e;
+        (0, ModuleDepth_1.assertDirectLoadLevel)(depthLevel);
         const module = this.getModule(moduleId);
         if (!module) {
             return;
@@ -916,11 +916,14 @@ class ModuleBuilder {
             (_a = this.cache) === null || _a === void 0 ? void 0 : _a.register(moduleId);
             return;
         }
+        // INDEX hollow may have pruned non-exported IR; rebuild from disk when upgrading.
+        if (module.getLoadState() === ArkModule_1.ModuleLoadState.INDEX) {
+            this.resetModuleIrForRebuild(module);
+        }
         // Record heapUsed before actual build (for heapUsed table population)
         const recordHeapUsed = (_c = (_b = this.monitor) === null || _b === void 0 ? void 0 : _b.isEnabled()) !== null && _c !== void 0 ? _c : false;
         const heapUsedBefore = recordHeapUsed ? this.monitor.getCurrentHeapUsed() : 0;
-        // Phase 1: build ArkFile objects to the effective level, with intra-module file
-        // dependency analysis integrated (topological-order parsing for level > IMPORTS).
+        // Phase 1: build ArkFile IR to SIGNATURES/BODIES (imports + topo + signatures).
         this.buildModuleToLevel(module, depthLevel);
         // Phase 2: build method bodies when BODIES level was requested
         if (depthLevel >= ModuleDepth_1.ModuleDepthLevel.BODIES) {
@@ -942,17 +945,8 @@ class ModuleBuilder {
         (_e = this.cache) === null || _e === void 0 ? void 0 : _e.register(moduleId);
     }
     /**
-     * Unload a module's data, releasing heavy data and resetting to NOT_LOADED state.
-     *
-     * Clears the module's filesMap (releasing ArkFile/ArkClass/ArkMethod objects), resets the
-     * file dependency graph (so that the next {@link loadModule} rebuilds IMPORTS from scratch),
-     * and sets the load state to NOT_LOADED. After unloading, {@link loadModule} can rebuild
-     * the module from scratch.
-     *
-     * SDK modules are not unloaded (their data is built by {@link buildSdkModules} and shared
-     * globally).
-     *
-     * @param moduleId - ID of the module to unload.
+     * Unload a module's data, releasing IR and resetting to NOT_LOADED.
+     * SDK modules are not unloaded (built by {@link buildSdkModules}).
      */
     unload(moduleId) {
         const module = this.getModule(moduleId);
@@ -962,10 +956,7 @@ class ModuleBuilder {
         if (module.getModuleType() === ArkModule_1.ModuleType.SDK) {
             return;
         }
-        this.scene.disposeModule(module);
-        this.breakInternalReferences(module);
-        module.clearFilesMap();
-        module.setFileDepGraph(undefined);
+        this.resetModuleIrForRebuild(module);
         module.setLoadState(ArkModule_1.ModuleLoadState.NOT_LOADED);
     }
     /**
@@ -999,6 +990,7 @@ class ModuleBuilder {
         this.monitor = this.scene.getMemoryMonitor();
         this.cache = this.scene.getModuleCache();
         this.topoOrder = topoOrder;
+        (0, ModuleDepth_1.assertDirectLoadLevel)(dependencyLoadLevel);
         this.dependencyLoadLevel = dependencyLoadLevel;
         this.topoOrderIndex = new Map();
         for (let i = 0; i < topoOrder.length; i++) {
@@ -1016,7 +1008,7 @@ class ModuleBuilder {
      * During eviction, the heapUsed estimate is tracked via {@link HeapUsedEstimateState},
      * decremented by the heapUsed table value of each unloaded/downgraded module.
      */
-    evictIfNeeded(moduleId, depthLevel = ModuleDepth_1.ModuleDepthLevel.META) {
+    evictIfNeeded(moduleId, depthLevel = ModuleDepth_1.ModuleDepthLevel.SIGNATURES) {
         if (!this.monitor || !this.cache || !this.topoOrderIndex) {
             return;
         }
@@ -1045,6 +1037,7 @@ class ModuleBuilder {
         const reverseTopo = [...this.topoOrder].reverse();
         this.runPhase1Eviction(hardProtected, softProtected, depGraph, heapUsedState);
         this.runPhase2Downgrade(protectedDeps, reverseTopo, heapUsedState);
+        this.runPhase2bDowngradeToIndex(protectedDeps, reverseTopo, heapUsedState);
         this.runPhase3Eviction(protectedDeps, reverseTopo, heapUsedState);
     }
     runPhase1Eviction(hardProtected, softProtected, depGraph, heapUsedState) {
@@ -1056,7 +1049,8 @@ class ModuleBuilder {
         if (heapUsedState.estimate <= heapUsedState.limit) {
             return;
         }
-        const downgradeTarget = Math.max(this.dependencyLoadLevel, ModuleDepth_1.ModuleDepthLevel.SIGNATURES);
+        // Prefer configured dependency load level (already coerced away from INDEX at init).
+        const downgradeTarget = this.dependencyLoadLevel;
         const targetLoadState = this.depthLevelToLoadState(downgradeTarget);
         for (const id of reverseTopo) {
             if (heapUsedState.estimate <= heapUsedState.limit) {
@@ -1074,6 +1068,32 @@ class ModuleBuilder {
             heapUsedState.estimate -= decrease;
         }
     }
+    /**
+     * Eviction phase 2b: if still over limit after BODIES→SIGNATURES, downgrade protected
+     * deps further to INDEX (hollow in-place IR; same lookup APIs as SIGNATURES).
+     */
+    runPhase2bDowngradeToIndex(protectedDeps, reverseTopo, heapUsedState) {
+        var _a;
+        if (heapUsedState.estimate <= heapUsedState.limit) {
+            return;
+        }
+        const targetLoadState = ArkModule_1.ModuleLoadState.INDEX;
+        for (const id of reverseTopo) {
+            if (heapUsedState.estimate <= heapUsedState.limit) {
+                break;
+            }
+            if (!protectedDeps.has(id) || !((_a = this.cache) === null || _a === void 0 ? void 0 : _a.has(id))) {
+                continue;
+            }
+            const mod = this.getModule(id);
+            if (!mod || mod.getLoadState() <= targetLoadState) {
+                continue;
+            }
+            const decrease = this.estimateDowngradeHeapUsedDecrease(id, ModuleDepth_1.ModuleDepthLevel.INDEX);
+            this.downgradeModule(id, ModuleDepth_1.ModuleDepthLevel.INDEX);
+            heapUsedState.estimate -= decrease;
+        }
+    }
     runPhase3Eviction(protectedDeps, reverseTopo, heapUsedState) {
         var _a;
         if (heapUsedState.estimate <= heapUsedState.limit) {
@@ -1150,10 +1170,14 @@ class ModuleBuilder {
         return Math.max(0, Math.floor(currentHeapUsed * ModuleBuilder.DOWNGRADE_RELEASE_RATIO));
     }
     /**
-     * Downgrade a module's loaded data to the given target level (min SIGNATURES), releasing the
-     * heavy method-body/view-tree/AST data while keeping signatures (ArkClass/method signatures,
-     * filesMap, Scene index maps) so dependents can still resolve types. No-op if already at or
-     * below the target level. Used by eviction Phase 2.
+     * Downgrade a module to the given target level. Used by eviction Phase 2 / 2b.
+     *
+     * - {@link ModuleDepthLevel.SIGNATURES}: clear method bodies / view trees / AST while keeping
+     *   full ArkFile signature IR.
+     * - {@link ModuleDepthLevel.INDEX}: hollow in place (strip + prune non-exports). Use
+     *   {@link unload} to drop IR entirely.
+     *
+     * No-op if already at or below the target.
      */
     downgradeModule(moduleId, targetLevel) {
         const module = this.getModule(moduleId);
@@ -1164,6 +1188,19 @@ class ModuleBuilder {
         if (module.getLoadState() <= targetLoadState) {
             return;
         }
+        if (targetLevel === ModuleDepth_1.ModuleDepthLevel.INDEX) {
+            this.hollowModuleToIndex(module);
+            return;
+        }
+        // SIGNATURES: strip bodies while keeping full signature IR.
+        this.stripModuleBodiesAndAst(module);
+        module.setLoadState(targetLoadState);
+    }
+    /**
+     * Drop method bodies / view trees / AST / source text while keeping ArkFile shells.
+     * Shared by SIGNATURES and INDEX downgrade paths.
+     */
+    stripModuleBodiesAndAst(module) {
         for (const arkFile of module.getFilesMap().values()) {
             for (const cls of ModelUtils_1.ModelUtils.getAllClassesInFile(arkFile)) {
                 for (const mtd of cls.getMethods(true)) {
@@ -1177,7 +1214,114 @@ class ModuleBuilder {
             arkFile.setAST(null);
             arkFile.clearSourceCode();
         }
-        module.setLoadState(targetLoadState);
+    }
+    /**
+     * INDEX retention: strip heavy payload in place, prune non-exported IR, keep export-reachable
+     * shells registered on the module / Scene so existing lookup APIs still resolve.
+     */
+    hollowModuleToIndex(module) {
+        if (module.getFilesMap().size === 0) {
+            module.setFileDepGraph(undefined);
+            module.setLoadState(ArkModule_1.ModuleLoadState.INDEX);
+            return;
+        }
+        this.stripModuleBodiesAndAst(module);
+        const { keepClasses, keepNamespaces } = this.collectExportReachableSets(module);
+        this.pruneNonExportedIr(module, keepClasses, keepNamespaces);
+        module.setFileDepGraph(undefined);
+        module.setLoadState(ArkModule_1.ModuleLoadState.INDEX);
+    }
+    collectExportReachableSets(module) {
+        const keepClasses = new Set();
+        const keepNamespaces = new Set();
+        for (const arkFile of module.getFilesMap().values()) {
+            for (const exp of arkFile.getExportInfos()) {
+                this.addExportToKeepSets(exp.getArkExport(), keepClasses, keepNamespaces);
+            }
+        }
+        return { keepClasses, keepNamespaces };
+    }
+    addExportToKeepSets(arkExport, keepClasses, keepNamespaces) {
+        if (!arkExport) {
+            return;
+        }
+        if (arkExport instanceof ArkClass_1.ArkClass) {
+            keepClasses.add(arkExport);
+            const ns = arkExport.getDeclaringArkNamespace();
+            if (ns) {
+                keepNamespaces.add(ns);
+            }
+            return;
+        }
+        if (arkExport instanceof ArkMethod_1.ArkMethod) {
+            const cls = arkExport.getDeclaringArkClass();
+            keepClasses.add(cls);
+            const ns = cls.getDeclaringArkNamespace();
+            if (ns) {
+                keepNamespaces.add(ns);
+            }
+            return;
+        }
+        if (arkExport instanceof ArkNamespace_1.ArkNamespace) {
+            keepNamespaces.add(arkExport);
+        }
+    }
+    pruneNonExportedIr(module, keepClasses, keepNamespaces) {
+        for (const arkFile of module.getFilesMap().values()) {
+            this.pruneNonKeptClasses(arkFile, keepClasses);
+            this.pruneNonKeptNamespaces(arkFile, keepClasses, keepNamespaces);
+        }
+    }
+    pruneNonKeptClasses(arkFile, keepClasses) {
+        for (const cls of [...ModelUtils_1.ModelUtils.getAllClassesInFile(arkFile)]) {
+            if (keepClasses.has(cls) || cls.isDefaultArkClass()) {
+                continue;
+            }
+            for (const base of cls.getAllHeritageClasses()) {
+                base.getExtendedClasses().delete(cls.getName());
+            }
+            for (const mtd of cls.getMethods(true)) {
+                this.scene.removeMethod(mtd);
+                mtd.clearBodyAndSupplementary();
+            }
+            const ns = cls.getDeclaringArkNamespace();
+            if (ns) {
+                ns.removeArkClass(cls);
+            }
+            else {
+                arkFile.removeArkClass(cls);
+            }
+        }
+    }
+    pruneNonKeptNamespaces(arkFile, keepClasses, keepNamespaces) {
+        for (const ns of [...arkFile.getNamespaces()]) {
+            if (keepNamespaces.has(ns) || this.namespaceOwnsKeptClass(ns, keepClasses)) {
+                continue;
+            }
+            arkFile.removeNamespace(ns);
+        }
+    }
+    namespaceOwnsKeptClass(ns, keepClasses) {
+        for (const cls of keepClasses) {
+            if (cls.getDeclaringArkNamespace() === ns) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Clear module IR from Scene maps and the module's filesMap so the next load rebuilds
+     * from disk. Used by {@link unload} and when upgrading out of hollow INDEX.
+     */
+    resetModuleIrForRebuild(module) {
+        if (module.getFilesMap().size === 0) {
+            module.setFileDepGraph(undefined);
+            return;
+        }
+        this.scene.disposeModule(module);
+        this.breakInternalReferences(module);
+        module.clearFilesMap();
+        module.setFileDepGraph(undefined);
     }
     /**
      * Get the number of source files in a module. If the module's filesMap is empty
@@ -1226,30 +1370,21 @@ class ModuleBuilder {
         return { hardProtected, softProtected };
     }
     /**
-     * Build module data to the specified depth level, integrating intra-module file dependency
-     * analysis into the build flow.
+     * Build module ArkFile IR up to SIGNATURES or BODIES.
+     * {@link ModuleDepthLevel.INDEX} is rejected ({@link assertDirectLoadLevel}).
      *
-     * Two-phase build for level > IMPORTS:
      * 1. Ensure ArkFile shells exist (create if filesMap is empty, reuse otherwise).
-     * 2. Build all files to IMPORTS level (lightweight import/export parsing, no dependency on
-     *    other files in the module).
-     * 3. Analyze intra-module file dependencies → compute topological order (moved here from
-     *    {@link loadModule} so it is part of the build-to-level flow).
-     * 4. For level > IMPORTS: upgrade each file to the target level (SIGNATURES/BODIES) in
-     *    topological order, so that depended-on files are parsed first.
-     *
-     * For level == META: only shells are created (no content).
-     * For level == IMPORTS: steps 1-3 (topoOrder available for later type inference).
-     * For level >= SIGNATURES: steps 1-4 (signatures built in topoOrder).
+     * 2. Build import/export info (if not already done) + analyze intra-module file dependencies.
+     * 3. Upgrade each file to the target level in topological order.
      *
-     * The {@link ArkModule.hasFileTopoOrder} flag is used to detect whether IMPORTS was already
-     * built (e.g. when upgrading from IMPORTS to SIGNATURES), avoiding redundant re-parsing.
+     * Method bodies are built later by {@link loadModule} when the target is BODIES.
      *
      * @param module - The module to build.
-     * @param level - The target depth level.
+     * @param level - Must be SIGNATURES or BODIES.
      */
     buildModuleToLevel(module, level) {
-        // 1. Ensure ArkFile shells exist (reuse if already created, e.g. from a prior META load)
+        (0, ModuleDepth_1.assertDirectLoadLevel)(level);
+        // 1. Ensure ArkFile shells exist (reuse if already created)
         let arkFiles;
         if (module.getFilesMap().size === 0) {
             arkFiles = FrontendBuilder_1.FrontendBuilder.createModuleFileShells(this.scene, module);
@@ -1257,13 +1392,8 @@ class ModuleBuilder {
         else {
             arkFiles = Array.from(module.getFilesMap().values());
         }
-        // META: no content to build
-        if (level <= ModuleDepth_1.ModuleDepthLevel.META) {
-            return;
-        }
-        // 2. Build IMPORTS level (if not already done) + analyze file dependencies
-        //    Use fileDepGraph existence as indicator that IMPORTS was already built.
-        if (level >= ModuleDepth_1.ModuleDepthLevel.IMPORTS && !module.hasFileTopoOrder()) {
+        // 2. Build import/export (if not already done) + analyze file dependencies
+        if (!module.hasFileTopoOrder()) {
             for (const arkFile of arkFiles) {
                 try {
                     FrontendBuilder_1.FrontendBuilder.buildImports(arkFile, arkFile.getLanguage());
@@ -1274,8 +1404,8 @@ class ModuleBuilder {
             }
             this.analyzeFileDependencies(module);
         }
-        // 3. For level > IMPORTS: upgrade to target level in topological order
-        if (level > ModuleDepth_1.ModuleDepthLevel.IMPORTS) {
+        // 3. Upgrade to target level in topological order
+        if (level >= ModuleDepth_1.ModuleDepthLevel.SIGNATURES) {
             const fileDepGraph = module.getFileDepGraph();
             let sortedFiles;
             if (fileDepGraph && fileDepGraph.getTopoOrder().length > 0) {
@@ -1285,7 +1415,7 @@ class ModuleBuilder {
                     .filter((f) => f !== undefined);
             }
             else {
-                // Fallback: no file dep graph available (e.g. empty module or analyzeFileDependencies produced no edges)
+                // Fallback: no file dep graph available
                 sortedFiles = arkFiles;
             }
             for (const arkFile of sortedFiles) {
@@ -1301,7 +1431,7 @@ class ModuleBuilder {
     // --- Intra-module file dependency analysis ---
     /**
      * Analyze file-to-file dependencies within a module using the import/export `from` specifiers
-     * populated at IMPORTS level.
+     * populated during the import/export parse step of {@link buildModuleToLevel}.
      *
      * Builds a {@link FileDepGraph}, resolves relative `from` specifiers to file paths within the
      * same module, adds dependency edges, computes a topological order via SCC detection, and
@@ -1435,7 +1565,7 @@ exports.ModuleBuilder = ModuleBuilder;
  * Calibrated from scene_board_ext measurements (no-eviction, no GC runs):
  * - BODIES: P75 of per-module heapUsed-per-file at BODIES level = ~1.7MB/file
  * - SIGNATURES: P75 of per-module heapUsed-per-file at SIGNATURES level = ~700KB/file
- * - IMPORTS/META: negligible (metadata only).
+ * - INDEX: hollow in-place IR (export-reachable shells); lighter than full SIGNATURES.
  *
  * No-GC calibration matches production conditions (no forced GC). Without GC,
  * heapUsed increments include uncollected garbage from parsing and type inference,
@@ -1445,8 +1575,7 @@ exports.ModuleBuilder = ModuleBuilder;
  * and as a fallback for unload estimation when the heapUsed table has no entry.
  */
 ModuleBuilder.HEAPUSED_PER_FILE = new Map([
-    [ModuleDepth_1.ModuleDepthLevel.META, 0],
-    [ModuleDepth_1.ModuleDepthLevel.IMPORTS, 0],
+    [ModuleDepth_1.ModuleDepthLevel.INDEX, 250000],
     [ModuleDepth_1.ModuleDepthLevel.SIGNATURES, 700000],
     [ModuleDepth_1.ModuleDepthLevel.BODIES, 1700000],
 ]);

package/lib/frontend/common/ModuleCache.d.ts

@@ -21,6 +21,7 @@ export interface HeapUsedEstimateState {
  * caller ({@link ModuleBuilder.evictIfNeeded}) handles the subsequent phases:
  * - **Phase 2** — downgrade protected dependencies to dependencyLoadLevel (release method
  *   bodies/AST, keep signatures), in reverse-topo order.
+ * - **Phase 2b** — further downgrade protected deps to INDEX (hollow in-place IR).
  * - **Phase 3** — if still over threshold, evict the protected dependencies (full unload),
  *   in reverse-topo order.
  *

package/lib/frontend/common/ModuleCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ModuleCache.d.ts","sourceRoot":"","sources":["../../../src/frontend/common/ModuleCache.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,WAAW;IACpB,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,WAAW,CAAkB;IAErC;;;;OAIG;IACH,OAAO,CAAC,aAAa,CAA2D;IAEhF,mCAAmC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAOzC,kGAAkG;IAC3F,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAS3C,oDAAoD;IAC7C,GAAG,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IAIvC,0CAA0C;IACnC,IAAI,IAAI,MAAM;IAIrB,uCAAuC;IAChC,gBAAgB,IAAI,QAAQ,EAAE;IAIrC,uEAAuE;IAChE,KAAK,IAAI,IAAI;IAMpB;;;;;;;;;OASG;IACI,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI;IAW/F;;;;OAIG;IACI,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,gBAAgB,GAAG,MAAM,GAAG,SAAS;IAInF;;;;;;;;;;;;;;;;;;;OAmBG;IACI,KAAK,CACR,gBAAgB,EAAE,GAAG,CAAC,QAAQ,CAAC,EAC/B,gBAAgB,EAAE,GAAG,CAAC,QAAQ,CAAC,EAC/B,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,EACtC,SAAS,EAAE,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC,GAAG,SAAS,EAChD,aAAa,EAAE,qBAAqB,EACpC,mBAAmB,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,MAAM,GACpD,IAAI;IAUP,OAAO,CAAC,aAAa;IA2BrB;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;CAwB3B"}
+{"version":3,"file":"ModuleCache.d.ts","sourceRoot":"","sources":["../../../src/frontend/common/ModuleCache.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,WAAW;IACpB,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,WAAW,CAAkB;IAErC;;;;OAIG;IACH,OAAO,CAAC,aAAa,CAA2D;IAEhF,mCAAmC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAOzC,kGAAkG;IAC3F,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAS3C,oDAAoD;IAC7C,GAAG,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IAIvC,0CAA0C;IACnC,IAAI,IAAI,MAAM;IAIrB,uCAAuC;IAChC,gBAAgB,IAAI,QAAQ,EAAE;IAIrC,uEAAuE;IAChE,KAAK,IAAI,IAAI;IAMpB;;;;;;;;;OASG;IACI,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI;IAW/F;;;;OAIG;IACI,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,gBAAgB,GAAG,MAAM,GAAG,SAAS;IAInF;;;;;;;;;;;;;;;;;;;OAmBG;IACI,KAAK,CACR,gBAAgB,EAAE,GAAG,CAAC,QAAQ,CAAC,EAC/B,gBAAgB,EAAE,GAAG,CAAC,QAAQ,CAAC,EAC/B,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,EACtC,SAAS,EAAE,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC,GAAG,SAAS,EAChD,aAAa,EAAE,qBAAqB,EACpC,mBAAmB,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,MAAM,GACpD,IAAI;IAUP,OAAO,CAAC,aAAa;IA2BrB;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;CAwB3B"}

package/lib/frontend/common/ModuleCache.js

@@ -24,6 +24,7 @@ exports.ModuleCache = void 0;
  * caller ({@link ModuleBuilder.evictIfNeeded}) handles the subsequent phases:
  * - **Phase 2** — downgrade protected dependencies to dependencyLoadLevel (release method
  *   bodies/AST, keep signatures), in reverse-topo order.
+ * - **Phase 2b** — further downgrade protected deps to INDEX (hollow in-place IR).
  * - **Phase 3** — if still over threshold, evict the protected dependencies (full unload),
  *   in reverse-topo order.
  *

package/lib/frontend/common/ModuleDepth.d.ts

@@ -1,28 +1,33 @@
 /**
- * Module data depth levels controlling how much data is built for ArkFile objects.
+ * Module data depth levels controlling how much data is retained for an {@link ArkModule}.
  * Higher levels are supersets of lower levels (incremental relationship).
  *
+ * Valid direct load targets ({@link ModuleAnalysisConfig} / {@link ModuleBuilder.loadModule}):
+ * {@link SIGNATURES} and {@link BODIES} only.
+ *
+ * {@link INDEX} is downgrade/fallback only: hollowed in-place ArkFile IR (export-reachable
+ * shells kept so import/type/RTA lookup APIs still work). Passing it to setLoadLevel /
+ * setDependencyLoadLevel / loadModule throws — do not use as a load target.
+ *
  * @category core/model
  */
 export declare enum ModuleDepthLevel {
     /**
-     * Level 0: Module metadata + dependency topology + ArkFile (path-only basic info).
-     * Index files (index.ets/index.ts) are exceptions: their ArkFile includes export/import info.
-     * Other files are NOT read or parsed.
-     */
-    META = 0,
-    /**
-     * Level 1: META + export/import info for ALL ArkFiles + intra-module file dependencies.
+     * Downgrade / fallback only: in-place hollow IR — bodies/AST/source stripped and
+     * non-exported classes pruned; {@link ArkFile}/{@link ArkClass}/{@link ArkMethod}
+     * shells remain queryable via the same Scene APIs as SIGNATURES.
+     * Not a valid direct load target.
      */
-    IMPORTS = 1,
+    INDEX = 0,
     /**
-     * Level 2: IMPORTS + ArkFile content excluding method bodies
-     * (namespaces, classes, method signatures, parameters, return types).
+     * Export/import info + namespaces/classes/method signatures (no method bodies).
      */
-    SIGNATURES = 2,
+    SIGNATURES = 1,
     /**
-     * Level 3: SIGNATURES + method bodies (ArkBody, CFG, Stmt/Expr).
+     * SIGNATURES + method bodies (ArkBody, CFG, Stmt/Expr).
      */
-    BODIES = 3
+    BODIES = 2
 }
+/** Throws if `level` is {@link ModuleDepthLevel.INDEX} (downgrade-only). */
+export declare function assertDirectLoadLevel(level: ModuleDepthLevel): void;
 //# sourceMappingURL=ModuleDepth.d.ts.map

package/lib/frontend/common/ModuleDepth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ModuleDepth.d.ts","sourceRoot":"","sources":["../../../src/frontend/common/ModuleDepth.ts"],"names":[],"mappings":"AAeA;;;;;GAKG;AACH,oBAAY,gBAAgB;IACxB;;;;OAIG;IACH,IAAI,IAAI;IAER;;OAEG;IACH,OAAO,IAAI;IAEX;;;OAGG;IACH,UAAU,IAAI;IAEd;;OAEG;IACH,MAAM,IAAI;CACb"}
+{"version":3,"file":"ModuleDepth.d.ts","sourceRoot":"","sources":["../../../src/frontend/common/ModuleDepth.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;GAYG;AACH,oBAAY,gBAAgB;IACxB;;;;;OAKG;IACH,KAAK,IAAI;IAET;;OAEG;IACH,UAAU,IAAI;IAEd;;OAEG;IACH,MAAM,IAAI;CACb;AAED,4EAA4E;AAC5E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAInE"}

package/lib/frontend/common/ModuleDepth.js

@@ -14,32 +14,42 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModuleDepthLevel = void 0;
+exports.assertDirectLoadLevel = exports.ModuleDepthLevel = void 0;
 /**
- * Module data depth levels controlling how much data is built for ArkFile objects.
+ * Module data depth levels controlling how much data is retained for an {@link ArkModule}.
  * Higher levels are supersets of lower levels (incremental relationship).
  *
+ * Valid direct load targets ({@link ModuleAnalysisConfig} / {@link ModuleBuilder.loadModule}):
+ * {@link SIGNATURES} and {@link BODIES} only.
+ *
+ * {@link INDEX} is downgrade/fallback only: hollowed in-place ArkFile IR (export-reachable
+ * shells kept so import/type/RTA lookup APIs still work). Passing it to setLoadLevel /
+ * setDependencyLoadLevel / loadModule throws — do not use as a load target.
+ *
  * @category core/model
  */
 var ModuleDepthLevel;
 (function (ModuleDepthLevel) {
     /**
-     * Level 0: Module metadata + dependency topology + ArkFile (path-only basic info).
-     * Index files (index.ets/index.ts) are exceptions: their ArkFile includes export/import info.
-     * Other files are NOT read or parsed.
-     */
-    ModuleDepthLevel[ModuleDepthLevel["META"] = 0] = "META";
-    /**
-     * Level 1: META + export/import info for ALL ArkFiles + intra-module file dependencies.
+     * Downgrade / fallback only: in-place hollow IR — bodies/AST/source stripped and
+     * non-exported classes pruned; {@link ArkFile}/{@link ArkClass}/{@link ArkMethod}
+     * shells remain queryable via the same Scene APIs as SIGNATURES.
+     * Not a valid direct load target.
      */
-    ModuleDepthLevel[ModuleDepthLevel["IMPORTS"] = 1] = "IMPORTS";
+    ModuleDepthLevel[ModuleDepthLevel["INDEX"] = 0] = "INDEX";
     /**
-     * Level 2: IMPORTS + ArkFile content excluding method bodies
-     * (namespaces, classes, method signatures, parameters, return types).
+     * Export/import info + namespaces/classes/method signatures (no method bodies).
      */
-    ModuleDepthLevel[ModuleDepthLevel["SIGNATURES"] = 2] = "SIGNATURES";
+    ModuleDepthLevel[ModuleDepthLevel["SIGNATURES"] = 1] = "SIGNATURES";
     /**
-     * Level 3: SIGNATURES + method bodies (ArkBody, CFG, Stmt/Expr).
+     * SIGNATURES + method bodies (ArkBody, CFG, Stmt/Expr).
      */
-    ModuleDepthLevel[ModuleDepthLevel["BODIES"] = 3] = "BODIES";
+    ModuleDepthLevel[ModuleDepthLevel["BODIES"] = 2] = "BODIES";
 })(ModuleDepthLevel = exports.ModuleDepthLevel || (exports.ModuleDepthLevel = {}));
+/** Throws if `level` is {@link ModuleDepthLevel.INDEX} (downgrade-only). */
+function assertDirectLoadLevel(level) {
+    if (level === ModuleDepthLevel.INDEX) {
+        throw new Error('ModuleDepthLevel.INDEX is not a direct load target; use SIGNATURES or BODIES');
+    }
+}
+exports.assertDirectLoadLevel = assertDirectLoadLevel;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arkanalyzer",
-  "version": "1.0.91",
+  "version": "1.0.92",
   "files": [
     "lib",
     "config"