@scriptc/compiler 0.2.4 → 0.2.6

package/dist/ir/validate.test.js

@@ -1,13 +1,38 @@
 import { expect, test } from "vitest";
-import { BOOL, DYN, DYN_CLASS_PROPERTIES, F64, NULL_T, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, mapOf, setOf } from "./ir.js";
+import { BOOL, DYN, DYN_CLASS_PROPERTIES, F64, NULL_T, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, mapOf, setOf, } from "./ir.js";
 import { deserializeModule, serializeModule } from "./serialize.js";
 import { validateModule } from "./validate.js";
 const loc = { file: "numeric-read.ts", start: 0, end: 0 };
 test("static callback operations validate their complete ABI after serialization", () => {
     const mod = expressionModule({ kind: "numLit", value: 0, type: F64, loc }, []);
     mod.ffiImports = [
-        { name: "register", symbol: "register", library: "native", callbackOperation: "register", params: [{ callback: { id: "callback", params: ["pointer"], returns: "void", lifetime: "retained", invoke: "script-thread" } }], returns: "pointer" },
-        { name: "release", symbol: "release", library: "native", callbackOperation: "release", callbackTarget: "register", params: [], returns: "void" },
+        {
+            name: "register",
+            symbol: "register",
+            library: "native",
+            callbackOperation: "register",
+            params: [
+                {
+                    callback: {
+                        id: "callback",
+                        params: ["pointer"],
+                        returns: "void",
+                        lifetime: "retained",
+                        invoke: "script-thread",
+                    },
+                },
+            ],
+            returns: "pointer",
+        },
+        {
+            name: "release",
+            symbol: "release",
+            library: "native",
+            callbackOperation: "release",
+            callbackTarget: "register",
+            params: [],
+            returns: "void",
+        },
     ];
     expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
     for (const variant of ["target", "library", "return", "params", "callback-id"]) {
@@ -24,25 +49,54 @@ test("static callback operations validate their complete ABI after serialization
             release.params = ["pointer"];
         if (variant === "callback-id")
             registration.params[0].callback.id = "wrong";
-        expect(validateModule(bad).some(error => error.message.includes("FFI callback operation"))).toBe(true);
+        expect(validateModule(bad).some((error) => error.message.includes("FFI callback operation"))).toBe(true);
     }
 });
 function localClassModule() {
     const self = { kind: "object", className: "Local" };
-    const mod = expressionModule({ kind: "classRef", className: "Local", captures: ["outer"], type: { kind: "classval", className: "Local" }, loc }, []);
-    mod.classes = [{ name: "Local", jsName: "Local", fields: [{ name: "%classEnvironment:Local", type: { kind: "classval", className: "Local" } }], localCaptures: [{ localId: "shared", name: "value", type: F64 }], loc }];
-    mod.functions[0].locals = [{ id: "outer", name: "value", type: F64, mutable: true, boxed: true }];
+    const mod = expressionModule({
+        kind: "classRef",
+        className: "Local",
+        captures: ["outer"],
+        type: { kind: "classval", className: "Local" },
+        loc,
+    }, []);
+    mod.classes = [
+        {
+            name: "Local",
+            jsName: "Local",
+            fields: [{ name: "%classEnvironment:Local", type: { kind: "classval", className: "Local" } }],
+            localCaptures: [{ localId: "shared", name: "value", type: F64 }],
+            loc,
+        },
+    ];
+    mod.functions[0].locals = [
+        { id: "outer", name: "value", type: F64, mutable: true, boxed: true },
+    ];
     mod.functions.push({
-        name: "%Local.constructor", params: [{ localId: "self", name: "this", type: self }],
-        locals: [{ id: "self", name: "this", type: self, mutable: false }, { id: "capture", name: "value", type: F64, mutable: true, boxed: true }],
+        name: "%Local.constructor",
+        params: [{ localId: "self", name: "this", type: self }],
+        locals: [
+            { id: "self", name: "this", type: self, mutable: false },
+            { id: "capture", name: "value", type: F64, mutable: true, boxed: true },
+        ],
         classCaptures: [{ localId: "capture", name: "value", type: F64, slot: 0 }],
-        returnType: VOID, body: [], loc,
+        returnType: VOID,
+        body: [],
+        loc,
     });
     return mod;
 }
 test("serialized field presence tracking requires native property storage", () => {
     const mod = expressionModule({ kind: "numLit", value: 0, type: F64, loc }, []);
-    mod.classes = [{ name: "Value", fields: [{ name: DYN_CLASS_PROPERTIES, type: DYN }], tracksOwnFields: true, loc }];
+    mod.classes = [
+        {
+            name: "Value",
+            fields: [{ name: DYN_CLASS_PROPERTIES, type: DYN }],
+            tracksOwnFields: true,
+            loc,
+        },
+    ];
     expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
     for (const variant of ["missing", "type", "runtime"]) {
         const bad = structuredClone(mod);
@@ -59,8 +113,14 @@ test("serialized field presence tracking requires native property storage", () =
 test("class prototype data helpers retain their ABI after serialization", () => {
     const mod = expressionModule({ kind: "numLit", value: 0, type: F64, loc }, []);
     mod.classes = [{ name: "Vector", fields: [], prototypeDataHelper: "%prototype.Vector", loc }];
-    mod.functions.push({ name: "%prototype.Vector", params: [], locals: [], returnType: DYN,
-        body: [{ kind: "return", value: { kind: "dynObjLit", fields: [], type: DYN, loc }, loc }], loc });
+    mod.functions.push({
+        name: "%prototype.Vector",
+        params: [],
+        locals: [],
+        returnType: DYN,
+        body: [{ kind: "return", value: { kind: "dynObjLit", fields: [], type: DYN, loc }, loc }],
+        loc,
+    });
     expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
     for (const variant of ["missing", "params", "return", "captures"]) {
         const bad = structuredClone(mod);
@@ -85,9 +145,14 @@ test("instance prototype helpers require the class receiver ABI", () => {
     const mod = localClassModule();
     mod.classes[0].instancePrototypeHelper = "%Local.prototype";
     const receiver = { kind: "object", className: "Local" };
-    mod.functions.push({ name: "%Local.prototype", params: [{ localId: "this", name: "this", type: receiver }],
-        locals: [{ id: "this", name: "this", type: receiver, mutable: false }], returnType: DYN,
-        body: [{ kind: "return", value: { kind: "dynObjLit", fields: [], type: DYN, loc }, loc }], loc });
+    mod.functions.push({
+        name: "%Local.prototype",
+        params: [{ localId: "this", name: "this", type: receiver }],
+        locals: [{ id: "this", name: "this", type: receiver, mutable: false }],
+        returnType: DYN,
+        body: [{ kind: "return", value: { kind: "dynObjLit", fields: [], type: DYN, loc }, loc }],
+        loc,
+    });
     expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
     for (const variant of ["missing", "params", "receiver", "return", "captures"]) {
         const bad = structuredClone(mod);
@@ -107,8 +172,18 @@ test("instance prototype helpers require the class receiver ABI", () => {
 });
 test("computed bases retain their constructor globals after serialization", () => {
     const mod = expressionModule({ kind: "numLit", value: 0, type: F64, loc }, []);
-    mod.classes = [{ name: "Base", fields: [], loc }, { name: "Child", base: "Base", fields: [], baseValueGlobal: "%g.computed", loc }];
-    mod.globals = [{ id: "%g.computed", name: "computed", type: { kind: "classval", className: "Base" }, mutable: false }];
+    mod.classes = [
+        { name: "Base", fields: [], loc },
+        { name: "Child", base: "Base", fields: [], baseValueGlobal: "%g.computed", loc },
+    ];
+    mod.globals = [
+        {
+            id: "%g.computed",
+            name: "computed",
+            type: { kind: "classval", className: "Base" },
+            mutable: false,
+        },
+    ];
     expect(deserializeModule(serializeModule(mod))).toEqual(mod);
     expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
     for (const variant of ["missing", "type", "class", "capture"]) {
@@ -126,7 +201,14 @@ test("computed bases retain their constructor globals after serialization", () =
 });
 test("class symbol fields preserve their identity metadata after serialization", () => {
     const mod = expressionModule({ kind: "numLit", value: 0, type: F64, loc }, []);
-    mod.classes = [{ name: "Item", fields: [{ name: "sym:key", type: STRING }], symbolFields: [{ field: "sym:key", globalId: "%g.key" }], loc }];
+    mod.classes = [
+        {
+            name: "Item",
+            fields: [{ name: "sym:key", type: STRING }],
+            symbolFields: [{ field: "sym:key", globalId: "%g.key" }],
+            loc,
+        },
+    ];
     mod.globals = [{ id: "%g.key", name: "key", type: SYMBOL_T, mutable: false }];
     expect(deserializeModule(serializeModule(mod))).toEqual(mod);
     expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
@@ -159,7 +241,19 @@ test.each(["missing", "unboxed", "type", "slot", "receiver", "closure", "layout"
     if (variant === "layout")
         mod.classes[0].runtime = true;
     if (variant === "direct-new")
-        mod.functions[0].body = [{ kind: "exprStmt", expr: { kind: "new", className: "Local", args: [], type: { kind: "object", className: "Local" }, loc }, loc }];
+        mod.functions[0].body = [
+            {
+                kind: "exprStmt",
+                expr: {
+                    kind: "new",
+                    className: "Local",
+                    args: [],
+                    type: { kind: "object", className: "Local" },
+                    loc,
+                },
+                loc,
+            },
+        ];
     expect(validateModule(mod).length).toBeGreaterThan(0);
 });
 test.each([mapOf(STRING, F64), setOf(STRING), { kind: "promise", inner: F64 }])("nullable %j payloads preserve an explicit absence tag", (type) => {
@@ -183,27 +277,120 @@ test("two differently typed Map payloads cannot silently share one tag test", ()
 });
 function numericReadModule(overrides = {}) {
     const read = {
-        kind: "arrIntrinsic", method: "getNumber",
+        kind: "arrIntrinsic",
+        method: "getNumber",
         receiver: { kind: "arrayLit", elems: [], type: arrayOf(F64), loc },
         args: [{ kind: "numLit", value: 0, type: F64, loc }],
-        type: F64, loc, ...overrides,
+        type: F64,
+        loc,
+        ...overrides,
     };
     return {
-        irVersion: 13, sourceFile: loc.file, entry: "main",
-        functions: [{ name: "main", params: [], locals: [], returnType: VOID, body: [{ kind: "exprStmt", expr: read, loc }], loc }],
+        irVersion: 14,
+        sourceFile: loc.file,
+        entry: "main",
+        functions: [
+            {
+                name: "main",
+                params: [],
+                locals: [],
+                returnType: VOID,
+                body: [{ kind: "exprStmt", expr: read, loc }],
+                loc,
+            },
+        ],
     };
 }
+test.each(["copyWithin", "fill", "fillUndefined"])("indexed array mutation %s validates its serialized argument and result contract", (method) => {
+    const number = { kind: "numLit", value: 1, type: F64, loc };
+    const value = { kind: "strLit", value: "entry", type: STRING, loc };
+    const type = arrayOf(STRING);
+    const expr = {
+        kind: "arrIntrinsic",
+        method,
+        receiver: { kind: "arrayLit", elems: [], type, loc },
+        args: method === "fill"
+            ? [value, number, number]
+            : method === "copyWithin"
+                ? [number, number, number]
+                : [number, number],
+        type,
+        loc,
+    };
+    const mod = expressionModule(expr, []);
+    expect(validateModule(mod)).toEqual([]);
+    expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+    for (const change of [
+        { args: expr.args.slice(1) },
+        { args: [...expr.args.slice(0, -1), value] },
+        { args: [method === "fill" ? number : value, ...expr.args.slice(1)] },
+        { type: arrayOf(F64) },
+    ]) {
+        const invalid = expressionModule({ ...expr, ...change }, []);
+        expect(validateModule(deserializeModule(serializeModule(invalid))).length).toBeGreaterThan(0);
+    }
+});
+test.each(["sortPrimitive", "toSortedPrimitive"])("primitive ordering %s validates its serialized element and result contract", (method) => {
+    for (const elem of [STRING, F64, BOOL]) {
+        const type = arrayOf(elem);
+        const expr = {
+            kind: "arrIntrinsic",
+            method,
+            receiver: { kind: "arrayLit", elems: [], type, loc },
+            args: [],
+            type,
+            loc,
+        };
+        const mod = expressionModule(expr, []);
+        expect(validateModule(mod)).toEqual([]);
+        expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+        for (const change of [
+            { args: [{ kind: "numLit", value: 1, type: F64, loc }] },
+            { type: F64 },
+            {
+                receiver: { kind: "arrayLit", elems: [], type: arrayOf(type), loc },
+                type: arrayOf(type),
+            },
+        ]) {
+            expect(validateModule(expressionModule({ ...expr, ...change }, [])).length).toBeGreaterThan(0);
+        }
+    }
+});
 function expressionModule(expr, unions) {
     return {
-        irVersion: 13, sourceFile: loc.file, entry: "main", unions,
-        functions: [{ name: "main", params: [], locals: [], returnType: VOID, body: [{ kind: "exprStmt", expr, loc }], loc }],
+        irVersion: 14,
+        sourceFile: loc.file,
+        entry: "main",
+        unions,
+        functions: [
+            {
+                name: "main",
+                params: [],
+                locals: [],
+                returnType: VOID,
+                body: [{ kind: "exprStmt", expr, loc }],
+                loc,
+            },
+        ],
     };
 }
 test("numeric byte tokens and DataView stores validate their storage before emission", () => {
-    const bytes = { kind: "varRef", localId: "bytes", type: { kind: "bytes", elem: "u8" }, loc };
+    const bytes = {
+        kind: "varRef",
+        localId: "bytes",
+        type: { kind: "bytes", elem: "u8" },
+        loc,
+    };
     const number = { kind: "numLit", value: 0, type: F64, loc };
     const kind = { kind: "strLit", value: "u32le", type: STRING, loc };
-    const read = { kind: "bytesIntrinsic", method: "readNum", receiver: bytes, args: [kind, number], type: F64, loc };
+    const read = {
+        kind: "bytesIntrinsic",
+        method: "readNum",
+        receiver: bytes,
+        args: [kind, number],
+        type: F64,
+        loc,
+    };
     const mod = expressionModule(read, []);
     mod.functions[0].locals.push({ id: "bytes", name: "bytes", type: bytes.type, mutable: false });
     expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
@@ -212,7 +399,14 @@ test("numeric byte tokens and DataView stores validate their storage before emis
         expect(validateModule(mod).some((e) => e.message.includes("invalid kind token"))).toBe(true);
     }
     kind.value = "u32le";
-    const store = { kind: "bytesIntrinsic", method: "dvSetUint32", receiver: bytes, args: [number, number], type: VOID, loc };
+    const store = {
+        kind: "bytesIntrinsic",
+        method: "dvSetUint32",
+        receiver: bytes,
+        args: [number, number],
+        type: VOID,
+        loc,
+    };
     mod.functions[0].body = [{ kind: "exprStmt", expr: store, loc }];
     expect(validateModule(mod)).toEqual([]);
     bytes.type = { kind: "bytes", elem: "u32" };
@@ -241,7 +435,26 @@ function recordValidationModule() {
     mod.records = [{ id: "row", fields: [{ name: "value", type: STRING }] }];
     mod.functions[0].locals = [{ id: "row", name: "row", type, mutable: false }];
     mod.functions[0].params = [{ localId: "row", name: "row", type }];
-    mod.functions[0].body.push({ kind: "recordSet", obj: source, shapeId: "row", field: "value", value: { kind: "strLit", value: "write", type: STRING, loc }, loc }, { kind: "exprStmt", expr: { kind: "recordClone", source, overrides: [{ name: "value", value: { kind: "strLit", value: "clone", type: STRING, loc } }], type, loc }, loc });
+    mod.functions[0].body.push({
+        kind: "recordSet",
+        obj: source,
+        shapeId: "row",
+        field: "value",
+        value: { kind: "strLit", value: "write", type: STRING, loc },
+        loc,
+    }, {
+        kind: "exprStmt",
+        expr: {
+            kind: "recordClone",
+            source,
+            overrides: [
+                { name: "value", value: { kind: "strLit", value: "clone", type: STRING, loc } },
+            ],
+            type,
+            loc,
+        },
+        loc,
+    });
     return mod;
 }
 test("record validation preserves first-field reads and writes and last-field initialization on duplicate declarations", () => {
@@ -253,9 +466,19 @@ test("record validation preserves first-field reads and writes and last-field in
     if (statement.kind !== "exprStmt" || statement.expr.kind !== "recordClone")
         throw new Error("fixture");
     statement.expr.overrides[0].value = { kind: "numLit", value: 1, type: F64, loc };
-    mod.functions[0].body.push({ kind: "exprStmt", expr: { kind: "recordLit", type: statement.expr.type, loc,
-            fields: [1, 2].map((value) => ({ name: "value", value: { kind: "numLit", value, type: F64, loc } })),
-        }, loc });
+    mod.functions[0].body.push({
+        kind: "exprStmt",
+        expr: {
+            kind: "recordLit",
+            type: statement.expr.type,
+            loc,
+            fields: [1, 2].map((value) => ({
+                name: "value",
+                value: { kind: "numLit", value, type: F64, loc },
+            })),
+        },
+        loc,
+    });
     expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([
         { message: 'duplicate record shape "row"', loc },
         { message: 'record row: duplicate field "value"', loc },
@@ -293,27 +516,96 @@ test("record clone validation refreshes accessor boundaries and preserves call-s
     mod.records[0].fields.unshift({ name: "%get:value", type: F64 });
     expect(validateModule(mod)).toEqual([
         { message: "in main: recordClone requires a plain declared-field shape, got row", loc },
-        { message: "in other: recordClone requires a plain declared-field shape, got row", loc: other.expr.loc },
+        {
+            message: "in other: recordClone requires a plain declared-field shape, got row",
+            loc: other.expr.loc,
+        },
     ]);
 });
 function classFieldModule() {
     const type = { kind: "object", className: "Value" };
     const source = { kind: "varRef", localId: "object", type, loc };
     const union = { kind: "union", unionId: "variants" };
-    const mod = expressionModule({ kind: "fieldGet", obj: source, className: "Value", field: "score", type: F64, loc }, [
-        { id: "variants", arms: [type, { kind: "record", shapeId: "row" }] },
-    ]);
-    mod.classes = [{ name: "Value", fields: [{ name: "score", type: F64 }, { name: "dynamic", type: DYN }], loc }];
+    const mod = expressionModule({ kind: "fieldGet", obj: source, className: "Value", field: "score", type: F64, loc }, [{ id: "variants", arms: [type, { kind: "record", shapeId: "row" }] }]);
+    mod.classes = [
+        {
+            name: "Value",
+            fields: [
+                { name: "score", type: F64 },
+                { name: "dynamic", type: DYN },
+            ],
+            loc,
+        },
+    ];
     mod.records = [{ id: "row", fields: [{ name: "score", type: F64 }] }];
-    mod.functions[0].params = [{ localId: "object", name: "object", type }, { localId: "variant", name: "variant", type: union }];
-    mod.functions[0].locals = [{ id: "object", name: "object", type, mutable: false }, { id: "variant", name: "variant", type: union, mutable: false }];
-    mod.functions[0].body.push({ kind: "fieldSet", obj: source, className: "Value", field: "score", value: { kind: "numLit", value: 1, type: F64, loc }, loc }, { kind: "exprStmt", expr: { kind: "fieldIncDec", obj: source, className: "Value", field: "score", fieldDyn: false, op: "+", prefix: true, type: F64, loc }, loc }, { kind: "exprStmt", expr: { kind: "fieldIncDec", obj: source, className: "Value", field: "dynamic", fieldDyn: true, op: "-", prefix: false, type: F64, loc }, loc }, { kind: "exprStmt", expr: { kind: "unionDisc", value: { kind: "varRef", localId: "variant", type: union, loc }, unionId: "variants", field: "score", type: F64, loc }, loc });
+    mod.functions[0].params = [
+        { localId: "object", name: "object", type },
+        { localId: "variant", name: "variant", type: union },
+    ];
+    mod.functions[0].locals = [
+        { id: "object", name: "object", type, mutable: false },
+        { id: "variant", name: "variant", type: union, mutable: false },
+    ];
+    mod.functions[0].body.push({
+        kind: "fieldSet",
+        obj: source,
+        className: "Value",
+        field: "score",
+        value: { kind: "numLit", value: 1, type: F64, loc },
+        loc,
+    }, {
+        kind: "exprStmt",
+        expr: {
+            kind: "fieldIncDec",
+            obj: source,
+            className: "Value",
+            field: "score",
+            fieldDyn: false,
+            op: "+",
+            prefix: true,
+            type: F64,
+            loc,
+        },
+        loc,
+    }, {
+        kind: "exprStmt",
+        expr: {
+            kind: "fieldIncDec",
+            obj: source,
+            className: "Value",
+            field: "dynamic",
+            fieldDyn: true,
+            op: "-",
+            prefix: false,
+            type: F64,
+            loc,
+        },
+        loc,
+    }, {
+        kind: "exprStmt",
+        expr: {
+            kind: "unionDisc",
+            value: { kind: "varRef", localId: "variant", type: union, loc },
+            unionId: "variants",
+            field: "score",
+            type: F64,
+            loc,
+        },
+        loc,
+    });
     return mod;
 }
 test("class field validation preserves last-class and first-field lookup on duplicate declarations", () => {
     const mod = classFieldModule();
     expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
-    mod.classes.unshift({ name: "Value", fields: [{ name: "score", type: STRING }, { name: "dynamic", type: F64 }], loc });
+    mod.classes.unshift({
+        name: "Value",
+        fields: [
+            { name: "score", type: STRING },
+            { name: "dynamic", type: F64 },
+        ],
+        loc,
+    });
     mod.classes[1].fields.push({ name: "score", type: STRING }, { name: "dynamic", type: F64 });
     expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([
         { message: 'duplicate class "Value"', loc },
@@ -380,16 +672,38 @@ function virtualCallModule() {
         { name: "Second", base: "Base", fields: [], methods: ["run"], loc },
     ];
     for (const name of ["Unrelated", "First", "Second"]) {
-        mod.functions.push({ name: `%${name}.run`, params: [{ localId: "self", name: "self", type: receiver }],
-            locals: [{ id: "self", name: "self", type: receiver, mutable: false }], returnType: F64,
-            body: [{ kind: "return", value: { kind: "numLit", value: 1, type: F64, loc }, loc }], loc });
+        mod.functions.push({
+            name: `%${name}.run`,
+            params: [{ localId: "self", name: "self", type: receiver }],
+            locals: [{ id: "self", name: "self", type: receiver, mutable: false }],
+            returnType: F64,
+            body: [{ kind: "return", value: { kind: "numLit", value: 1, type: F64, loc }, loc }],
+            loc,
+        });
     }
     for (let i = 0; i < 2; i++) {
         const at = { ...loc, start: i + 1 };
-        mod.functions.push({ name: `caller${i}`, params: [{ localId: "self", name: "self", type: receiver }],
-            locals: [{ id: "self", name: "self", type: receiver, mutable: false }], returnType: VOID,
-            body: [{ kind: "exprStmt", expr: { kind: "virtualCall", className: "Base", method: "run",
-                        args: [{ kind: "varRef", localId: "self", type: receiver, loc: at }], type: F64, loc: at }, loc: at }], loc: at });
+        mod.functions.push({
+            name: `caller${i}`,
+            params: [{ localId: "self", name: "self", type: receiver }],
+            locals: [{ id: "self", name: "self", type: receiver, mutable: false }],
+            returnType: VOID,
+            body: [
+                {
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "virtualCall",
+                        className: "Base",
+                        method: "run",
+                        args: [{ kind: "varRef", localId: "self", type: receiver, loc: at }],
+                        type: F64,
+                        loc: at,
+                    },
+                    loc: at,
+                },
+            ],
+            loc: at,
+        });
     }
     return mod;
 }
@@ -408,7 +722,9 @@ test("virtual-call validation resolves an abstract slot in class-table order and
     const mod = virtualCallModule();
     const second = mod.functions.find((fn) => fn.name === "%Second.run");
     second.returnType = STRING;
-    second.body = [{ kind: "return", value: { kind: "strLit", value: "second", type: STRING, loc }, loc }];
+    second.body = [
+        { kind: "return", value: { kind: "strLit", value: "second", type: STRING, loc }, loc },
+    ];
     expect(validateModule(mod)).toEqual([]);
     mod.classes.reverse();
     expect(validateModule(mod).map((error) => error.message)).toEqual([
@@ -436,9 +752,16 @@ test("virtual-call validation uses the nearest concrete ancestor instead of an o
     const mod = virtualCallModule();
     mod.classes.unshift({ name: "Root", fields: [], methods: ["run"], loc });
     mod.classes.find((cls) => cls.name === "Base").base = "Root";
-    mod.functions.push({ name: "%Root.run", params: [{ localId: "self", name: "self", type: { kind: "object", className: "Base" } }],
-        locals: [{ id: "self", name: "self", type: { kind: "object", className: "Base" }, mutable: false }], returnType: STRING,
-        body: [{ kind: "return", value: { kind: "strLit", value: "root", type: STRING, loc }, loc }], loc });
+    mod.functions.push({
+        name: "%Root.run",
+        params: [{ localId: "self", name: "self", type: { kind: "object", className: "Base" } }],
+        locals: [
+            { id: "self", name: "self", type: { kind: "object", className: "Base" }, mutable: false },
+        ],
+        returnType: STRING,
+        body: [{ kind: "return", value: { kind: "strLit", value: "root", type: STRING, loc }, loc }],
+        loc,
+    });
     expect(validateModule(mod).map((error) => error.message)).toEqual([
         "in caller0: virtualCall Base.run result type mismatch",
         "in caller1: virtualCall Base.run result type mismatch",
@@ -446,9 +769,73 @@ test("virtual-call validation uses the nearest concrete ancestor instead of an o
     mod.classes.find((cls) => cls.name === "Root").methods = [];
     expect(validateModule(mod)).toEqual([]);
 });
+test("erased generic families admit compatible object views without supplying virtual slots", () => {
+    const concrete = { kind: "object", className: "Concrete" };
+    const family = { kind: "object", className: "Family" };
+    const mod = expressionModule({
+        kind: "upcast",
+        value: { kind: "varRef", localId: "value", type: concrete, loc },
+        type: family,
+        loc,
+    }, []);
+    mod.functions[0].params = [{ localId: "value", name: "value", type: concrete }];
+    mod.functions[0].locals = [{ id: "value", name: "value", type: concrete, mutable: false }];
+    mod.classes = [
+        { name: "Root", fields: [{ name: "value", type: F64 }], methods: [], loc },
+        { name: "Family", base: "Root", fields: [{ name: "value", type: F64 }], methods: [], loc },
+        { name: "Storage", base: "Root", fields: [{ name: "value", type: F64 }], methods: [], loc },
+        {
+            name: "Concrete",
+            base: "Storage",
+            genericOf: "Family",
+            fields: [{ name: "value", type: F64 }],
+            methods: [],
+            loc,
+        },
+    ];
+    expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
+    mod.classes[3].fields[0].type = STRING;
+    expect(validateModule(mod).map((error) => error.message)).toContain('class Concrete: generic family "Family" has an incompatible prefix');
+    mod.classes[3].fields[0].type = F64;
+    delete mod.classes[3].base;
+    expect(validateModule(mod).map((error) => error.message)).toContain('class Concrete: generic family "Family" has a different storage root');
+    mod.classes[3].base = "Storage";
+    mod.classes[1].genericOf = "Concrete";
+    expect(validateModule(mod).map((error) => error.message)).toContain('class Concrete: generic family "Family" must name an erased declaration');
+    const calls = virtualCallModule();
+    calls.classes = calls.classes.filter((cls) => cls.name !== "Second");
+    const first = calls.classes.find((cls) => cls.name === "First");
+    delete first.base;
+    first.genericOf = "Base";
+    expect(validateModule(calls).map((error) => error.message)).toContain("in caller0: virtualCall Base.run: no concrete override below the static class");
+});
+test("erased family membership cannot reinterpret a specialized constructor ABI", () => {
+    const mod = expressionModule({
+        kind: "upcast",
+        value: {
+            kind: "varRef",
+            localId: "ctor",
+            type: { kind: "classval", className: "Concrete" },
+            loc,
+        },
+        type: { kind: "classval", className: "Family" },
+        loc,
+    }, []);
+    const ctor = { kind: "classval", className: "Concrete" };
+    mod.functions[0].params = [{ localId: "ctor", name: "ctor", type: ctor }];
+    mod.functions[0].locals = [{ id: "ctor", name: "ctor", type: ctor, mutable: false }];
+    mod.classes = [
+        { name: "Family", fields: [], methods: [], loc },
+        { name: "Concrete", genericOf: "Family", fields: [], methods: [], loc },
+    ];
+    expect(validateModule(mod).map((error) => error.message)).toContain('in main: upcast: "Concrete" does not extend "Family"');
+});
 test("library callbacks retain child, specialized, and generic result diagnostics", () => {
     const expr = {
-        kind: "libCall", fn: "cp.execFile", type: F64, loc,
+        kind: "libCall",
+        fn: "cp.execFile",
+        type: F64,
+        loc,
         args: [
             { kind: "strLit", value: "tool", type: STRING, loc },
             { kind: "arrayLit", elems: [], type: arrayOf(STRING), loc },
@@ -464,9 +851,13 @@ test("library callbacks retain child, specialized, and generic result diagnostic
 test("nullish chains retain child-before-parent diagnostic order", () => {
     const at = (start) => ({ ...loc, start });
     const expr = {
-        kind: "nullish", type: F64, loc: at(4),
+        kind: "nullish",
+        type: F64,
+        loc: at(4),
         left: {
-            kind: "nullish", type: STRING, loc: at(2),
+            kind: "nullish",
+            type: STRING,
+            loc: at(2),
             left: { kind: "numLit", value: 0, type: STRING, loc: at(0) },
             right: { kind: "boolLit", value: true, type: F64, loc: at(1) },
         },
@@ -484,9 +875,15 @@ test("nullish chains retain child-before-parent diagnostic order", () => {
 test("logical trees retain left/right/parent diagnostic order", () => {
     const at = (start) => ({ ...loc, start });
     const expr = {
-        kind: "logical", op: "&&", type: BOOL, loc: at(4),
+        kind: "logical",
+        op: "&&",
+        type: BOOL,
+        loc: at(4),
         left: {
-            kind: "logical", op: "||", type: STRING, loc: at(2),
+            kind: "logical",
+            op: "||",
+            type: STRING,
+            loc: at(2),
             left: { kind: "numLit", value: 0, type: STRING, loc: at(0) },
             right: { kind: "boolLit", value: true, type: F64, loc: at(1) },
         },
@@ -503,7 +900,9 @@ test("logical trees retain left/right/parent diagnostic order", () => {
 test("conditional trees retain condition/then/else/parent diagnostic order", () => {
     const at = (start) => ({ ...loc, start });
     const expr = {
-        kind: "ternary", type: STRING, loc: at(3),
+        kind: "ternary",
+        type: STRING,
+        loc: at(3),
         cond: { kind: "numLit", value: 0, type: BOOL, loc: at(0) },
         then: { kind: "boolLit", value: true, type: F64, loc: at(1) },
         else_: { kind: "strLit", value: "wrong", type: BOOL, loc: at(2) },
@@ -518,13 +917,39 @@ test("conditional trees retain condition/then/else/parent diagnostic order", ()
 });
 test.each(["callValue", "dynCall"])("%s requires a checked-value receiver and preserves it in serialization", (kind) => {
     const funcType = { kind: "func", params: [], ret: DYN };
-    const closure = { kind: "closure", fnName: "callback", captures: [], type: funcType, loc };
-    const receiver = { kind: "dynFrom", value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, type: DYN, loc };
+    const closure = {
+        kind: "closure",
+        fnName: "callback",
+        captures: [],
+        type: funcType,
+        loc,
+    };
+    const receiver = {
+        kind: "dynFrom",
+        value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc },
+        type: DYN,
+        loc,
+    };
     const call = kind === "callValue"
         ? { kind, callee: closure, receiver, args: [], type: DYN, loc }
-        : { kind, callee: { kind: "dynFrom", value: closure, type: DYN, loc }, receiver, calleeName: "callback", args: [], type: DYN, loc };
+        : {
+            kind,
+            callee: { kind: "dynFrom", value: closure, type: DYN, loc },
+            receiver,
+            calleeName: "callback",
+            args: [],
+            type: DYN,
+            loc,
+        };
     const mod = expressionModule(call, []);
-    mod.functions.push({ name: "callback", params: [], locals: [], returnType: DYN, body: [{ kind: "return", value: receiver, loc }], loc });
+    mod.functions.push({
+        name: "callback",
+        params: [],
+        locals: [],
+        returnType: DYN,
+        body: [{ kind: "return", value: receiver, loc }],
+        loc,
+    });
     expect(validateModule(mod)).toEqual([]);
     expect(deserializeModule(serializeModule(mod))).toEqual(mod);
     call.receiver = { kind: "numLit", value: 1, type: F64, loc };
@@ -536,14 +961,29 @@ function optionalUnionModule(arms = [BOOL, F64, UNDEFINED_T]) {
     const type = { kind: "union", unionId: "receiver" };
     const tag = arms.findIndex((arm) => arm.kind === "f64");
     const receiver = tag >= 0
-        ? { kind: "unionWrap", unionId: "receiver", tag, value: { kind: "numLit", value: 7, type: F64, loc }, type, loc }
+        ? {
+            kind: "unionWrap",
+            unionId: "receiver",
+            tag,
+            value: { kind: "numLit", value: 7, type: F64, loc },
+            type,
+            loc,
+        }
         : {
-            kind: "unionWrap", unionId: "receiver", tag: arms.findIndex((arm) => arm.kind === "undefinedT"),
-            value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, type, loc,
+            kind: "unionWrap",
+            unionId: "receiver",
+            tag: arms.findIndex((arm) => arm.kind === "undefinedT"),
+            value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc },
+            type,
+            loc,
         };
     const chain = {
-        kind: "optChain", id: "test", receiver,
-        body: { kind: "chainRecv", id: "test", type, loc }, type, loc,
+        kind: "optChain",
+        id: "test",
+        receiver,
+        body: { kind: "chainRecv", id: "test", type, loc },
+        type,
+        loc,
     };
     return expressionModule(chain, [{ id: "receiver", arms }]);
 }
@@ -573,9 +1013,12 @@ test("a single present arm still binds its payload", () => {
     if (statement.kind !== "exprStmt" || statement.expr.kind !== "optChain")
         throw new Error("fixture");
     statement.expr.body = {
-        kind: "unionWrap", unionId: "receiver", tag: 0,
+        kind: "unionWrap",
+        unionId: "receiver",
+        tag: 0,
         value: { kind: "chainRecv", id: "test", type: F64, loc },
-        type: { kind: "union", unionId: "receiver" }, loc,
+        type: { kind: "union", unionId: "receiver" },
+        loc,
     };
     expect(validateModule(mod)).toEqual([]);
 });
@@ -584,19 +1027,35 @@ function keyedUnionModule(resultArms, overflowOnly = false) {
     const result = { kind: "union", unionId: "result" };
     const record = { kind: "record", shapeId: "row" };
     const obj = {
-        kind: "recordLit", type: record, loc,
-        fields: [{ name: "value", value: {
-                    kind: "unionWrap", unionId: "stored", tag: 0,
-                    value: { kind: "numLit", value: 9, type: F64, loc }, type: stored, loc,
-                } }],
+        kind: "recordLit",
+        type: record,
+        loc,
+        fields: [
+            {
+                name: "value",
+                value: {
+                    kind: "unionWrap",
+                    unionId: "stored",
+                    tag: 0,
+                    value: { kind: "numLit", value: 9, type: F64, loc },
+                    type: stored,
+                    loc,
+                },
+            },
+        ],
     };
     const read = {
-        kind: "recordKeyGet", obj, shapeId: "row",
+        kind: "recordKeyGet",
+        obj,
+        shapeId: "row",
         key: { kind: "strLit", value: overflowOnly ? "extra" : "value", type: STRING, loc },
-        type: result, loc, ...(overflowOnly ? { overflowOnly: true } : {}),
+        type: result,
+        loc,
+        ...(overflowOnly ? { overflowOnly: true } : {}),
     };
     const mod = expressionModule(read, [
-        { id: "stored", arms: [F64, NULL_T] }, { id: "result", arms: resultArms },
+        { id: "stored", arms: [F64, NULL_T] },
+        { id: "result", arms: resultArms },
     ]);
     mod.records = [{ id: "row", fields: [{ name: "value", type: stored }], indexValue: stored }];
     return mod;
@@ -615,16 +1074,27 @@ test("union array reads validate every element layout against the joined result"
     const receiver = { kind: "union", unionId: "arrays" };
     const result = { kind: "union", unionId: "result" };
     const array = {
-        kind: "arrayLit", elems: [{
-                kind: "unionWrap", unionId: "stored", tag: 1,
-                value: { kind: "unitLit", unit: "null", type: NULL_T, loc }, type: stored, loc,
-            }],
-        type: arrayOf(stored), loc,
+        kind: "arrayLit",
+        elems: [
+            {
+                kind: "unionWrap",
+                unionId: "stored",
+                tag: 1,
+                value: { kind: "unitLit", unit: "null", type: NULL_T, loc },
+                type: stored,
+                loc,
+            },
+        ],
+        type: arrayOf(stored),
+        loc,
     };
     const read = {
-        kind: "unionKeyGet", unionId: "arrays",
+        kind: "unionKeyGet",
+        unionId: "arrays",
         value: { kind: "unionWrap", unionId: "arrays", tag: 0, value: array, type: receiver, loc },
-        key: { kind: "numLit", value: 0, type: F64, loc }, type: result, loc,
+        key: { kind: "numLit", value: 0, type: F64, loc },
+        type: result,
+        loc,
     };
     const mod = expressionModule(read, [
         { id: "stored", arms: [F64, NULL_T] },
@@ -651,7 +1121,8 @@ test("indexed equality validates primitive kinds, arguments, and result", () =>
     expect(validateModule(mod)).toEqual([]);
     expect(deserializeModule(serializeModule(mod))).toEqual(mod);
     for (const override of [
-        { args: [] }, { type: F64 },
+        { args: [] },
+        { type: F64 },
         { args: [args[0], { kind: "arrayLit", elems: [], type: arrayOf(STRING), loc }, args[2]] },
         { receiver: { kind: "arrayLit", elems: [], type: arrayOf(arrayOf(F64)), loc } },
     ]) {
@@ -659,7 +1130,10 @@ test("indexed equality validates primitive kinds, arguments, and result", () =>
     }
 });
 test.each([
-    [{ receiver: { kind: "arrayLit", elems: [], type: arrayOf(STRING), loc } }, "requires f64 elements"],
+    [
+        { receiver: { kind: "arrayLit", elems: [], type: arrayOf(STRING), loc } },
+        "requires f64 elements",
+    ],
     [{ args: [] }, "0 args, expected 1"],
     [{ args: [{ kind: "strLit", value: "0", type: STRING, loc }] }, "arg 0: expected f64"],
     [{ type: BOOL }, "must be f64"],
@@ -669,15 +1143,22 @@ test.each([
 function tdzModule(mutable = true) {
     const value = { kind: "numLit", value: 0, type: F64, loc };
     return {
-        irVersion: 13, sourceFile: loc.file, entry: "main",
-        functions: [{
-                name: "main", params: [], returnType: VOID, loc,
+        irVersion: 14,
+        sourceFile: loc.file,
+        entry: "main",
+        functions: [
+            {
+                name: "main",
+                params: [],
+                returnType: VOID,
+                loc,
                 locals: [{ id: "value", name: "value", type: F64, mutable, boxed: true, tdz: true }],
                 body: [
                     { kind: "varDecl", localId: "value", init: null, loc },
                     { kind: "assign", localId: "value", value, initializes: true, loc },
                 ],
-            }],
+            },
+        ],
     };
 }
 test.each([true, false])("TDZ declarations round-trip their initialization marker (mutable=%s)", (mutable) => {
@@ -705,10 +1186,20 @@ test("TDZ globals require guarded pointer storage and round-trip initialization"
     mod.records = [{ id: "codec", fields: [{ name: "%TextEncoder", type: F64 }], declaredOrder: [] }];
     mod.globals = [{ id: "%g.value", name: "value", type, mutable: false, tdz: true }];
     mod.functions[0].locals = [];
-    mod.functions[0].body = [{
-            kind: "assign", localId: "%g.value", initializes: true, loc,
-            value: { kind: "recordLit", fields: [{ name: "%TextEncoder", value: { kind: "numLit", value: -1, type: F64, loc } }], type, loc },
-        }];
+    mod.functions[0].body = [
+        {
+            kind: "assign",
+            localId: "%g.value",
+            initializes: true,
+            loc,
+            value: {
+                kind: "recordLit",
+                fields: [{ name: "%TextEncoder", value: { kind: "numLit", value: -1, type: F64, loc } }],
+                type,
+                loc,
+            },
+        },
+    ];
     expect(validateModule(mod)).toEqual([]);
     expect(deserializeModule(serializeModule(mod))).toEqual(mod);
     mod.globals[0].type = F64;
@@ -733,9 +1224,12 @@ test("TDZ initialization still checks the payload representation", () => {
 function overflowPresenceModule() {
     const record = { kind: "record", shapeId: "dictionary" };
     const check = {
-        kind: "recordOvfHas", shapeId: "dictionary",
+        kind: "recordOvfHas",
+        shapeId: "dictionary",
         obj: { kind: "recordLit", fields: [], type: record, loc },
-        key: { kind: "strLit", value: "key", type: STRING, loc }, type: BOOL, loc,
+        key: { kind: "strLit", value: "key", type: STRING, loc },
+        type: BOOL,
+        loc,
     };
     const mod = expressionModule(check, []);
     mod.records = [{ id: "dictionary", fields: [], indexValue: F64 }];
@@ -779,16 +1273,38 @@ test("TDZ locals require a shared box", () => {
 });
 function discriminatedModule() {
     return {
-        irVersion: 13, sourceFile: loc.file, entry: "main",
+        irVersion: 14,
+        sourceFile: loc.file,
+        entry: "main",
         functions: [{ name: "main", params: [], locals: [], returnType: VOID, body: [], loc }],
         records: [
             { id: "empty", fields: [{ name: "kind", type: STRING }] },
-            { id: "value", fields: [{ name: "kind", type: STRING }, { name: "value", type: F64 }] },
+            {
+                id: "value",
+                fields: [
+                    { name: "kind", type: STRING },
+                    { name: "value", type: F64 },
+                ],
+            },
+        ],
+        unions: [
+            {
+                id: "variants",
+                arms: [
+                    NULL_T,
+                    { kind: "record", shapeId: "empty" },
+                    { kind: "record", shapeId: "value" },
+                    UNDEFINED_T,
+                ],
+                discriminant: {
+                    field: "kind",
+                    cases: [
+                        { tag: 1, values: ["empty"] },
+                        { tag: 2, values: ["number", "value"] },
+                    ],
+                },
+            },
         ],
-        unions: [{
-                id: "variants", arms: [NULL_T, { kind: "record", shapeId: "empty" }, { kind: "record", shapeId: "value" }, UNDEFINED_T],
-                discriminant: { field: "kind", cases: [{ tag: 1, values: ["empty"] }, { tag: 2, values: ["number", "value"] }] },
-            }],
     };
 }
 test("discriminator metadata validates and survives serialization", () => {
@@ -797,16 +1313,76 @@ test("discriminator metadata validates and survives serialization", () => {
     expect(deserializeModule(serializeModule(mod))).toEqual(mod);
 });
 test.each([
-    ["missing arm", (m) => { m.unions[0].discriminant.cases.pop(); }, "missing discriminant"],
-    ["unit arm", (m) => { m.unions[0].discriminant.cases[0].tag = 0; }, "invalid discriminant tag"],
-    ["negative tag", (m) => { m.unions[0].discriminant.cases[0].tag = -1; }, "invalid discriminant tag"],
-    ["fractional tag", (m) => { m.unions[0].discriminant.cases[0].tag = 1.5; }, "invalid discriminant tag"],
-    ["missing field", (m) => { m.unions[0].discriminant.field = "absent"; }, "invalid discriminant tag"],
-    ["duplicate tag", (m) => { m.unions[0].discriminant.cases.push({ tag: 1, values: ["other"] }); }, "invalid discriminant tag"],
-    ["empty values", (m) => { m.unions[0].discriminant.cases[0].values = []; }, "empty discriminant values"],
-    ["wrong primitive", (m) => { m.unions[0].discriminant.cases[0].values = [false]; }, "invalid or repeated"],
-    ["shared literal", (m) => { m.unions[0].discriminant.cases[1].values = ["empty"]; }, "invalid or repeated"],
-    ["duplicate literal", (m) => { m.unions[0].discriminant.cases[0].values = ["empty", "empty"]; }, "invalid or repeated"],
+    [
+        "missing arm",
+        (m) => {
+            m.unions[0].discriminant.cases.pop();
+        },
+        "missing discriminant",
+    ],
+    [
+        "unit arm",
+        (m) => {
+            m.unions[0].discriminant.cases[0].tag = 0;
+        },
+        "invalid discriminant tag",
+    ],
+    [
+        "negative tag",
+        (m) => {
+            m.unions[0].discriminant.cases[0].tag = -1;
+        },
+        "invalid discriminant tag",
+    ],
+    [
+        "fractional tag",
+        (m) => {
+            m.unions[0].discriminant.cases[0].tag = 1.5;
+        },
+        "invalid discriminant tag",
+    ],
+    [
+        "missing field",
+        (m) => {
+            m.unions[0].discriminant.field = "absent";
+        },
+        "invalid discriminant tag",
+    ],
+    [
+        "duplicate tag",
+        (m) => {
+            m.unions[0].discriminant.cases.push({ tag: 1, values: ["other"] });
+        },
+        "invalid discriminant tag",
+    ],
+    [
+        "empty values",
+        (m) => {
+            m.unions[0].discriminant.cases[0].values = [];
+        },
+        "empty discriminant values",
+    ],
+    [
+        "wrong primitive",
+        (m) => {
+            m.unions[0].discriminant.cases[0].values = [false];
+        },
+        "invalid or repeated",
+    ],
+    [
+        "shared literal",
+        (m) => {
+            m.unions[0].discriminant.cases[1].values = ["empty"];
+        },
+        "invalid or repeated",
+    ],
+    [
+        "duplicate literal",
+        (m) => {
+            m.unions[0].discriminant.cases[0].values = ["empty", "empty"];
+        },
+        "invalid or repeated",
+    ],
 ])("discriminator metadata rejects %s", (_name, mutate, message) => {
     const mod = discriminatedModule();
     mutate(mod);
@@ -835,7 +1411,14 @@ test("mixed literal discriminators resolve field unions declared later", () => {
     expect(validateModule(mod).some((error) => error.message.includes("invalid or repeated"))).toBe(true);
 });
 test("typed-array brand tests serialize their element kind and reject misplaced brands", () => {
-    const expr = { kind: "dynTest", test: "bytes", bytesElem: "u16", value: { kind: "dynObjLit", type: DYN, loc }, type: BOOL, loc };
+    const expr = {
+        kind: "dynTest",
+        test: "bytes",
+        bytesElem: "u16",
+        value: { kind: "dynObjLit", type: DYN, loc },
+        type: BOOL,
+        loc,
+    };
     const mod = expressionModule(expr, []);
     expect(validateModule(mod)).toEqual([]);
     expect(deserializeModule(serializeModule(mod))).toEqual(mod);