@scriptc/compiler 0.1.7 → 0.2.1

package/dist/ir/validate.test.js

@@ -1,8 +1,170 @@
 import { expect, test } from "vitest";
-import { BOOL, F64, STRING, VOID, arrayOf } from "./ir.js";
+import { BOOL, DYN, 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" },
+    ];
+    expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
+    for (const variant of ["target", "library", "return", "params", "callback-id"]) {
+        const bad = structuredClone(mod);
+        const registration = bad.ffiImports[0];
+        const release = bad.ffiImports[1];
+        if (variant === "target")
+            release.callbackTarget = "missing";
+        if (variant === "library")
+            release.library = "different";
+        if (variant === "return")
+            registration.returns = "void";
+        if (variant === "params")
+            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);
+    }
+});
+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 }];
+    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 }],
+        classCaptures: [{ localId: "capture", name: "value", type: F64, slot: 0 }],
+        returnType: VOID, body: [], loc,
+    });
+    return mod;
+}
+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 });
+    expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
+    for (const variant of ["missing", "params", "return", "captures"]) {
+        const bad = structuredClone(mod);
+        const helper = bad.functions[1];
+        if (variant === "missing")
+            bad.functions.pop();
+        if (variant === "params")
+            helper.params.push({ localId: "p", name: "p", type: DYN });
+        if (variant === "return")
+            helper.returnType = F64;
+        if (variant === "captures")
+            helper.captures = [];
+        expect(validateModule(bad).some((error) => error.message.includes("prototype data helper"))).toBe(true);
+    }
+});
+test("local classes retain serialized capture slots and fresh identity", () => {
+    const mod = localClassModule();
+    expect(validateModule(mod)).toEqual([]);
+    expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+});
+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 });
+    expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
+    for (const variant of ["missing", "params", "receiver", "return", "captures"]) {
+        const bad = structuredClone(mod);
+        const helper = bad.functions.at(-1);
+        if (variant === "missing")
+            bad.functions.pop();
+        if (variant === "params")
+            helper.params = [];
+        if (variant === "receiver")
+            helper.params[0].type = DYN;
+        if (variant === "return")
+            helper.returnType = F64;
+        if (variant === "captures")
+            helper.captures = [];
+        expect(validateModule(bad).some((error) => error.message.includes("instance prototype helper"))).toBe(true);
+    }
+});
+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 }];
+    expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+    expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
+    for (const variant of ["missing", "type", "class", "capture"]) {
+        const bad = structuredClone(mod);
+        if (variant === "missing")
+            bad.globals = [];
+        if (variant === "type")
+            bad.globals[0].type = DYN;
+        if (variant === "class")
+            bad.globals[0].type = { kind: "classval", className: "Child" };
+        if (variant === "capture")
+            bad.classes[1].localBaseCapture = 0;
+        expect(validateModule(bad).some((error) => error.message.includes("computed base global"))).toBe(true);
+    }
+});
+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.globals = [{ id: "%g.key", name: "key", type: SYMBOL_T, mutable: false }];
+    expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+    expect(validateModule(deserializeModule(serializeModule(mod)))).toEqual([]);
+    for (const variant of ["global", "type", "field"]) {
+        const bad = structuredClone(mod);
+        if (variant === "global")
+            bad.globals = [];
+        if (variant === "type")
+            bad.globals[0].type = STRING;
+        if (variant === "field")
+            bad.classes[0].fields = [];
+        expect(validateModule(bad).some((error) => error.message.includes("symbol field metadata"))).toBe(true);
+    }
+});
+test.each(["missing", "unboxed", "type", "slot", "receiver", "closure", "layout", "direct-new"])("local classes reject an invalid %s environment", (variant) => {
+    const mod = localClassModule();
+    const ctor = mod.functions[1];
+    if (variant === "missing")
+        mod.functions[0].locals = [];
+    if (variant === "unboxed")
+        delete mod.functions[0].locals[0].boxed;
+    if (variant === "type")
+        ctor.locals[1].type = STRING;
+    if (variant === "slot")
+        ctor.classCaptures[0].slot = 1;
+    if (variant === "receiver")
+        ctor.params[0].type = F64;
+    if (variant === "closure")
+        ctor.captures = [];
+    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 }];
+    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) => {
+    const mod = expressionModule({ kind: "numLit", value: 0, type: F64, loc }, [
+        { id: "nullable", arms: [type, NULL_T, UNDEFINED_T] },
+    ]);
+    expect(validateModule(mod)).toEqual([]);
+    expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+});
+test.each([mapOf(STRING, F64), setOf(STRING), { kind: "promise", inner: F64 }])("%j payloads still refuse unrelated data siblings", (type) => {
+    const mod = expressionModule({ kind: "numLit", value: 0, type: F64, loc }, [
+        { id: "mixed", arms: [type, STRING, UNDEFINED_T] },
+    ]);
+    expect(validateModule(mod).map((error) => error.message)).toContain(`union mixed: ${type.kind} arm 0 beside non-unit arms`);
+});
+test("two differently typed Map payloads cannot silently share one tag test", () => {
+    const mod = expressionModule({ kind: "numLit", value: 0, type: F64, loc }, [
+        { id: "maps", arms: [mapOf(STRING, F64), mapOf(STRING, STRING), UNDEFINED_T] },
+    ]);
+    expect(validateModule(mod).filter((error) => error.message.includes("beside non-unit arms"))).toHaveLength(2);
+});
 function numericReadModule(overrides = {}) {
     const read = {
         kind: "arrIntrinsic", method: "getNumber",
@@ -11,10 +173,206 @@ function numericReadModule(overrides = {}) {
         type: F64, loc, ...overrides,
     };
     return {
-        irVersion: 11, sourceFile: loc.file, entry: "main",
+        irVersion: 13, sourceFile: loc.file, entry: "main",
         functions: [{ name: "main", params: [], locals: [], returnType: VOID, body: [{ kind: "exprStmt", expr: read, loc }], loc }],
     };
 }
+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 }],
+    };
+}
+test("library callbacks retain child, specialized, and generic result diagnostics", () => {
+    const expr = {
+        kind: "libCall", fn: "cp.execFile", type: F64, loc,
+        args: [
+            { kind: "strLit", value: "tool", type: STRING, loc },
+            { kind: "arrayLit", elems: [], type: arrayOf(STRING), loc },
+            { kind: "boolLit", value: true, type: F64, loc },
+        ],
+    };
+    expect(validateModule(expressionModule(expr, [])).map((error) => error.message)).toEqual([
+        "in main: boolLit must be bool",
+        "in main: libCall cp.execFile callback must be a non-rest void function with at most three parameters",
+        "in main: libCall cp.execFile must be child, got f64",
+    ]);
+});
+test("nullish chains retain child-before-parent diagnostic order", () => {
+    const at = (start) => ({ ...loc, start });
+    const expr = {
+        kind: "nullish", type: F64, loc: at(4),
+        left: {
+            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) },
+        },
+        right: { kind: "strLit", value: "wrong", type: F64, loc: at(3) },
+    };
+    expect(validateModule(expressionModule(expr, [])).map((error) => [error.loc.start, error.message])).toEqual([
+        [0, "in main: numLit must be f64"],
+        [1, "in main: boolLit must be bool"],
+        [1, "in main: nullish right operand: expected string, got f64"],
+        [2, "in main: nullish left must be a union, got string"],
+        [3, "in main: strLit must be string"],
+        [4, "in main: nullish left must be a union, got string"],
+    ]);
+});
+test("logical trees retain left/right/parent diagnostic order", () => {
+    const at = (start) => ({ ...loc, start });
+    const expr = {
+        kind: "logical", op: "&&", type: BOOL, loc: at(4),
+        left: {
+            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) },
+        },
+        right: { kind: "strLit", value: "wrong", type: BOOL, loc: at(3) },
+    };
+    expect(validateModule(expressionModule(expr, [])).map((error) => [error.loc.start, error.message])).toEqual([
+        [0, "in main: numLit must be f64"],
+        [1, "in main: boolLit must be bool"],
+        [1, "in main: logical || right: expected string, got f64"],
+        [3, "in main: strLit must be string"],
+        [2, "in main: logical && left: expected bool, got string"],
+    ]);
+});
+test("conditional trees retain condition/then/else/parent diagnostic order", () => {
+    const at = (start) => ({ ...loc, start });
+    const expr = {
+        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) },
+    };
+    expect(validateModule(expressionModule(expr, [])).map((error) => [error.loc.start, error.message])).toEqual([
+        [0, "in main: numLit must be f64"],
+        [1, "in main: boolLit must be bool"],
+        [2, "in main: strLit must be string"],
+        [1, "in main: ternary then-branch: expected string, got f64"],
+        [2, "in main: ternary else-branch: expected string, got bool"],
+    ]);
+});
+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 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 };
+    const mod = expressionModule(call, []);
+    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 };
+    expect(validateModule(mod).some((error) => error.message.includes(`${kind} receiver`))).toBe(true);
+    call.receiver = { kind: "varRef", localId: "missing", type: DYN, loc };
+    expect(validateModule(mod).some((error) => error.message.includes("missing"))).toBe(true);
+});
+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: 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,
+    };
+    return expressionModule(chain, [{ id: "receiver", arms }]);
+}
+test("optional chains over several value arms bind the tagged receiver", () => {
+    const mod = optionalUnionModule();
+    expect(validateModule(mod)).toEqual([]);
+    expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+});
+test("optional chains reject bindings that discard a surviving variant", () => {
+    const mod = optionalUnionModule();
+    const statement = mod.functions[0].body[0];
+    if (statement.kind !== "exprStmt" || statement.expr.kind !== "optChain")
+        throw new Error("fixture");
+    statement.expr.body = { kind: "chainRecv", id: "test", type: F64, loc };
+    expect(validateModule(mod).some((error) => error.message.includes("chainRecv: expected"))).toBe(true);
+});
+test.each([
+    [BOOL, F64],
+    [NULL_T, UNDEFINED_T],
+])("optional chains need both a present and an absent path %#", (...arms) => {
+    expect(validateModule(optionalUnionModule(arms)).some((error) => error.message.includes("must have unit arms and at least one non-unit arm"))).toBe(true);
+});
+test("a single present arm still binds its payload", () => {
+    const mod = optionalUnionModule([F64, UNDEFINED_T]);
+    expect(validateModule(mod).some((error) => error.message.includes("chainRecv: expected"))).toBe(true);
+    const statement = mod.functions[0].body[0];
+    if (statement.kind !== "exprStmt" || statement.expr.kind !== "optChain")
+        throw new Error("fixture");
+    statement.expr.body = {
+        kind: "unionWrap", unionId: "receiver", tag: 0,
+        value: { kind: "chainRecv", id: "test", type: F64, loc },
+        type: { kind: "union", unionId: "receiver" }, loc,
+    };
+    expect(validateModule(mod)).toEqual([]);
+});
+function keyedUnionModule(resultArms, overflowOnly = false) {
+    const stored = { kind: "union", unionId: "stored" };
+    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,
+                } }],
+    };
+    const read = {
+        kind: "recordKeyGet", obj, shapeId: "row",
+        key: { kind: "strLit", value: overflowOnly ? "extra" : "value", type: STRING, loc },
+        type: result, loc, ...(overflowOnly ? { overflowOnly: true } : {}),
+    };
+    const mod = expressionModule(read, [
+        { id: "stored", arms: [F64, NULL_T] }, { id: "result", arms: resultArms },
+    ]);
+    mod.records = [{ id: "row", fields: [{ name: "value", type: stored }], indexValue: stored }];
+    return mod;
+}
+test.each([false, true])("keyed union reads validate a payload-preserving widening (overflow=%s)", (overflow) => {
+    const mod = keyedUnionModule([BOOL, F64, NULL_T, UNDEFINED_T], overflow);
+    expect(validateModule(mod)).toEqual([]);
+    expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+});
+test.each([false, true])("keyed union reads refuse to discard a stored arm (overflow=%s)", (overflow) => {
+    const errors = validateModule(keyedUnionModule([F64, STRING, UNDEFINED_T], overflow));
+    expect(errors.some((error) => error.message.includes("cannot surface as the result type"))).toBe(true);
+});
+test("union array reads validate every element layout against the joined result", () => {
+    const stored = { kind: "union", unionId: "stored" };
+    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,
+    };
+    const read = {
+        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,
+    };
+    const mod = expressionModule(read, [
+        { id: "stored", arms: [F64, NULL_T] },
+        { id: "arrays", arms: [arrayOf(stored), arrayOf(STRING), UNDEFINED_T] },
+        { id: "result", arms: [F64, NULL_T, STRING, UNDEFINED_T] },
+    ]);
+    expect(validateModule(mod)).toEqual([]);
+    expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+    mod.unions[2].arms = [F64, STRING, UNDEFINED_T];
+    expect(validateModule(mod).some((error) => error.message.includes("element union cannot surface"))).toBe(true);
+});
 test("numeric array-read intrinsic validates and round-trips", () => {
     const mod = numericReadModule();
     expect(validateModule(mod)).toEqual([]);
@@ -45,4 +403,180 @@ test.each([
 ])("numeric array-read intrinsic rejects malformed IR %#", (overrides, message) => {
     expect(validateModule(numericReadModule(overrides)).some((error) => error.message.includes(message))).toBe(true);
 });
+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,
+                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) => {
+    const mod = tdzModule(mutable);
+    expect(validateModule(mod)).toEqual([]);
+    expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+});
+test("an initialization marker cannot bypass an ordinary immutable binding", () => {
+    const mod = tdzModule(false);
+    delete mod.functions[0].locals[0].tdz;
+    const messages = validateModule(mod).map((error) => error.message);
+    expect(messages.some((message) => message.includes('initializing assign requires a TDZ binding "value"'))).toBe(true);
+    expect(messages.some((message) => message.includes('assign to immutable local "value"'))).toBe(true);
+});
+test("global assignments cannot masquerade as lexical initialization", () => {
+    const mod = tdzModule();
+    mod.globals = [{ id: "value", name: "value", type: F64, mutable: true }];
+    mod.functions[0].locals = [];
+    mod.functions[0].body.shift();
+    expect(validateModule(mod).some((error) => error.message.includes("initializing assign requires a TDZ binding"))).toBe(true);
+});
+test("TDZ globals require guarded pointer storage and round-trip initialization", () => {
+    const mod = tdzModule();
+    const type = { kind: "record", shapeId: "codec" };
+    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 },
+        }];
+    expect(validateModule(mod)).toEqual([]);
+    expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+    mod.globals[0].type = F64;
+    expect(validateModule(mod).some((error) => error.message.includes('TDZ global "value" must have record, function, or checked-value storage'))).toBe(true);
+});
+test("legacy const TDZ declarations remain readable", () => {
+    const mod = tdzModule(false);
+    const store = mod.functions[0].body[1];
+    if (store.kind !== "assign")
+        throw new Error("fixture");
+    delete store.initializes;
+    expect(validateModule(mod)).toEqual([]);
+});
+test("TDZ initialization still checks the payload representation", () => {
+    const mod = tdzModule();
+    const store = mod.functions[0].body[1];
+    if (store.kind !== "assign")
+        throw new Error("fixture");
+    store.value = { kind: "strLit", value: "wrong", type: STRING, loc };
+    expect(validateModule(mod).some((error) => error.message.includes('assign "value"'))).toBe(true);
+});
+function overflowPresenceModule() {
+    const record = { kind: "record", shapeId: "dictionary" };
+    const check = {
+        kind: "recordOvfHas", shapeId: "dictionary",
+        obj: { kind: "recordLit", fields: [], type: record, loc },
+        key: { kind: "strLit", value: "key", type: STRING, loc }, type: BOOL, loc,
+    };
+    const mod = expressionModule(check, []);
+    mod.records = [{ id: "dictionary", fields: [], indexValue: F64 }];
+    return mod;
+}
+test("overflow presence checks validate and serialize", () => {
+    const mod = overflowPresenceModule();
+    expect(validateModule(mod)).toEqual([]);
+    expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+});
+test("overflow presence requires a map-bearing shape", () => {
+    const mod = overflowPresenceModule();
+    delete mod.records[0].indexValue;
+    expect(validateModule(mod).some((error) => error.message.includes("requires an index-signature record"))).toBe(true);
+});
+test("overflow presence rejects an undeclared shape", () => {
+    const mod = overflowPresenceModule();
+    mod.records = [];
+    expect(validateModule(mod).some((error) => error.message.includes("recordOvfHas on undeclared shape"))).toBe(true);
+});
+test.each(["receiver", "key", "result"])("overflow presence checks its %s type", (slot) => {
+    const mod = overflowPresenceModule();
+    const statement = mod.functions[0].body[0];
+    if (statement.kind !== "exprStmt" || statement.expr.kind !== "recordOvfHas")
+        throw new Error("fixture");
+    const check = statement.expr;
+    const wrong = { kind: "numLit", value: 1, type: F64, loc };
+    if (slot === "receiver")
+        check.obj = wrong;
+    else if (slot === "key")
+        check.key = wrong;
+    else
+        check.type = F64;
+    const message = slot === "result" ? "recordOvfHas must be bool" : `recordOvfHas ${slot}`;
+    expect(validateModule(mod).some((error) => error.message.includes(message))).toBe(true);
+});
+test("TDZ locals require a shared box", () => {
+    const mod = tdzModule();
+    delete mod.functions[0].locals[0].boxed;
+    expect(validateModule(mod).some((error) => error.message.includes('TDZ local "value" must be boxed'))).toBe(true);
+});
+function discriminatedModule() {
+    return {
+        irVersion: 13, 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 }] },
+        ],
+        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", () => {
+    const mod = discriminatedModule();
+    expect(validateModule(mod)).toEqual([]);
+    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"],
+])("discriminator metadata rejects %s", (_name, mutate, message) => {
+    const mod = discriminatedModule();
+    mutate(mod);
+    expect(validateModule(mod).some((error) => error.message.includes(message))).toBe(true);
+});
+test("numeric discriminators reject non-finite values", () => {
+    const mod = discriminatedModule();
+    for (const record of mod.records)
+        record.fields[0].type = F64;
+    const guard = mod.unions[0].discriminant;
+    guard.cases[0].values = [0];
+    guard.cases[1].values = [1];
+    expect(validateModule(mod)).toEqual([]);
+    for (const invalid of [NaN, Infinity, -Infinity]) {
+        guard.cases[1].values = [invalid];
+        expect(validateModule(mod).some((error) => error.message.includes("invalid or repeated"))).toBe(true);
+    }
+});
+test("mixed literal discriminators resolve field unions declared later", () => {
+    const mod = discriminatedModule();
+    mod.records[1].fields[0].type = { kind: "union", unionId: "literal" };
+    mod.unions[0].discriminant.cases[1].values = ["value", 1];
+    mod.unions.push({ id: "literal", arms: [F64, STRING] });
+    expect(validateModule(mod)).toEqual([]);
+    mod.unions[0].discriminant.cases[1].values.push(false);
+    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 mod = expressionModule(expr, []);
+    expect(validateModule(mod)).toEqual([]);
+    expect(deserializeModule(serializeModule(mod))).toEqual(mod);
+    expr.test = "array";
+    expect(validateModule(mod).map((d) => d.message)).toContain("in main: dynTest bytesElem requires a valid bytes test");
+});
 //# sourceMappingURL=validate.test.js.map