arkanalyzer 1.0.94 → 2.0.0-beta1

package/lib/core/common/Builtin.d.ts

@@ -1,45 +1,69 @@
-import { ClassSignature, FileSignature, MethodSignature } from '../model/ArkSignature';
+import { ClassSignature, MethodSignature } from '../model/ArkSignature';
 import { ClassType } from '../base/Type';
 import { Scene } from '../../Scene';
+/**
+ * Built-in class name constants and signature stubs.
+ *
+ * Signatures created here are **unclear stubs** (declaring file = FileSignature.DEFAULT) that
+ * live in the temp canonicalizer. During type inference they are resolved to the real SDK
+ * signatures via the built-in library (see TypeInference.inferBaseType →
+ * SdkUtils.getSdkGlobal);
+ * when the SDK is unavailable (enableBuiltIn=false) they remain unresolved in temp space and
+ * are reported by checkTempSignatureCompleteness.
+ */
 export declare class Builtin {
     static OBJECT: string;
     static ARRAY: string;
-    static SET: string;
     static MAP: string;
+    static SET: string;
     static REGEXP: string;
     static BIGINT: string;
     static FUNCTION: string;
-    static BUILT_IN_CLASSES: Set<string>;
-    static DUMMY_PROJECT_NAME: string;
-    static DUMMY_FILE_NAME: string;
-    static BUILT_IN_CLASSES_FILE_SIGNATURE: FileSignature;
-    static OBJECT_CLASS_SIGNATURE: ClassSignature;
-    static OBJECT_CLASS_TYPE: ClassType;
-    static ARRAY_CLASS_SIGNATURE: ClassSignature;
-    static SET_CLASS_SIGNATURE: ClassSignature;
-    static MAP_CLASS_SIGNATURE: ClassSignature;
-    static REGEXP_CLASS_SIGNATURE: ClassSignature;
-    static REGEXP_CLASS_TYPE: ClassType;
-    static BUILT_IN_CLASS_SIGNATURE_MAP: Map<string, ClassSignature>;
     static ITERATOR_FUNCTION: string;
     static ITERATOR: string;
     static ITERATOR_NEXT: string;
     static ITERATOR_RESULT: string;
     static ITERATOR_RESULT_DONE: string;
     static ITERATOR_RESULT_VALUE: string;
-    static ITERATOR_CLASS_SIGNATURE: ClassSignature;
-    static ITERATOR_RESULT_CLASS_SIGNATURE: ClassSignature;
-    static ITERATOR_CLASS_TYPE: ClassType;
-    static ITERATOR_RESULT_CLASS_TYPE: ClassType;
     static TO_STRING: string;
-    static TO_STRING_METHOD_SIGNATURE: MethodSignature;
     static SLICE: string;
     static CONCAT: string;
-    private static buildBuiltInClasses;
-    private static buildBuiltInClassesFileSignature;
-    static buildBuiltInClassSignature(className: string): ClassSignature;
-    private static buildBuiltInClassSignatureMap;
-    static isBuiltinClass(className: string): boolean;
+    /**
+     * Lazy per-name cache of unclear stub signatures. Stubs hold no registry-dependent state
+     * (the declaring file SigID is the literal 0, rebuilt as DEFAULT in every registry
+     * lifecycle), so the instances are dispose-stable: after dispose(), the rebuilt temp
+     * canonicalizer assigns them fresh IDs via its new objectIdentity symbol (the old symbol
+     * property is cleaned by Canonicalizer.clear()).
+     */
+    private static stubCache;
+    /** Unclear stub signature for a built-in class name (shared instance per name). */
+    static getBuiltinClassSignature(className: string): ClassSignature;
+    /** @internal Snapshot of the cached unclear stubs — the validator's reachability baseline
+     * for the temp class space (stubs are legitimately held by this cache; they are producers,
+     * not holders with a temp registration mark, so they are exempt from anchor checks). */
+    static getStubCacheEntries(): ClassSignature[];
+    static get OBJECT_CLASS_SIGNATURE(): ClassSignature;
+    static get OBJECT_CLASS_TYPE(): ClassType;
+    static get ARRAY_CLASS_SIGNATURE(): ClassSignature;
+    static get REGEXP_CLASS_SIGNATURE(): ClassSignature;
+    static get REGEXP_CLASS_TYPE(): ClassType;
+    static get ITERATOR_CLASS_SIGNATURE(): ClassSignature;
+    static get ITERATOR_RESULT_CLASS_SIGNATURE(): ClassSignature;
+    static get ITERATOR_CLASS_TYPE(): ClassType;
+    static get ITERATOR_RESULT_CLASS_TYPE(): ClassType;
+    /**
+     * The stub method signature for `toString` on Object. Each access returns a fresh
+     * MethodSignature over the shared Object stub.
+     *
+     * 教训存档，勿再尝试单例化
+     */
+    static get TO_STRING_METHOD_SIGNATURE(): MethodSignature;
+    private static arrayStubMethodSignatures;
+    static clearStubMethodSigCaches(): void;
+    /**
+     * Array stub 方法签名（不查 SDK——`(Array stub, name)` 恒 stub 值）的 per-name 实例缓存
+     */
+    static getOrCreateArrayStubMethodSignature(methodName: string): MethodSignature;
     static buildArrayMethodSignature(methodName: string, scene: Scene): MethodSignature;
     static getBuiltInMethodSignature(className: string, methodName: string, scene: Scene): MethodSignature | undefined;
 }

package/lib/core/common/Builtin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Builtin.d.ts","sourceRoot":"","sources":["../../../src/core/common/Builtin.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,eAAe,EAAsB,MAAM,uBAAuB,CAAC;AAC3G,OAAO,EAAE,SAAS,EAAwC,MAAM,cAAc,CAAC;AAC/E,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGpC,qBAAa,OAAO;IAGhB,OAAc,MAAM,SAAY;IAChC,OAAc,KAAK,SAAW;IAC9B,OAAc,GAAG,SAAS;IAC1B,OAAc,GAAG,SAAS;IAC1B,OAAc,MAAM,SAAY;IAChC,OAAc,MAAM,SAAY;IAChC,OAAc,QAAQ,SAAc;IAEpC,OAAc,gBAAgB,cAA8B;IAG5D,OAAc,kBAAkB,SAAY;IAC5C,OAAc,eAAe,SAAkB;IAE/C,OAAc,+BAA+B,gBAA8C;IAC3F,OAAc,sBAAsB,iBAAgD;IACpF,OAAc,iBAAiB,YAA8C;IAC7E,OAAc,qBAAqB,iBAA+C;IAClF,OAAc,mBAAmB,iBAA6C;IAC9E,OAAc,mBAAmB,iBAA6C;IAC9E,OAAc,sBAAsB,iBAAgD;IACpF,OAAc,iBAAiB,YAA8C;IAC7E,OAAc,4BAA4B,8BAAwC;IAGlF,OAAc,iBAAiB,SAAqB;IACpD,OAAc,QAAQ,SAAsB;IAC5C,OAAc,aAAa,SAAU;IACrC,OAAc,eAAe,SAAoB;IACjD,OAAc,oBAAoB,SAAU;IAC5C,OAAc,qBAAqB,SAAW;IAE9C,OAAc,wBAAwB,iBAAkD;IACxF,OAAc,+BAA+B,iBAAyD;IACtG,OAAc,mBAAmB,YAAwE;IACzG,OAAc,0BAA0B,YAA+E;IAGvH,OAAc,SAAS,SAAc;IACrC,OAAc,0BAA0B,kBAGtC;IAGF,OAAc,KAAK,SAAW;IAC9B,OAAc,MAAM,SAAY;IAEhC,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAUlC,OAAO,CAAC,MAAM,CAAC,gCAAgC;WAIjC,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc;IAI3E,OAAO,CAAC,MAAM,CAAC,6BAA6B;WAU9B,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;WAI1C,yBAAyB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,eAAe;WAQ5E,yBAAyB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,eAAe,GAAG,SAAS;CAO5H"}
+{"version":3,"file":"Builtin.d.ts","sourceRoot":"","sources":["../../../src/core/common/Builtin.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,cAAc,EAAE,eAAe,EAAsB,MAAM,uBAAuB,CAAC;AAC5F,OAAO,EAAE,SAAS,EAAwC,MAAM,cAAc,CAAC;AAC/E,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAIpC;;;;;;;;;GASG;AACH,qBAAa,OAAO;IAEhB,OAAc,MAAM,SAAY;IAChC,OAAc,KAAK,SAAW;IAC9B,OAAc,GAAG,SAAS;IAC1B,OAAc,GAAG,SAAS;IAC1B,OAAc,MAAM,SAAY;IAChC,OAAc,MAAM,SAAY;IAChC,OAAc,QAAQ,SAAc;IAGpC,OAAc,iBAAiB,SAAqB;IACpD,OAAc,QAAQ,SAAsB;IAC5C,OAAc,aAAa,SAAU;IACrC,OAAc,eAAe,SAAoB;IACjD,OAAc,oBAAoB,SAAU;IAC5C,OAAc,qBAAqB,SAAW;IAG9C,OAAc,SAAS,SAAc;IAGrC,OAAc,KAAK,SAAW;IAC9B,OAAc,MAAM,SAAY;IAIhC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,SAAS,CAA0C;IAElE,mFAAmF;WACrE,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc;IASzE;;4FAEwF;WAC1E,mBAAmB,IAAI,cAAc,EAAE;IAIrD,WAAkB,sBAAsB,IAAI,cAAc,CAEzD;IACD,WAAkB,iBAAiB,IAAI,SAAS,CAE/C;IACD,WAAkB,qBAAqB,IAAI,cAAc,CAExD;IACD,WAAkB,sBAAsB,IAAI,cAAc,CAEzD;IACD,WAAkB,iBAAiB,IAAI,SAAS,CAE/C;IAED,WAAkB,wBAAwB,IAAI,cAAc,CAE3D;IACD,WAAkB,+BAA+B,IAAI,cAAc,CAElE;IACD,WAAkB,mBAAmB,IAAI,SAAS,CAEjD;IACD,WAAkB,0BAA0B,IAAI,SAAS,CAExD;IAED;;;;;OAKG;IACH,WAAkB,0BAA0B,IAAI,eAAe,CAE9D;IAED,OAAO,CAAC,MAAM,CAAC,yBAAyB,CAAsC;WAEhE,wBAAwB,IAAI,IAAI;IAI9C;;OAEG;WACW,mCAAmC,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe;WASxE,yBAAyB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,eAAe;WAQ5E,yBAAyB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,eAAe,GAAG,SAAS;CAO5H"}

package/lib/core/common/Builtin.js

@@ -13,80 +13,113 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Builtin = void 0;
 const ArkSignature_1 = require("../model/ArkSignature");
 const Type_1 = require("../base/Type");
 const ArkClass_1 = require("../model/ArkClass");
+const SdkUtils_1 = require("./SdkUtils");
+/**
+ * Built-in class name constants and signature stubs.
+ *
+ * Signatures created here are **unclear stubs** (declaring file = FileSignature.DEFAULT) that
+ * live in the temp canonicalizer. During type inference they are resolved to the real SDK
+ * signatures via the built-in library (see TypeInference.inferBaseType →
+ * SdkUtils.getSdkGlobal);
+ * when the SDK is unavailable (enableBuiltIn=false) they remain unresolved in temp space and
+ * are reported by checkTempSignatureCompleteness.
+ */
 class Builtin {
-    static buildBuiltInClasses() {
-        const builtInClasses = new Set();
-        builtInClasses.add(this.OBJECT);
-        builtInClasses.add(this.ARRAY);
-        builtInClasses.add(this.SET);
-        builtInClasses.add(this.MAP);
-        builtInClasses.add(this.REGEXP);
-        return builtInClasses;
-    }
-    static buildBuiltInClassesFileSignature() {
-        return new ArkSignature_1.FileSignature(this.DUMMY_PROJECT_NAME, this.DUMMY_FILE_NAME);
-    }
-    static buildBuiltInClassSignature(className) {
-        return new ArkSignature_1.ClassSignature(className, this.BUILT_IN_CLASSES_FILE_SIGNATURE);
-    }
-    static buildBuiltInClassSignatureMap() {
-        const builtInClassSignatureMap = new Map();
-        builtInClassSignatureMap.set(this.OBJECT, this.OBJECT_CLASS_SIGNATURE);
-        builtInClassSignatureMap.set(this.ARRAY, this.ARRAY_CLASS_SIGNATURE);
-        builtInClassSignatureMap.set(this.SET, this.SET_CLASS_SIGNATURE);
-        builtInClassSignatureMap.set(this.MAP, this.MAP_CLASS_SIGNATURE);
-        builtInClassSignatureMap.set(this.REGEXP, this.REGEXP_CLASS_SIGNATURE);
-        return builtInClassSignatureMap;
-    }
-    static isBuiltinClass(className) {
-        return this.BUILT_IN_CLASSES.has(className);
+    /** Unclear stub signature for a built-in class name (shared instance per name). */
+    static getBuiltinClassSignature(className) {
+        let stub = this.stubCache.get(className);
+        if (stub === undefined) {
+            stub = new ArkSignature_1.ClassSignature(className, 0, undefined);
+            this.stubCache.set(className, stub);
+        }
+        return stub;
+    }
+    /** @internal Snapshot of the cached unclear stubs — the validator's reachability baseline
+     * for the temp class space (stubs are legitimately held by this cache; they are producers,
+     * not holders with a temp registration mark, so they are exempt from anchor checks). */
+    static getStubCacheEntries() {
+        return Array.from(this.stubCache.values());
+    }
+    static get OBJECT_CLASS_SIGNATURE() {
+        return this.getBuiltinClassSignature(this.OBJECT);
+    }
+    static get OBJECT_CLASS_TYPE() {
+        return new Type_1.ClassType(this.OBJECT_CLASS_SIGNATURE);
+    }
+    static get ARRAY_CLASS_SIGNATURE() {
+        return this.getBuiltinClassSignature(this.ARRAY);
+    }
+    static get REGEXP_CLASS_SIGNATURE() {
+        return this.getBuiltinClassSignature(this.REGEXP);
+    }
+    static get REGEXP_CLASS_TYPE() {
+        return new Type_1.ClassType(this.REGEXP_CLASS_SIGNATURE);
+    }
+    static get ITERATOR_CLASS_SIGNATURE() {
+        return this.getBuiltinClassSignature(this.ITERATOR);
+    }
+    static get ITERATOR_RESULT_CLASS_SIGNATURE() {
+        return this.getBuiltinClassSignature(this.ITERATOR_RESULT);
+    }
+    static get ITERATOR_CLASS_TYPE() {
+        return new Type_1.ClassType(this.ITERATOR_CLASS_SIGNATURE, [new Type_1.GenericType('T')]);
+    }
+    static get ITERATOR_RESULT_CLASS_TYPE() {
+        return new Type_1.ClassType(this.ITERATOR_RESULT_CLASS_SIGNATURE, [new Type_1.GenericType('T')]);
+    }
+    /**
+     * The stub method signature for `toString` on Object. Each access returns a fresh
+     * MethodSignature over the shared Object stub.
+     *
+     * 教训存档，勿再尝试单例化
+     */
+    static get TO_STRING_METHOD_SIGNATURE() {
+        return new ArkSignature_1.MethodSignature(this.OBJECT_CLASS_SIGNATURE, new ArkSignature_1.MethodSubSignature(this.TO_STRING, [], Type_1.StringType.getInstance(), false));
+    }
+    static clearStubMethodSigCaches() {
+        this.arrayStubMethodSignatures.clear();
+    }
+    /**
+     * Array stub 方法签名（不查 SDK——`(Array stub, name)` 恒 stub 值）的 per-name 实例缓存
+     */
+    static getOrCreateArrayStubMethodSignature(methodName) {
+        let sig = this.arrayStubMethodSignatures.get(methodName);
+        if (sig === undefined) {
+            sig = new ArkSignature_1.MethodSignature(Builtin.ARRAY_CLASS_SIGNATURE, new ArkSignature_1.MethodSubSignature(methodName, [], Type_1.UnknownType.getInstance(), false));
+            this.arrayStubMethodSignatures.set(methodName, sig);
+        }
+        return sig;
     }
     static buildArrayMethodSignature(methodName, scene) {
         let methodSignature = this.getBuiltInMethodSignature(Builtin.ARRAY, methodName, scene);
         if (!methodSignature) {
-            methodSignature = new ArkSignature_1.MethodSignature(Builtin.ARRAY_CLASS_SIGNATURE, new ArkSignature_1.MethodSubSignature(methodName, [], Type_1.UnknownType.getInstance(), false));
+            methodSignature = this.getOrCreateArrayStubMethodSignature(methodName);
         }
         return methodSignature;
     }
     static getBuiltInMethodSignature(className, methodName, scene) {
-        var _b;
-        const globalClass = scene.getSdkGlobal(className);
+        var _a;
+        const globalClass = SdkUtils_1.SdkUtils.getSdkGlobal(className);
         if (globalClass instanceof ArkClass_1.ArkClass) {
-            return (_b = globalClass.getMethodWithName(methodName)) === null || _b === void 0 ? void 0 : _b.getSignature();
+            return (_a = globalClass.getMethodWithName(methodName)) === null || _a === void 0 ? void 0 : _a.getSignature();
         }
         return undefined;
     }
 }
 exports.Builtin = Builtin;
-_a = Builtin;
 // built-in classes
-// TODO: Automatically obtain from the standard library
 Builtin.OBJECT = 'Object';
 Builtin.ARRAY = 'Array';
-Builtin.SET = 'Set';
 Builtin.MAP = 'Map';
+Builtin.SET = 'Set';
 Builtin.REGEXP = 'RegExp';
 Builtin.BIGINT = 'BigInt';
 Builtin.FUNCTION = 'Function';
-Builtin.BUILT_IN_CLASSES = _a.buildBuiltInClasses();
-// signature for built-in class
-Builtin.DUMMY_PROJECT_NAME = 'ES2015';
-Builtin.DUMMY_FILE_NAME = 'BuiltinClass';
-Builtin.BUILT_IN_CLASSES_FILE_SIGNATURE = Builtin.buildBuiltInClassesFileSignature();
-Builtin.OBJECT_CLASS_SIGNATURE = _a.buildBuiltInClassSignature(_a.OBJECT);
-Builtin.OBJECT_CLASS_TYPE = new Type_1.ClassType(_a.OBJECT_CLASS_SIGNATURE);
-Builtin.ARRAY_CLASS_SIGNATURE = _a.buildBuiltInClassSignature(_a.ARRAY);
-Builtin.SET_CLASS_SIGNATURE = _a.buildBuiltInClassSignature(_a.SET);
-Builtin.MAP_CLASS_SIGNATURE = _a.buildBuiltInClassSignature(_a.MAP);
-Builtin.REGEXP_CLASS_SIGNATURE = _a.buildBuiltInClassSignature(_a.REGEXP);
-Builtin.REGEXP_CLASS_TYPE = new Type_1.ClassType(_a.REGEXP_CLASS_SIGNATURE);
-Builtin.BUILT_IN_CLASS_SIGNATURE_MAP = _a.buildBuiltInClassSignatureMap();
 // constants for iterator
 Builtin.ITERATOR_FUNCTION = 'Symbol.iterator';
 Builtin.ITERATOR = 'IterableIterator';
@@ -94,13 +127,18 @@ Builtin.ITERATOR_NEXT = 'next';
 Builtin.ITERATOR_RESULT = 'IteratorResult';
 Builtin.ITERATOR_RESULT_DONE = 'done';
 Builtin.ITERATOR_RESULT_VALUE = 'value';
-Builtin.ITERATOR_CLASS_SIGNATURE = _a.buildBuiltInClassSignature(_a.ITERATOR);
-Builtin.ITERATOR_RESULT_CLASS_SIGNATURE = _a.buildBuiltInClassSignature(_a.ITERATOR_RESULT);
-Builtin.ITERATOR_CLASS_TYPE = new Type_1.ClassType(_a.ITERATOR_CLASS_SIGNATURE, [new Type_1.GenericType('T')]);
-Builtin.ITERATOR_RESULT_CLASS_TYPE = new Type_1.ClassType(_a.ITERATOR_RESULT_CLASS_SIGNATURE, [new Type_1.GenericType('T')]);
 // constants for string
 Builtin.TO_STRING = 'toString';
-Builtin.TO_STRING_METHOD_SIGNATURE = new ArkSignature_1.MethodSignature(ArkSignature_1.ClassSignature.DEFAULT, new ArkSignature_1.MethodSubSignature(_a.TO_STRING, [], Type_1.StringType.getInstance(), false));
 // constants for array
 Builtin.SLICE = 'slice';
 Builtin.CONCAT = 'concat';
+// --- Stable unclear stubs (shared per name) ---
+/**
+ * Lazy per-name cache of unclear stub signatures. Stubs hold no registry-dependent state
+ * (the declaring file SigID is the literal 0, rebuilt as DEFAULT in every registry
+ * lifecycle), so the instances are dispose-stable: after dispose(), the rebuilt temp
+ * canonicalizer assigns them fresh IDs via its new objectIdentity symbol (the old symbol
+ * property is cleaned by Canonicalizer.clear()).
+ */
+Builtin.stubCache = new Map();
+Builtin.arrayStubMethodSignatures = new Map();

package/lib/core/common/CanonicalizerValidator.d.ts

@@ -0,0 +1,308 @@
+/**
+ * 签名 canonicalizer 的内部结构校验器（仅开发调试用）。
+ *
+ * 每个 formal 空间的校验规则互不相同（class 空间存在别名折叠语义、method 空间存在
+ * declare-only 合法无 model 条目等），因此各空间独立实现各自的 validateXxxSpace，
+ * 不做统一泛型模板；待多个空间落地后若出现真实重复，再抽取公共部分。
+ *
+ * 通过 `SceneOptions.validateCanonicalizers` 开启（默认关闭）。
+ */
+export declare class CanonicalizerValidator {
+    /**
+     * 校验 formal file 空间的结构不变量，规则如下：
+     *
+     * R1a  DEFAULT 保留位契约（正向断言）：ID 0 必须存在 DEFAULT 签名条目。
+     *      缺失说明 registry 初始化损坏（internDefaults 未执行或被破坏）。
+     *
+     * R1b  DEFAULT 保留位契约（正向断言）：ID 0 的 model 必须为 undefined。
+     *      models[0] 设计上永久空置（registerFile 有 id > 0 守卫）；若被绕过守卫
+     *      直接 setModel(0, ...) 挂载，视为保留位被侵占。
+     *
+     * R2   ID 稠密性：[1, size) 内每个 ID 都必须有签名条目。
+     *      出现空洞说明条目结构损坏（理论上不可达，防御性检查）。
+     *
+     * R3   model 完备性：[1, size) 内每个 ID 必须有对应的 ArkFile model。
+     *      两种可能来路：① disposeModule 驱逐态（removeFile 删 model 留 sig，合法、
+     *      可 reload 自愈）；② 新代码引入的空洞（bug）。本工具不区分二者，
+     *      全部报告，由开发者结合场景判断。
+     *
+     * R4   model 回指一致性：挂载在 ID i 的 ArkFile，其 getFileSigID() 必须等于 i。
+     *      回指不一致会导致查询路径走 stale 兜底（error 日志 + 返回 DEFAULT）。
+     *
+     * R5   签名值唯一性：任意两个不同 ID 不得持有 equals() 相等的签名。
+     *      canonicalizer 本身按 hash+equals 去重，正常情况下同值必同 ID；本规则
+     *      违规当且仅当 hash/equals 契约破裂（如给 FileSignature 加字段进了 equals
+     *      忘了进 hash）。契约保证"equals 相等 → hash 相等"，故违规对必落在同一
+     *      hash 分组内，按 hashCode 分组后组内两两比较即可，均摊 O(n)。
+     *      ID 0 的 DEFAULT 签名参与分组比较——这是值域坍缩不变量的守卫：所有用
+     *      UNKNOWN 常量（%unk/%unk）构造的签名必须 intern 到 ID 0，不得出现第二个。
+     *
+     * R6   model 挂载唯一性：同一 ArkFile 实例不得挂载于多个 ID。
+     *      双挂载意味着模型索引错乱，Scene.getFile 查询结果将不一致。
+     *
+     * R7   project/SDK ID 边界一致性（仅边界已设置时检查，见
+     *      SignatureCanonicalizerRegistry.markProjectFileBoundary）：
+     *      [1, first) 内有 model 的 ID，其 isProjectFile() 必须为 false；
+     *      [first, size) 内有 model 的 ID，其 isProjectFile() 必须为 true。
+     *      违反说明构建时序回归（如边界设置后仍有 SDK 文件注册）或 ArkFile 的
+     *      projectFile 标志被误标。ID 0（DEFAULT）不参与本规则。
+     *
+     * 执行语义：所有规则全量执行、任何违规不中断；违规逐条收集（规则号 + ID +
+     * 签名描述），一次性汇总报告——无论违规多少都给出完整清单。全部规则均为
+     * error 级：任何一条违规即意味着某项不变量被打破。
+     *
+     * @returns 全部违规描述（空数组 = 空间干净）。
+     */
+    static validateFileSpace(): string[];
+    /** R2–R7：单 ID 条目级校验（R5 仅累积分组，组内比较在 {@link checkSignatureValueUniqueness}）。 */
+    private static checkFileEntry;
+    /**
+     * 校验 formal namespace 空间的结构不变量，规则如下：
+     *
+     * N1a  DEFAULT 保留位契约（正向断言）：ID 0 必须存在 DEFAULT 签名条目。
+     *
+     * N1b  DEFAULT 保留位契约（正向断言）：ID 0 的 model 必须为 undefined。
+     *
+     * N2   ID 稠密性：[1, size) 内每个 ID 都必须有签名条目。
+     *
+     * N3   model 完备性：[1, size) 内每个 ID 必须有对应的 ArkNamespace model。
+     *      两种可能来路：① disposeModule 驱逐态（removeNamespace 删 model 留 sig，
+     *      合法、可 reload 自愈）；② 签名值仅被惰性 intern（NamespaceSignature.
+     *      getNamespaceSigID）而无真实 ArkNamespace 注册——ArkNamespace.setSignature
+     *      已带自愈补挂，出现即为新路径逃逸。全部报告，由开发者结合场景判断。
+     *
+     * N4   model 回指一致性：挂载在 ID i 的 ArkNamespace，其 getNamespaceSigID()
+     *      必须等于 i。
+     *
+     * N5   签名值唯一性：任意两个不同 ID 不得持有 equals() 相等的签名（守卫
+     *      hash/equals 契约与 DEFAULT 值域坍缩；原理同 file 空间 R5）。
+     *
+     * N6   model 挂载唯一性：同一 ArkNamespace 实例不得挂载于多个 ID。
+     *
+     * N7   链完整性（仅对 model 存活的条目检查；驱逐态条目的链检查跳过——N3 已
+     *      报告其驱逐，父/子链完整性以存活侧为准）：
+     *      N7a  嵌套 ns：declaringNamespaceSigID 非 undefined 时，父 namespace 的
+     *          model 必须存在（disposeModule 同文件整树驱逐，父驱逐子存活 = 驱逐
+     *          不完整或手工构造逃逸）；
+     *      N7b  嵌套 ns：父 model 的 top 列表必须含本 ID（父子互联正确）；
+     *      N7c  顶层 ns：declaringNamespaceSigID 为 undefined 时，declaring file
+     *          的 model 必须存在且其 top 列表含本 ID（file 侧互联正确）。
+     *
+     * 执行语义：所有规则全量执行、任何违规不中断；违规逐条收集（规则号 + ID +
+     * 签名描述），一次性汇总报告。全部规则均为 error 级。
+     *
+     * @returns 全部违规描述（空数组 = 空间干净）。
+     */
+    static validateNamespaceSpace(): string[];
+    /** N2–N7：单 ID 条目级校验（N5 仅累积分组，组内比较在 {@link checkSignatureValueUniqueness}）。 */
+    private static checkNamespaceEntry;
+    /** N7a/N7b/N7c：挂载链完整性（仅存活条目；嵌套 ns 查父链，顶层 ns 查 declaring file 链）。 */
+    private static checkNamespaceChain;
+    /**
+     * 校验 formal class 空间的结构不变量，规则如下：
+     *
+     * C1a  DEFAULT 保留位契约（正向断言）：ID 0 必须存在 DEFAULT 签名条目。
+     *
+     * C1b  DEFAULT 保留位契约（正向断言）：ID 0 的 model 必须为 undefined。
+     *
+     * C2   ID 稠密性：[1, size) 内每个 ID 都必须有签名条目（防御性检查）。
+     *
+     * C3   model 完备性：[1, size) 内每个 ID 必须有对应的 ArkClass model。
+     *      两种可能来路：① disposeModule 驱逐态（removeClassModel 删 model 留 sig，合法、可 reload 自愈）；② 显式 getId intern 无 model——生产路径不产生
+     *      此形态（formal 只读命中 / temp 弱注册兜底，写入点收敛为 internDefaults + ArkClass.setSignature），出现即为 tests 手工构造或未来新代码逃逸
+     *      （ArkClass.setSignature 的 existing≥0 分支不注册语义由本规则持续守护）。全部报告，开发者判别。
+     *
+     * C4   model 回指一致性：挂载在 ID i 的 ArkClass，其 getClassSigID() 必须
+     *      等于 i。
+     *
+     * C5   签名值唯一性：任意两个不同 ID 不得持有 equals() 相等的签名（守卫
+     *      hash/equals 契约与 DEFAULT 值域坍缩；原理同 file R5）。
+     *      注：display 归一化后 AliasClassSignature 的 aliasName **参与** equals/hash——alias 是独立 formal 条目（同 aliasName+同 origin 维度折叠、异名/
+     *      与 origin 互不相等），本规则即守护该独立 ID 语义（两个 alias ID 值相等 = 契约破坏）。
+     *
+     * C6   model 挂载唯一性：同一 ArkClass 实例不得挂载于多个 ID。
+     *
+     * C7   挂载链完整性（仅对 model 存活条目检查；驱逐态条目链检查跳过——C3 已
+     *      报告其驱逐，链完整性以存活侧为准；单 Scene 单次构建生命周期声明覆盖）：
+     *      C7a  嵌套类：declaringNamespaceSigID 非 undefined 时，父 namespace
+     *           的 model 必须存在（父驱逐子存活 = 驱逐不完整或手工构造逃逸）；
+     *      C7b  嵌套类：父 ns 的 topClass 列表必须含本 ID（hasTopClassWithID）；
+     *      C7c  顶层类：declaring file 的 model 必须存在且其 topClass 列表
+     *           含本 ID。
+     *
+     * 执行语义：所有规则全量执行、任何违规不中断；违规逐条收集（规则号 + ID +
+     * 签名描述），一次性汇总报告。全部规则均为 error 级。
+     *
+     * @returns 全部违规描述（空数组 = 空间干净）。
+     */
+    static validateClassSpace(): string[];
+    /** C2–C7：单 ID 条目级校验（C5 仅累积分组，组内比较在 {@link checkSignatureValueUniqueness}；alias 条目豁免 C4/C6/链检查）。 */
+    private static checkClassEntry;
+    /** C7a/C7b/C7c：挂载链完整性（仅存活条目；alias 条目豁免——挂载链以 origin 条目为准）。 */
+    private static checkClassChain;
+    /**
+     * 校验 formal field 空间的结构不变量，规则如下：
+     *
+     * F1a  DEFAULT 保留位契约（正向断言）：ID 0 必须存在 DEFAULT 签名条目。
+     *
+     * F1b  DEFAULT 保留位契约（正向断言）：ID 0 的 model 必须为 undefined。
+     *
+     * F2   ID 稠密性：[1, size) 内每个 ID 都必须有签名条目（防御性检查）。
+     *
+     * F3   model 完备性：[1, size) 内每个 ID 必须有对应的 ArkField model。
+     *      两种可能来路：① 驱逐态（disposeModule / pruneNonKeptClasses 的
+     *      removeField 删 model 留 sig，合法、reload 由 addField 兜底自愈——
+     *      窗口期报告属预期）；② 引用侧 namespace 声明签名（genFieldSignature
+     *      等构造的 ns 重载，无 ArkField model，值语义合法形态）及未来新代码
+     *      逃逸。全部报告，由开发者结合场景判断。
+     *
+     * F4   model 回指一致性：挂载在 ID i 的 ArkField，其 getFieldSigID() 必须
+     *      等于 i（field 单轨——无 method 空间的 impl/declare 双槽复杂度）。
+     *
+     * F4b  双侧声明类一致性：model.getDeclaringClassID() 必须等于
+     *      sig.getDeclaringClassSigID()（ArkField 与 FieldSignature 独立维护
+     *      两处 declaring ClassSigID，能抓 builder 不一致 bug）。
+     *      注意 breakInternalReferences 将 declaringClassID 置 -1 的窗口形态
+     *      （unload 后半，model 残留期）——该形态同时被 F3（若 model 已删）
+     *      或本规则（model 仍在但 ID=-1）捕获，属驱逐窗口预期报告。
+     *
+     * F5   签名值唯一性：任意两个不同 ID 不得持有 equals() 相等的签名
+     *      （hash 分组 + 组内两两比较；ID 0 种入守卫 DEFAULT 值域坍缩）。
+     *      注记：type 不参与身份（equals/hashCode 只含 fieldName + staticFlag +
+     *      四个 declaring SigID）；setType/setStaticFlag 可在 intern 后原地改值
+     *      且不重算 hash（hash-equal 是 equals-equal 的合法超集，算法不受影响）。
+     *
+     * F6   model 挂载唯一性：同一 ArkField 实例不得挂载于多个 ID（按 model 槽
+     *      唯一口径——AbcInference 同名重复推断产生的非 model 别名实例是值语义
+     *      合法形态，不属违规）。
+     *
+     * F7   挂载链完整性（仅对 model 存活条目检查）：
+     *      F7a  declaring class 的 model 必须存在（class 驱逐后 field 存活 =
+     *           驱逐不完整——P0 修复后此形态应仅出现在合法驱逐窗口之外）；
+     *      F7b  该 class 的字段索引必须含本 ID：hasTopFieldWithID(i) ||
+     *           hasTopStaticFieldWithID(i)——联合判定（不区分数组）：index
+     *           signature 存在签名 staticFlag=true 但按 modifier tag 挂实例
+     *           数组的既有不一致形态，联合判定免误报。
+     *      注记：model 侧不存在 namespace 声明的 ArkField（ns 声明签名仅在引用侧，无 F7 的 ns 分支）；查询走 sig.getDeclaringClassSigID() formal 直查
+     *      （不经 declaringSignatureDisplay——display 归一化后 declaringClass 为 AliasClassSignature 时 SigID 是独立的 alias ID，formal 直查命中 alias 条目，
+     *      display 仅影响展示）。
+     *
+     * 执行语义：所有规则全量执行、任何违规不中断；违规逐条收集（规则号 + ID +
+     * 签名描述），一次性汇总报告。全部规则均为 error 级。
+     *
+     * @returns 全部违规描述（空数组 = 空间干净）。
+     */
+    static validateFieldSpace(): string[];
+    /** F2–F7：单 ID 条目级校验（F5 仅累积分组，组内比较在 {@link checkSignatureValueUniqueness}）。 */
+    private static checkFieldEntry;
+    /** F7a/F7b：挂载链完整性（仅存活条目——declaring class model 存在 + 类字段索引联合判定）。 */
+    private static checkFieldChain;
+    /**
+     * 校验 formal method 空间的结构不变量，规则如下：
+     *
+     * 前置设计契约（闭包双签名，BodyBuilder.updateNestedMethodWithClosures 的
+     * 终态为设计行为）：重签后 model[id1]=M（旧签名，类索引锚定——枚举入口）
+     * 与 model[id2]=M（新签名含闭包参数——invoke expr 消费面）双注册合法，
+     * topMethodSigIDs 持 id1 不变、id2 不入索引（保证 getMethods 枚举唯一，
+     * 实测 ENUM-DUP=0）。
+     *
+     * M1a  DEFAULT 保留位契约（正向断言）：ID 0 必须存在 DEFAULT 签名条目。
+     *
+     * M1b  DEFAULT 保留位契约（正向断言）：ID 0 的 model 必须为 undefined。
+     *
+     * M2   ID 稠密性：[1, size) 内每个 ID 都必须有签名条目（防御性检查）。
+     *
+     * M3   model 完备性：无 model 的条目按 declaring class 存活判定分类——declaring class 的 model 存活 → 视为 declare-only 合法态跳过（实证：SDK 接口
+     *      overload 声明条目（如 ObjectConstructor.create/freeze 的非首声明）与闭包 declare 重签产物均为此形态，单资源达千条量级，属构建常态而非洞）；
+     *      declaring class 不明（-1/0）或 class model 已删（驱逐窗口外）→ 报告。驱逐窗口内的条目随 reload 由 addMethod 兜底自愈。
+     *
+     * M4   挂载槽一致性（方法级三方持有，闭包双签名适配）：model[i] 存在时，
+     *      i === M.getMethodSigID() ∨ M.declareSigIDs ∋ i ∨ 某存活类方法索引
+     *      ∋ i。闭包 id1 经索引持有 ✓、id2 经 self-id ✓；违规 = 孤儿挂载
+     *      （无任何持有方的 model 残留，如驱逐窗口 legacy 槽）。
+     *
+     * M4b  双侧声明类一致：model.getDeclaringClassID() === sig 的
+     *      declaringClassSigID（独立双维护点，抓 builder 不同步）。copyMembers
+     *      跨类挂载双侧同指 from 类 → 不误报 ✓。
+     *
+     * M5   签名值唯一（hash 分组 + 组内两两 equals，ID 0 种入守卫值域坍缩）。
+     *      注记：declaringClassTempSigID 参与 equals——temp 版与 formal 版是
+     *      合法分裂条目非重复；returnType 进 equals 不进 hash（仅返回类型不同
+     *      的重载合法分 ID）。
+     *
+     * M6   反向链检查（非实例唯一——闭包双挂载已合法化）：存活类方法索引
+     *      （含 default/init 三个旁路 ID 字段）的每个条目 ID 必须有 model
+     *      （抓索引断链：驱逐 desync、索引损坏）。
+     *
+     * M7   declaring class model 存在（sig 侧 -1 temp / 0 跳过并注记；
+     *      class 驱逐后 method 存活 = 驱逐不完整形态）。
+     *
+     * 执行语义：所有规则全量执行、任何违规不中断；违规逐条收集（规则号 + ID +
+     * 签名描述），一次性汇总报告。全部规则均为 error 级。
+     *
+     * @returns 全部违规描述（空数组 = 空间干净）。
+     */
+    static validateMethodSpace(): string[];
+    /** M4/M6 辅助结构（单遍构建）：索引持有集（存活类方法索引 + default/init 旁路 ID）与索引条目清单。 */
+    private static collectMethodIndexHolders;
+    /** M2–M7：单 ID 条目级校验（M5 仅累积分组，组内比较在 {@link checkSignatureValueUniqueness}）。 */
+    private static checkMethodEntry;
+    /** M6（反向链）：存活类方法索引的每个条目 ID 必须有 model。 */
+    private static checkMethodIndexBackLinks;
+    /**
+     * 校验三个 temp 弱注册空间（class/method/field）的结构不变量，规则如下：
+     *
+     * T1  非陈旧性：非空 slot 的值不得已存在于 formal 空间。temp 注册的前提是
+     *     formal miss；若后来同值签名进入 formal（真实模型注册），该 slot 即
+     *     过期——消费方已可从 formal 解析，成为"可迁移未迁移"的陈旧残留
+     *     （持有者下次重路由 formal 命中时经 retireWithReplacement 置空）。
+     *     （注意：不做"全部 unclear"强断言——ClassType/FunctionType/Ref 等注册源
+     *     的条件是 formal miss，clear-but-unregistered 条目为设计内合法形态。）
+     *
+     * T2  register 幂等守护：槽位 ID ↔ 实例自带 symbol ID 双向一致。register 按
+     *     对象恒等幂等分配 ID（同实例复用、新实例新 ID），同一实例出现在两个
+     *     槽位（或实例自带 ID 与槽位不符）意味着 symbol 标记被破坏。
+     *
+     * T3  持有者 ID 有效性：持有结构上声明的 temp SigID
+     *     必须指向非空 slot（未迁移）或有替换记录的已置空 slot（已迁移，惰性
+     *     物化痕迹态 formalID≥0 && tempSigID≠undefined 亦经此规则覆盖）。
+     *     两者皆无 = stale（Registry clear/dispose 后的残留）或从未注册的 ID
+     *     （构造 bug）。持有结构（判据一律用注册标记字段 getTempSigID /
+     *     getDeclaringClassTempSigID）：
+     *     - tempClass：ClassType（getTempSigID）、FieldSignature/MethodSignature
+     *       的 declaringClassTempSigID
+     *     - tempMethod：FunctionType/LexicalEnvType/AbstractInvokeExpr（getTempSigID）
+     *     - tempField：EnumValueType、AbstractFieldRef 即 ArkInstanceFieldRef/
+     *       ArkStaticFieldRef（getTempSigID）
+     *
+     * T4  持有可达性——不设此规则：索引表 slot 强持有下，"存活但无持有者"的 GC 驱动判定失去意义（slot 本身就是持有者，全保留是设计决策——推导中间垃圾
+     *     钉活到 dispose 属知情权衡）。若引入 prune，再按需新建对应审计规则。
+     *
+     * 执行语义：所有规则全量执行、任何违规不中断；全部为 error 级。
+     *
+     * @returns 全部违规描述（空数组 = 三个空间干净）。
+     */
+    static validateTempSpaces(): string[];
+    private static runTempSpaceValidation;
+    /** T1 + T2：单空间的条目级校验。 */
+    private static validateTempSpaceEntries;
+    private static checkTempHolderIDs;
+    /** T3（方法粒度）：方法签名 declaring/返回类型/参数类型 + 方法体（locals/usedGlobals/语句 def&uses）。 */
+    private static checkMethodHolderEntries;
+    /** T3 判定：声明的 temp SigID 必须指向非空 slot（未迁移）或有替换记录的已置空 slot（已迁移）。 */
+    private static checkTempHolderID;
+    /** T3 类型遍历：按类型形态分发持有检查（容器递归共享 visited 防环）。 */
+    private static visitTypeHolders;
+    /** T3 值遍历：invoke expr / field ref / GlobalRef 的 temp 声明与嵌套遍历。 */
+    private static visitValueHolders;
+    /** X1a/X1b：DEFAULT reserved-slot contract (entry exists + model empty), seeding ID 0 into the value-uniqueness groups. */
+    private static checkDefaultSlot;
+    /** X5（检查）：组内两两 equals——hash/equals 契约与 DEFAULT 值域坍缩守卫。分组大小几乎恒为 1，均摊 O(n)。 */
+    private static checkSignatureValueUniqueness;
+    /**
+     * 校验全部已注册空间，输出一份合并汇总（完整全貌，绝不截断）。
+     * @returns 全部空间干净时返回 true。
+     */
+    static validateAll(): boolean;
+}
+//# sourceMappingURL=CanonicalizerValidator.d.ts.map

package/lib/core/common/CanonicalizerValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CanonicalizerValidator.d.ts","sourceRoot":"","sources":["../../../src/core/common/CanonicalizerValidator.ts"],"names":[],"mappings":"AA+BA;;;;;;;;GAQG;AACH,qBAAa,sBAAsB;IAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;WACW,iBAAiB,IAAI,MAAM,EAAE;IAsB3C,8EAA8E;IAC9E,OAAO,CAAC,MAAM,CAAC,cAAc;IAwD7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;WACW,sBAAsB,IAAI,MAAM,EAAE;IAoBhD,8EAA8E;IAC9E,OAAO,CAAC,MAAM,CAAC,mBAAmB;IA8ClC,oEAAoE;IACpE,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAyBlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;WACW,kBAAkB,IAAI,MAAM,EAAE;IAoB5C,mGAAmG;IACnG,OAAO,CAAC,MAAM,CAAC,eAAe;IAkD9B,8DAA8D;IAC9D,OAAO,CAAC,MAAM,CAAC,eAAe;IAuB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmDG;WACW,kBAAkB,IAAI,MAAM,EAAE;IAoB5C,8EAA8E;IAC9E,OAAO,CAAC,MAAM,CAAC,eAAe;IAuD9B,mEAAmE;IACnE,OAAO,CAAC,MAAM,CAAC,eAAe;IAkB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;WACW,mBAAmB,IAAI,MAAM,EAAE;IAqB7C,mEAAmE;IACnE,OAAO,CAAC,MAAM,CAAC,yBAAyB;IAwBxC,8EAA8E;IAC9E,OAAO,CAAC,MAAM,CAAC,gBAAgB;IA0D/B,yCAAyC;IACzC,OAAO,CAAC,MAAM,CAAC,yBAAyB;IAgBxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;WACW,kBAAkB,IAAI,MAAM,EAAE;IAI5C,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAUrC,yBAAyB;IACzB,OAAO,CAAC,MAAM,CAAC,wBAAwB;IA2BvC,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAwBjC,+EAA+E;IAC/E,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAkCvC,iEAAiE;IACjE,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAoBhC,8CAA8C;IAC9C,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAuC/B,iEAAiE;IACjE,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAyBhC,0HAA0H;IAC1H,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAmB/B,6EAA6E;IAC7E,OAAO,CAAC,MAAM,CAAC,6BAA6B;IAoB5C;;;OAGG;WACW,WAAW,IAAI,OAAO;CAgBvC"}