@scriptc/compiler 0.3.2 → 0.3.4

package/dist/frontend/lowering/lower-assert.js

@@ -27,10 +27,10 @@ import * as ts from "../ts7/adapter.js";
 import { resultIsDiscarded } from "./call-position.js";
 import { jsFuncNameOf, own } from "./lowerer.js";
 import { NARROW_FIRST } from "./surfaces.js";
-import { inspectExpr, typeReachesItself } from "./lower-inspect.js";
+import { inspectExpr, typeReachesCycle, typeReachesFunction, typeReachesItself, } from "./lower-inspect.js";
 import { abstractEqualityExpr, abstractEqualitySupported } from "./abstract-equality.js";
 import { BOOL, CAUGHT, DYN, DYN_HANDLE_KINDS, F64, REGEX, RUNTIME_ERROR_CLASSES, STRING, VOID, isUnitType, typeEquals, typeKey, } from "../../ir/ir.js";
-import { boolLit, countedFor, numLit, strLit, varRef } from "../../ir/build.js";
+import { boolLit, countedFor, dynUndefinedExpr, numLit, strLit, varRef } from "../../ir/build.js";
 /** node:assert/strict binds the loose NAMES to the strict comparisons —
  * Node's own aliasing (`strict.equal === assert.strictEqual`). */
 const STRICT_ALIASES = {
@@ -46,6 +46,68 @@ function canonicalAssertMember(module, member) {
         return own(STRICT_ALIASES, member) ?? member;
     return member;
 }
+/* Node's AssertionError carries actual, expected and operator. Where the
+ * verdict is computed in compiled code, the failure branch records them
+ * (assert.record) before the throwing call, so a passing assertion boxes
+ * nothing. Values without a checked-dynamic form record undefined, and so
+ * do values whose type can be cyclic (the checked-dynamic form is a deep
+ * copy, which a cyclic value does not have) or can hold functions (their
+ * boxes carry no source names, which the failure message prints). */
+/** A value as the dyn the record carries. */
+function recordedValue(lowerer, value, loc) {
+    if (value === null)
+        return dynUndefinedExpr(loc);
+    if (value.type.kind === "dyn")
+        return value;
+    if (value.kind === "unitLit" ||
+        (lowerer.dynConvertible(value.type) &&
+            !typeReachesCycle(lowerer, value.type) &&
+            !typeReachesFunction(lowerer, value.type))) {
+        return { kind: "dynFrom", value, type: DYN, loc };
+    }
+    return dynUndefinedExpr(loc);
+}
+/** `if (failing) assert.record(actual, expected, operator)`. */
+function recordOnFailure(lowerer, failing, actual, expected, operator, loc) {
+    return {
+        kind: "if",
+        cond: failing,
+        then: [
+            {
+                kind: "exprStmt",
+                expr: {
+                    kind: "libCall",
+                    fn: "assert.record",
+                    args: [
+                        recordedValue(lowerer, actual, loc),
+                        recordedValue(lowerer, expected, loc),
+                        strLit(operator, loc),
+                    ],
+                    type: VOID,
+                    loc,
+                },
+                loc,
+            },
+        ],
+        else_: null,
+        loc,
+    };
+}
+/** A value held in a hidden local, so the verdict and the record read it once. */
+function stableValue(lowerer, stmts, value, name, loc) {
+    if (value.kind === "varRef" ||
+        value.kind === "unitLit" ||
+        value.kind === "boolLit" ||
+        value.kind === "numLit" ||
+        value.kind === "strLit")
+        return value;
+    const local = lowerer.declareHiddenLocal(name, value.type);
+    stmts.push({ kind: "varDecl", localId: local.id, init: value, loc });
+    return varRef(local.id, value.type, loc);
+}
+function notExpr(value, loc) {
+    return { kind: "unary", op: "!", operand: value, type: BOOL, loc };
+}
 /** VOID/never results are usable as statements and concise arrow bodies
  * only (the lower-dgram stance): nothing downstream can consume them. */
 function requireStatementPosition(lowerer, call, what) {
@@ -90,6 +152,12 @@ export function lowerAssertModuleCall(lowerer, expr, bi, loc) {
             return lowerAssertEqual(lowerer, expr, loc, false, true);
         case "notDeepStrictEqual":
             return lowerAssertEqual(lowerer, expr, loc, true, true);
+        case "deepEqual":
+            return lowerAssertLooseDeep(lowerer, expr, loc, false);
+        case "notDeepEqual":
+            return lowerAssertLooseDeep(lowerer, expr, loc, true);
+        case "partialDeepStrictEqual":
+            return lowerAssertPartialDeep(lowerer, expr, loc);
         case "fail":
             return lowerAssertFail(lowerer, expr, loc);
         case "match":
@@ -164,9 +232,20 @@ function lowerAssertLooseEqual(lowerer, expr, loc, negated) {
     };
     const a = stable(left, "%assertLooseA");
     const b = stable(right, "%assertLooseB");
-    const equal = abstractEqualityExpr(lowerer, a, b, loc, true);
-    const actual = inspectExpr(lowerer, a.type, a, numLit(0, loc), numLit(2, loc), loc);
-    const expected = inspectExpr(lowerer, b.type, b, numLit(0, loc), numLit(2, loc), loc);
+    const equal = stableValue(lowerer, stmts, abstractEqualityExpr(lowerer, a, b, loc, true), "%assertLooseEqual", loc);
+    const failing = negated ? equal : notExpr(equal, loc);
+    stmts.push(recordOnFailure(lowerer, failing, a, b, negated ? "!=" : "==", loc));
+    // The operands are inspected only for the failure message.
+    const inspectOnFailure = (value) => ({
+        kind: "ternary",
+        cond: failing,
+        then: inspectExpr(lowerer, value.type, value, numLit(0, loc), numLit(2, loc), loc),
+        else_: strLit("", loc),
+        type: STRING,
+        loc,
+    });
+    const actual = inspectOnFailure(a);
+    const expected = inspectOnFailure(b);
     const { msg, hasMsg } = lowerMessageArg(lowerer, expr.arguments[2], loc);
     const result = {
         kind: "libCall",
@@ -177,6 +256,437 @@ function lowerAssertLooseEqual(lowerer, expr, loc, negated) {
     };
     return { kind: "seqExpr", stmts, result, type: VOID, loc };
 }
+/** The two compared operands. A context-free EMPTY array literal on
+ * either side has no element type of its own (`deepStrictEqual(
+ * ee.listeners('x'), [])` — the checker says any[]): it adopts the OTHER
+ * side's array type. Literals have no side effects, so lowering order is
+ * unobservable. */
+function lowerComparedOperands(lowerer, aNode, bNode, loc) {
+    const emptyArrayLit = (n) => ts.isArrayLiteralExpression(n) && n.elements.length === 0;
+    const emptyOf = (t) => ({ kind: "arrayLit", elems: [], type: t, loc });
+    // A dyn other side adopts number[] — the dyn array a boxed empty
+    // literal builds is elementless, so any elem type serves.
+    const adoptedEmpty = (other) => other.kind === "array"
+        ? emptyOf(other)
+        : other.kind === "dyn"
+            ? emptyOf({ kind: "array", elem: F64 })
+            : null;
+    if (emptyArrayLit(aNode) && !emptyArrayLit(bNode)) {
+        const b = lowerer.lowerExpr(bNode);
+        return { a: adoptedEmpty(b.type) ?? lowerer.lowerExpr(aNode), b };
+    }
+    const a = lowerer.lowerExpr(aNode);
+    const b = emptyArrayLit(bNode)
+        ? (adoptedEmpty(a.type) ?? lowerer.lowerExpr(bNode))
+        : lowerer.lowerExpr(bNode);
+    return { a, b };
+}
+/** True when a union occurs anywhere in `t`'s value structure. */
+function typeHasUnion(lowerer, t, visiting) {
+    switch (t.kind) {
+        case "union":
+            return true;
+        case "array":
+        case "set":
+            return typeHasUnion(lowerer, t.elem, visiting);
+        case "map":
+            return typeHasUnion(lowerer, t.key, visiting) || typeHasUnion(lowerer, t.value, visiting);
+        case "record": {
+            if (visiting.has(t.shapeId))
+                return false;
+            visiting.add(t.shapeId);
+            const shape = lowerer.shapes.get(t.shapeId);
+            return shape?.fields.some((f) => typeHasUnion(lowerer, f.type, visiting)) ?? false;
+        }
+        default:
+            return false;
+    }
+}
+/** assert.deepEqual / notDeepEqual: Node's loose deep comparison. Two
+ * operands of one union-free static type compare through the per-type
+ * helper in its loose mode (numbers under ==, typed arrays without the
+ * Buffer brand); everything else crosses into the checked-dynamic tree
+ * and compares there. Types that can be cyclic are refused: the failure
+ * message renders the values, which needs their checked-dynamic copy. */
+function lowerAssertLooseDeep(lowerer, expr, loc, negated) {
+    const surface = negated ? "assert.notDeepEqual" : "assert.deepEqual";
+    requireStatementPosition(lowerer, expr, surface);
+    if (expr.arguments.length < 2 || expr.arguments.length > 3) {
+        lowerer.noLowering(`${surface} with ${expr.arguments.length} arguments`, expr);
+    }
+    const aNode = expr.arguments[0];
+    const bNode = expr.arguments[1];
+    const { a, b } = lowerComparedOperands(lowerer, aNode, bNode, loc);
+    const { msg, hasMsg } = lowerMessageArg(lowerer, expr.arguments[2], loc);
+    refuseUnrenderedDeepOperands(lowerer, surface, [
+        [a, aNode],
+        [b, bNode],
+    ], "loose");
+    if (typeEquals(a.type, b.type) &&
+        a.type.kind !== "dyn" &&
+        // Functions box with their source names for the message.
+        a.type.kind !== "func" &&
+        !isUnitType(a.type) &&
+        deepUnsupportedReason(lowerer, a.type, new Set()) === null &&
+        !typeHasUnion(lowerer, a.type, new Set())) {
+        const verdictOf = a.type.kind === "bytes"
+            ? (x, y) => ({
+                kind: "libCall",
+                fn: "assert.looseBytesEq",
+                args: [x, y],
+                type: BOOL,
+                loc,
+            })
+            : (x, y) => ({
+                kind: "call",
+                callee: deepEqHelper(lowerer, a.type, loc, true),
+                args: [x, y],
+                type: BOOL,
+                loc,
+            });
+        return deepCheckCall(lowerer, a, b, "loose", verdictOf, negated, msg, hasMsg, loc, "loose");
+    }
+    return {
+        kind: "libCall",
+        fn: "assert.looseDeepDyn",
+        args: [
+            boxDeepOperand(lowerer, surface, a, aNode, a, b),
+            boxDeepOperand(lowerer, surface, b, bNode, a, b),
+            boolLit(negated, loc),
+            msg,
+            hasMsg,
+        ],
+        type: VOID,
+        loc,
+    };
+}
+/** The operand types the checked-dynamic deep comparisons refuse: types
+ * that can be cyclic, and structures holding functions. Their failure
+ * messages render the checked-dynamic copy, which a cyclic value does not
+ * have and in which a nested function loses its source name. */
+function refuseUnrenderedDeepOperands(lowerer, surface, operands, hintFor) {
+    for (const [value, node] of operands) {
+        if (value.type.kind !== "dyn" && typeReachesCycle(lowerer, value.type)) {
+            lowerer.noLowering(`${surface} of '${lowerer.fmt(value.type)}' values`, node, `recursive types have no ${hintFor} deep comparison — deepStrictEqual compares them`);
+        }
+        if (value.type.kind !== "func" && typeReachesFunction(lowerer, value.type)) {
+            lowerer.noLowering(`${surface} of '${lowerer.fmt(value.type)}' values`, node, `structures holding functions have no ${hintFor} deep comparison — compare the functions with strictEqual`);
+        }
+    }
+}
+/** An operand as the checked-dynamic value the runtime comparisons take;
+ * a function boxes with its source name for the message. */
+function boxDeepOperand(lowerer, surface, e, node, a, b) {
+    if (e.type.kind === "dyn")
+        return e;
+    const convertible = e.kind === "unitLit" ||
+        (e.type.kind === "object" && e.type.className === "%Error") ||
+        lowerer.dynConvertible(e.type);
+    if (!convertible) {
+        lowerer.noLowering(`${surface} of '${lowerer.fmt(a.type)}' and '${lowerer.fmt(b.type)}' values`, node, "both sides must convert into the checked-dynamic tree (primitives, functions, arrays, records, Maps, Sets, typed arrays and errors)");
+    }
+    const fnName = e.type.kind === "func" ? jsFuncNameOf(node) : null;
+    return {
+        kind: "dynFrom",
+        value: e,
+        ...(fnName !== null ? { fnName } : {}),
+        type: DYN,
+        loc: e.loc,
+    };
+}
+/** assert.partialDeepStrictEqual: Node's partial deep comparison (the
+ * expected value contained in the actual one), over the checked-dynamic
+ * copies of both operands. */
+function lowerAssertPartialDeep(lowerer, expr, loc) {
+    const surface = "assert.partialDeepStrictEqual";
+    requireStatementPosition(lowerer, expr, surface);
+    if (expr.arguments.length < 2 || expr.arguments.length > 3) {
+        lowerer.noLowering(`${surface} with ${expr.arguments.length} arguments`, expr);
+    }
+    const aNode = expr.arguments[0];
+    const bNode = expr.arguments[1];
+    const { a, b } = lowerComparedOperands(lowerer, aNode, bNode, loc);
+    const { msg, hasMsg } = lowerMessageArg(lowerer, expr.arguments[2], loc);
+    refuseUnrenderedDeepOperands(lowerer, surface, [
+        [a, aNode],
+        [b, bNode],
+    ], "partial");
+    const boxedA = boxDeepOperand(lowerer, surface, a, aNode, a, b);
+    const boxedB = boxDeepOperand(lowerer, surface, b, bNode, a, b);
+    // Functions box with their source names for the message.
+    if (a.type.kind !== "dyn" &&
+        b.type.kind !== "dyn" &&
+        a.type.kind !== "func" &&
+        b.type.kind !== "func") {
+        // Statically typed operands compare through the typed partial
+        // comparison; only subtrees it does not cover cross into the
+        // checked-dynamic tree.
+        return deepCheckCall(lowerer, a, b, "partial", (x, y) => partialEqExpr(lowerer, x, y, loc), false, msg, hasMsg, loc, "partial");
+    }
+    return {
+        kind: "libCall",
+        fn: "assert.partialDeepDyn",
+        args: [boxedA, boxedB, msg, hasMsg],
+        type: VOID,
+        loc,
+    };
+}
+const SCALAR_KINDS = new Set(["f64", "string", "bool", "bigint", "symbol"]);
+/** Node's partial deep comparison of `x` (actual) and `y` (expected), two
+ * side-effect-free reads of statically typed values. Scalars compare by
+ * Object.is, mismatched primitive kinds are unequal, unions dispatch on
+ * their tags, and arrays and records compare through the lifted helper;
+ * every other pair compares as checked-dynamic values. */
+function partialEqExpr(lowerer, x, y, loc) {
+    const ta = x.type;
+    const tb = y.type;
+    const helperCall = () => ({
+        kind: "call",
+        callee: partialEqHelper(lowerer, ta, tb, loc),
+        args: [x, y],
+        type: BOOL,
+        loc,
+    });
+    // A unit value against a union: equal exactly when the union holds it.
+    const unitAgainstUnion = (unit, union, value) => {
+        if (!isUnitType(unit) || union.kind !== "union")
+            return null;
+        const tag = lowerer.armTag(union.unionId, unit);
+        if (tag < 0)
+            return boolLit(false, loc);
+        return {
+            kind: "unionIsTag",
+            unionId: union.unionId,
+            tag,
+            negated: false,
+            value,
+            type: BOOL,
+            loc,
+        };
+    };
+    const unitCase = unitAgainstUnion(ta, tb, y) ?? unitAgainstUnion(tb, ta, x);
+    if (unitCase)
+        return unitCase;
+    if (ta.kind === "union" || tb.kind === "union")
+        return helperCall();
+    if (isUnitType(ta) || isUnitType(tb))
+        return boolLit(ta.kind === tb.kind, loc);
+    if (SCALAR_KINDS.has(ta.kind) && SCALAR_KINDS.has(tb.kind)) {
+        if (ta.kind !== tb.kind)
+            return boolLit(false, loc);
+        switch (ta.kind) {
+            case "f64":
+                return { kind: "libCall", fn: "assert.sameValue", args: [x, y], type: BOOL, loc };
+            case "bigint":
+                return { kind: "libCall", fn: "bigint.eq", args: [x, y], type: BOOL, loc };
+            case "string":
+                return { kind: "strEq", negated: false, left: x, right: y, type: BOOL, loc };
+            default:
+                return { kind: "bin", op: "===", left: x, right: y, type: BOOL, loc };
+        }
+    }
+    const composite = (t) => t.kind === "array" || t.kind === "record";
+    if ((ta.kind === "array" && tb.kind === "array") ||
+        (ta.kind === "record" &&
+            tb.kind === "record" &&
+            lowerer.shapes.get(ta.shapeId)?.indexValue === undefined &&
+            lowerer.shapes.get(tb.shapeId)?.indexValue === undefined)) {
+        return helperCall();
+    }
+    // A primitive never partially equals an array or a record.
+    if ((SCALAR_KINDS.has(ta.kind) && composite(tb)) ||
+        (composite(ta) && SCALAR_KINDS.has(tb.kind))) {
+        return boolLit(false, loc);
+    }
+    return {
+        kind: "libCall",
+        fn: "assert.partialEqDyn",
+        args: [
+            x.type.kind === "dyn" ? x : { kind: "dynFrom", value: x, type: DYN, loc },
+            y.type.kind === "dyn" ? y : { kind: "dynFrom", value: y, type: DYN, loc },
+        ],
+        type: BOOL,
+        loc,
+    };
+}
+/** The interned `%assert.pdeq.<n>(a, b): boolean` for one pair of static
+ * types: union tag dispatch, ordered-subsequence arrays (partialArrayEquiv),
+ * or records compared over the expected shape's present fields. */
+function partialEqHelper(lowerer, ta, tb, loc) {
+    const key = `assert.pdeq:${typeKey(ta)}|${typeKey(tb)}`;
+    const existing = lowerer.assertHelpers.get(key);
+    if (existing)
+        return existing;
+    const name = `%assert.pdeq.${lowerer.assertHelpers.size}`;
+    lowerer.assertHelpers.set(key, name);
+    const a = () => varRef("a.0", ta, loc);
+    const b = () => varRef("b.0", tb, loc);
+    const ret = (value) => ({ kind: "return", value, loc });
+    const not = (operand) => notExpr(operand, loc);
+    const bailIf = (cond) => ({
+        kind: "if",
+        cond,
+        then: [ret(boolLit(false, loc))],
+        else_: null,
+        loc,
+    });
+    const locals = [
+        { id: "a.0", name: "a", type: ta, mutable: false },
+        { id: "b.0", name: "b", type: tb, mutable: false },
+    ];
+    let body;
+    const unionDispatch = (side) => {
+        const t = side === "a" ? ta : tb;
+        if (t.kind !== "union")
+            throw new InternalCompilerError("partial union dispatch over a non-union");
+        const def = lowerer.unions.get(t.unionId);
+        if (!def)
+            throw new InternalCompilerError(`partial deep-equal of unknown union ${t.unionId}`);
+        const value = side === "a" ? a() : b();
+        const stmts = def.arms.map((arm, tag) => {
+            const narrowed = {
+                kind: "unionNarrow",
+                unionId: t.unionId,
+                tag,
+                value,
+                type: arm,
+                loc,
+            };
+            return {
+                kind: "if",
+                cond: {
+                    kind: "unionIsTag",
+                    unionId: t.unionId,
+                    tag,
+                    negated: false,
+                    value,
+                    type: BOOL,
+                    loc,
+                },
+                then: [
+                    ret(side === "a"
+                        ? partialEqExpr(lowerer, narrowed, b(), loc)
+                        : partialEqExpr(lowerer, a(), narrowed, loc)),
+                ],
+                else_: null,
+                loc,
+            };
+        });
+        stmts.push(ret(boolLit(false, loc)));
+        return stmts;
+    };
+    if (ta.kind === "union") {
+        body = unionDispatch("a");
+    }
+    else if (tb.kind === "union") {
+        body = unionDispatch("b");
+    }
+    else if (ta.kind === "array" && tb.kind === "array") {
+        const len = (arr) => ({
+            kind: "arrIntrinsic",
+            method: "length",
+            receiver: arr,
+            args: [],
+            type: F64,
+            loc,
+        });
+        const pos = () => varRef("pos.0", F64, loc);
+        const bump = {
+            kind: "assign",
+            localId: "pos.0",
+            value: { kind: "bin", op: "+", left: pos(), right: numLit(1, loc), type: F64, loc },
+            loc,
+        };
+        locals.push({ id: "i.0", name: "i", type: F64, mutable: true }, { id: "pos.0", name: "pos", type: F64, mutable: true });
+        body = [
+            bailIf({ kind: "bin", op: "<", left: len(a()), right: len(b()), type: BOOL, loc }),
+            { kind: "varDecl", localId: "pos.0", init: numLit(0, loc), loc },
+            countedFor(loc, len(b()), (i) => [
+                {
+                    kind: "while",
+                    cond: not(partialEqExpr(lowerer, { kind: "arrayGet", arr: a(), index: pos(), type: ta.elem, loc }, { kind: "arrayGet", arr: b(), index: i, type: tb.elem, loc }, loc)),
+                    body: [
+                        bump,
+                        // pos > la - lb + i: the rest of b no longer fits in a.
+                        bailIf({
+                            kind: "bin",
+                            op: ">",
+                            left: pos(),
+                            right: {
+                                kind: "bin",
+                                op: "+",
+                                left: { kind: "bin", op: "-", left: len(a()), right: len(b()), type: F64, loc },
+                                right: i,
+                                type: F64,
+                                loc,
+                            },
+                            type: BOOL,
+                            loc,
+                        }),
+                    ],
+                    loc,
+                },
+                bump,
+            ]),
+            ret(boolLit(true, loc)),
+        ];
+    }
+    else if (ta.kind === "record" && tb.kind === "record") {
+        const shapeA = lowerer.shapes.get(ta.shapeId);
+        const shapeB = lowerer.shapes.get(tb.shapeId);
+        if (!shapeA || !shapeB)
+            throw new InternalCompilerError("partial deep-equal of an unknown shape");
+        body = [];
+        for (const fb of shapeB.fields) {
+            const presentB = lowerer.recordFieldPresent(b(), tb.shapeId, fb.name, loc);
+            const fa = shapeA.fields.find((f) => f.name === fb.name);
+            const checks = [];
+            if (!fa) {
+                checks.push(ret(boolLit(false, loc)));
+            }
+            else {
+                const presentA = lowerer.recordFieldPresent(a(), ta.shapeId, fa.name, loc);
+                if (presentA.kind !== "boolLit")
+                    checks.push(bailIf(not(presentA)));
+                checks.push(bailIf(not(partialEqExpr(lowerer, {
+                    kind: "recordGet",
+                    obj: a(),
+                    shapeId: ta.shapeId,
+                    field: fa.name,
+                    type: fa.type,
+                    loc,
+                }, {
+                    kind: "recordGet",
+                    obj: b(),
+                    shapeId: tb.shapeId,
+                    field: fb.name,
+                    type: fb.type,
+                    loc,
+                }, loc))));
+            }
+            if (presentB.kind === "boolLit")
+                body.push(...checks);
+            else
+                body.push({ kind: "if", cond: presentB, then: checks, else_: null, loc });
+        }
+        body.push(ret(boolLit(true, loc)));
+    }
+    else {
+        throw new InternalCompilerError(`partial deep-equal helper over ${typeKey(ta)} and ${typeKey(tb)}`);
+    }
+    lowerer.liftedFns.push({
+        name,
+        params: [
+            { localId: "a.0", name: "a", type: ta },
+            { localId: "b.0", name: "b", type: tb },
+        ],
+        returnType: BOOL,
+        locals,
+        body,
+        loc,
+    });
+    return name;
+}
 /** The callable-module form: `assert(x)` where the callee identifier IS
  * the assert module binding — a default import (`import assert from
  * "node:assert"`) or the CJS `const assert = require("assert")`. Node's
@@ -208,19 +718,34 @@ function lowerAssertOk(lowerer, expr, loc) {
         lowerer.noLowering(`${expr.expression.getText()} with ${expr.arguments.length} arguments`, expr, "the supported forms are assert(value) and assert(value, message)");
     }
     const valueNode = expr.arguments[0];
-    const pass = lowerer.ensureBool(lowerer.lowerExpr(valueNode), valueNode);
+    const stmts = [];
+    const value = stableValue(lowerer, stmts, lowerer.lowerExpr(valueNode), "%assertOkValue", loc);
+    const pass = stableValue(lowerer, stmts, lowerer.ensureBool(value, valueNode), "%assertOkPass", loc);
     const msgNode = expr.arguments[1];
+    let msg;
+    let generated = false;
     if (!msgNode || (ts.isIdentifier(msgNode) && msgNode.text === "undefined")) {
         // Node reads the CALLSITE LINE and slices the expression out of it
         // (internal/errors/error_source.js) — a call spanning lines truncates
         // at the first newline, so the compile-time text does too.
         const source = expr.getText().split("\n", 1)[0];
-        const generated = `The expression evaluated to a falsy value:\n\n  ${source}\n`;
-        const msg = { kind: "strLit", value: generated, type: STRING, loc };
-        return { kind: "libCall", fn: "assert.ok", args: [pass, msg], type: VOID, loc };
+        const text = `The expression evaluated to a falsy value:\n\n  ${source}\n`;
+        msg = { kind: "strLit", value: text, type: STRING, loc };
+        generated = true;
+    }
+    else {
+        msg = lowerMessageArg(lowerer, msgNode, loc).msg;
     }
-    const { msg } = lowerMessageArg(lowerer, msgNode, loc);
-    return { kind: "libCall", fn: "assert.ok", args: [pass, msg], type: VOID, loc };
+    // Node's actual is the value, expected true, operator "==".
+    stmts.push(recordOnFailure(lowerer, notExpr(pass, loc), value, boolLit(true, loc), "==", loc));
+    const result = {
+        kind: "libCall",
+        fn: "assert.ok",
+        args: [pass, msg, boolLit(generated, loc)],
+        type: VOID,
+        loc,
+    };
+    return { kind: "seqExpr", stmts, result, type: VOID, loc };
 }
 /** assert.fail([message]): an unconditional AssertionError — "Failed"
  * when the message is omitted (Node's internal default). Lowers as
@@ -231,15 +756,36 @@ function lowerAssertFail(lowerer, expr, loc) {
         lowerer.noLowering(`assert.fail with ${expr.arguments.length} arguments`, expr, "the supported form is fail(message?) — the deprecated fail(actual, expected, ...) has no lowering");
     }
     let msg;
+    let generated;
     const msgNode = expr.arguments[0];
+    const stmts = [];
     if (!msgNode || (ts.isIdentifier(msgNode) && msgNode.text === "undefined")) {
         msg = { kind: "strLit", value: "Failed", type: STRING, loc };
+        generated = boolLit(true, loc);
     }
     else {
-        msg = lowerMessageArg(lowerer, msgNode, loc).msg;
+        // Node's AssertionError sets generatedMessage to !message, so an
+        // empty custom message counts as generated.
+        msg = stableValue(lowerer, stmts, lowerMessageArg(lowerer, msgNode, loc).msg, "%assertFailMessage", loc);
+        generated = {
+            kind: "strEq",
+            negated: false,
+            left: msg,
+            right: strLit("", loc),
+            type: BOOL,
+            loc,
+        };
     }
     const falseLit = { kind: "boolLit", value: false, type: BOOL, loc };
-    return { kind: "libCall", fn: "assert.ok", args: [falseLit, msg], type: VOID, loc };
+    stmts.push(recordOnFailure(lowerer, boolLit(true, loc), null, null, "fail", loc));
+    const result = {
+        kind: "libCall",
+        fn: "assert.ok",
+        args: [falseLit, msg, generated],
+        type: VOID,
+        loc,
+    };
+    return { kind: "seqExpr", stmts, result, type: VOID, loc };
 }
 /** The equality quartet. Scalars (number/string/boolean) compare with
  * Object.is in the runtime (strictEqual and deepStrictEqual agree there —
@@ -253,34 +799,39 @@ function lowerAssertEqual(lowerer, expr, loc, negated, deep) {
     if (expr.arguments.length < 2 || expr.arguments.length > 3) {
         lowerer.noLowering(`${surface} with ${expr.arguments.length} arguments`, expr);
     }
-    // A context-free EMPTY array literal on either side has no element type
-    // of its own (`deepStrictEqual(ee.listeners('x'), [])` — the checker
-    // says any[]): it adopts the OTHER side's array type. Literals have no
-    // side effects, so lowering order is unobservable.
     const aNode = expr.arguments[0];
     const bNode = expr.arguments[1];
-    const emptyArrayLit = (n) => ts.isArrayLiteralExpression(n) && n.elements.length === 0;
-    const emptyOf = (t) => ({ kind: "arrayLit", elems: [], type: t, loc });
-    // A dyn other side adopts number[] — the dyn array a boxed empty
-    // literal builds is elementless, so any elem type serves.
-    const adoptedEmpty = (other) => other.kind === "array"
-        ? emptyOf(other)
-        : other.kind === "dyn"
-            ? emptyOf({ kind: "array", elem: F64 })
-            : null;
-    let a;
-    let b;
-    if (emptyArrayLit(aNode) && !emptyArrayLit(bNode)) {
-        b = lowerer.lowerExpr(bNode);
-        a = adoptedEmpty(b.type) ?? lowerer.lowerExpr(aNode);
-    }
-    else {
-        a = lowerer.lowerExpr(aNode);
-        b = emptyArrayLit(bNode)
-            ? (adoptedEmpty(a.type) ?? lowerer.lowerExpr(bNode))
-            : lowerer.lowerExpr(bNode);
-    }
+    const { a, b } = lowerComparedOperands(lowerer, aNode, bNode, loc);
     const { msg, hasMsg } = lowerMessageArg(lowerer, expr.arguments[2], loc);
+    // An Assert instance with skipPrototype: Node compares own properties
+    // without the prototype check, so operands of different static types (two
+    // classes, a class and a record) can be equal. They compare as
+    // checked-dynamic values, and so do class instances, which have no typed
+    // deep comparison; the runtime walk skips the prototype check for the
+    // call (assert-instances.ts). Other same-typed operands keep their typed
+    // comparison.
+    const skipPrototype = deep && lowerer.assertCallOptions?.skipPrototype === true;
+    if (skipPrototype &&
+        a.type.kind !== "dyn" &&
+        b.type.kind !== "dyn" &&
+        (!typeEquals(a.type, b.type) || deepUnsupportedReason(lowerer, a.type, new Set()) !== null)) {
+        const box = (e, node) => {
+            if (e.kind !== "unitLit" &&
+                (!lowerer.dynConvertible(e.type) ||
+                    typeReachesCycle(lowerer, e.type) ||
+                    typeReachesFunction(lowerer, e.type))) {
+                lowerer.noLowering(`${surface} with skipPrototype of '${lowerer.fmt(a.type)}' and '${lowerer.fmt(b.type)}' values`, node, "operands of different static types compare as checked-dynamic values, which this operand does not convert to");
+            }
+            return { kind: "dynFrom", value: e, type: DYN, loc: e.loc };
+        };
+        return {
+            kind: "libCall",
+            fn: "assert.eqDyn",
+            args: [box(a, aNode), box(b, bNode), boolLit(negated, loc), boolLit(true, loc), msg, hasMsg],
+            type: VOID,
+            loc,
+        };
+    }
     // CHECKED-DYNAMIC operands (dyn-vs-dyn, dyn-vs-static): both sides
     // cross into the checked-dynamic tree and one runtime entry answers the whole quartet —
     // SameValue for the strict pair (boxed-closure identity for
@@ -321,7 +872,10 @@ function lowerAssertEqual(lowerer, expr, loc, negated, deep) {
                 // same). The deep walk compares the retained error data without
                 // re-encoding and losing identity (SEMANTICS.md).
                 (k === "object" && e.type.kind === "object" && e.type.className === "%Error") ||
-                (deep && k !== "bytes" && k !== "object" && lowerer.dynConvertible(e.type));
+                (deep && k !== "bytes" && k !== "object" && lowerer.dynConvertible(e.type)) ||
+                // Under skipPrototype the prototype a class instance or Buffer
+                // brand would carry is not compared.
+                (skipPrototype && lowerer.dynConvertible(e.type));
             if (!ok) {
                 const hint = !deep && (k === "record" || k === "array" || k === "map" || k === "set" || k === "union")
                     ? "strictEqual on objects is reference equality, which does not survive the unknown boundary (values copy when they cross) — deepStrictEqual compares structure, or narrow the unknown side first"
@@ -401,23 +955,18 @@ function lowerAssertEqual(lowerer, expr, loc, negated, deep) {
                 loc,
             };
         }
-        if (brandA === null || brandB === null) {
+        if (!skipPrototype && (brandA === null || brandB === null)) {
             lowerer.noLowering(`${surface} of typed-array values whose constructor is not in the static type`, brandA === null ? expr.arguments[0] : expr.arguments[1], "Node's deep equality compares prototypes (a Buffer is never deep-equal to a plain Uint8Array) — annotate the value so its constructor is visible");
         }
-        const verdict = {
+        // The brand is the prototype; skipPrototype ignores it.
+        const sameBrand = skipPrototype || brandA === brandB;
+        return deepCheckCall(lowerer, a, b, `bytes:${sameBrand}`, (x, y) => ({
             kind: "libCall",
             fn: "assert.bytesDeepEq",
-            args: [a, b, boolLit(brandA === brandB, loc)],
+            args: [x, y, boolLit(sameBrand, loc)],
             type: BOOL,
             loc,
-        };
-        return {
-            kind: "libCall",
-            fn: "assert.deepResult",
-            args: [verdict, boolLit(negated, loc), msg, hasMsg],
-            type: VOID,
-            loc,
-        };
+        }), negated, msg, hasMsg, loc);
     }
     // Function values (ANY two static signatures — a tuple-typed
     // listeners() element against a prefix-declared handler): strictEqual
@@ -461,11 +1010,62 @@ function lowerAssertEqual(lowerer, expr, loc, negated, deep) {
         lowerer.noLowering(`${surface} of '${lowerer.fmt(a.type)}' values`, expr, unsupported);
     }
     const helper = deepEqHelper(lowerer, a.type, loc);
-    const verdict = { kind: "call", callee: helper, args: [a, b], type: BOOL, loc };
+    return deepCheckCall(lowerer, a, b, "deep", (x, y) => ({ kind: "call", callee: helper, args: [x, y], type: BOOL, loc }), negated, msg, hasMsg, loc);
+}
+/** `assert.deepResult(%assert.dcheck.<n>(a, b), negated, msg, hasMsg)`.
+ * The wrapper returns the verdict and, on failure, records actual and
+ * expected. The operands are its parameters, so the call site passes them
+ * as temporaries and a passing assertion holds no extra reference. */
+function deepCheckCall(lowerer, a, b, variant, verdictOf, negated, msg, hasMsg, loc, mode = "strict") {
+    const key = `assert.dcheck:${variant}:${negated}:${typeKey(a.type)}:${typeKey(b.type)}`;
+    let name = lowerer.assertHelpers.get(key);
+    if (!name) {
+        name = `%assert.dcheck.${lowerer.assertHelpers.size}`;
+        lowerer.assertHelpers.set(key, name);
+        const pa = varRef("a.0", a.type, loc);
+        const pb = varRef("b.0", b.type, loc);
+        const verdict = varRef("v.0", BOOL, loc);
+        lowerer.liftedFns.push({
+            name,
+            params: [
+                { localId: "a.0", name: "a", type: a.type },
+                { localId: "b.0", name: "b", type: b.type },
+            ],
+            returnType: BOOL,
+            locals: [
+                { id: "a.0", name: "a", type: a.type, mutable: false },
+                { id: "b.0", name: "b", type: b.type, mutable: false },
+                { id: "v.0", name: "verdict", type: BOOL, mutable: false },
+            ],
+            body: [
+                { kind: "varDecl", localId: "v.0", init: verdictOf(pa, pb), loc },
+                recordOnFailure(lowerer, negated ? verdict : notExpr(verdict, loc), pa, pb, mode === "partial"
+                    ? "partialDeepStrictEqual"
+                    : mode === "loose"
+                        ? negated
+                            ? "notDeepEqual"
+                            : "deepEqual"
+                        : negated
+                            ? "notDeepStrictEqual"
+                            : "deepStrictEqual", loc),
+                { kind: "return", value: verdict, loc },
+            ],
+            loc,
+        });
+    }
     return {
         kind: "libCall",
-        fn: "assert.deepResult",
-        args: [verdict, boolLit(negated, loc), msg, hasMsg],
+        fn: mode === "partial"
+            ? "assert.partialDeepResult"
+            : mode === "loose"
+                ? "assert.looseDeepResult"
+                : "assert.deepResult",
+        args: [
+            { kind: "call", callee: name, args: [a, b], type: BOOL, loc },
+            boolLit(negated, loc),
+            msg,
+            hasMsg,
+        ],
         type: VOID,
         loc,
     };
@@ -893,7 +1493,20 @@ function assertThrowsHelper(lowerer, mode, recvType, recvIsPromise, expected, lo
     let catchBody;
     if (mode === "dnr" || mode === "dnt") {
         const actual = () => ({ kind: "caughtToDyn", value: caughtRef(), type: DYN, loc });
-        const unwanted = () => lib("assert.unwantedError", [
+        // Node's actual is the caught value.
+        const unwanted = () => ({
+            kind: "block",
+            body: [
+                lib("assert.record", [
+                    actual(),
+                    dynUndefinedExpr(loc),
+                    strLit(mode === "dnr" ? "doesNotReject" : "doesNotThrow", loc),
+                ]),
+                unwantedCall(),
+            ],
+            loc,
+        });
+        const unwantedCall = () => lib("assert.unwantedError", [
             {
                 kind: "libCall",
                 fn: "util.toUSVString",
@@ -1002,6 +1615,7 @@ function assertThrowsHelper(lowerer, mode, recvType, recvIsPromise, expected, lo
                             narrowed(),
                             m(),
                             hm(),
+                            boolLit(mode === "rejects", loc),
                         ]),
                     ]),
                     // A non-Error thrown value: propagate (SEMANTICS.md 104; the
@@ -1013,7 +1627,13 @@ function assertThrowsHelper(lowerer, mode, recvType, recvIsPromise, expected, lo
             case "regex":
                 catchBody = [
                     ifStmt(isInstance("%Error"), [
-                        lib("assert.throwsRegex", [varRef("re.0", REGEX, loc), narrowed(), m(), hm()]),
+                        lib("assert.throwsRegex", [
+                            varRef("re.0", REGEX, loc),
+                            narrowed(),
+                            m(),
+                            hm(),
+                            boolLit(mode === "rejects", loc),
+                        ]),
                         doReturn,
                     ]),
                     rethrow,
@@ -1023,7 +1643,7 @@ function assertThrowsHelper(lowerer, mode, recvType, recvIsPromise, expected, lo
                 catchBody = [
                     ifStmt(isInstance("%Error"), [
                         ...shapeSlotStmts(),
-                        lib("assert.shapeEnd", [m(), hm()]),
+                        lib("assert.shapeEnd", [m(), hm(), boolLit(mode === "rejects", loc)]),
                         doReturn,
                     ]),
                     rethrow,
@@ -1150,6 +1770,7 @@ function lowerAssertIfError(lowerer, expr, loc) {
             args: [
                 { kind: "boolLit", value: true, type: BOOL, loc },
                 { kind: "strLit", value: "", type: STRING, loc },
+                { kind: "boolLit", value: true, type: BOOL, loc },
             ],
             type: VOID,
             loc,
@@ -1168,6 +1789,7 @@ function lowerAssertIfError(lowerer, expr, loc) {
             args: [
                 { kind: "boolLit", value: true, type: BOOL, loc },
                 { kind: "strLit", value: "", type: STRING, loc },
+                { kind: "boolLit", value: true, type: BOOL, loc },
             ],
             type: VOID,
             loc,
@@ -1289,8 +1911,8 @@ function bytesBrandOf(lowerer, node) {
 }
 /* ── deep equality (deepStrictEqual / notDeepStrictEqual) ──────────────── */
 /** Why `t` has no honest deep comparison, or null when it lowers. The
- * fence names the FIRST unsupported constituent — never a silent
- * miscompare. Recursive record shapes terminate through `visiting`
+ * fence names the FIRST unsupported constituent instead of emitting a
+ * wrong comparison. Recursive record shapes terminate through `visiting`
  * (a shape being checked is assumed fine; its own walk decides). */
 function deepUnsupportedReason(lowerer, t, visiting) {
     switch (t.kind) {
@@ -1367,12 +1989,15 @@ function deepUnsupportedReason(lowerer, t, visiting) {
  * tag+payload unions, SameValueZero-keyed Maps with deep values, scalar
  * Sets by membership. Registered in the cache BEFORE the body builds, so
  * recursive record shapes call themselves by name. */
-function deepEqHelper(lowerer, t, loc) {
-    const key = `assert.deq:${typeKey(t)}`;
+function deepEqHelper(lowerer, t, loc, loose = false) {
+    // The loose mode (deepEqual over one union-free type) differs only in
+    // numbers: == with NaN equal to NaN.
+    const prefix = loose ? "ldeq" : "deq";
+    const key = `assert.${prefix}:${typeKey(t)}`;
     const existing = lowerer.assertHelpers.get(key);
     if (existing)
         return existing;
-    const name = `%assert.deq.${lowerer.assertHelpers.size}`;
+    const name = `%assert.${prefix}.${lowerer.assertHelpers.size}`;
     lowerer.assertHelpers.set(key, name);
     const a = () => varRef("a.0", t, loc);
     const b = () => varRef("b.0", t, loc);
@@ -1398,7 +2023,13 @@ function deepEqHelper(lowerer, t, loc) {
     /** Deep-compare two same-typed exprs through the per-type helper. */
     const deq = (elemT, x, y) => isUnitType(elemT)
         ? boolLit(true, loc)
-        : { kind: "call", callee: deepEqHelper(lowerer, elemT, loc), args: [x, y], type: BOOL, loc };
+        : {
+            kind: "call",
+            callee: deepEqHelper(lowerer, elemT, loc, loose),
+            args: [x, y],
+            type: BOOL,
+            loc,
+        };
     let locals = [
         { id: "a.0", name: "a", type: t, mutable: false },
         { id: "b.0", name: "b", type: t, mutable: false },
@@ -1406,7 +2037,15 @@ function deepEqHelper(lowerer, t, loc) {
     let body;
     switch (t.kind) {
         case "f64":
-            body = [ret({ kind: "libCall", fn: "assert.sameValue", args: [a(), b()], type: BOOL, loc })];
+            body = [
+                ret({
+                    kind: "libCall",
+                    fn: loose ? "assert.looseF64Eq" : "assert.sameValue",
+                    args: [a(), b()],
+                    type: BOOL,
+                    loc,
+                }),
+            ];
             break;
         case "bigint":
             body = [ret({ kind: "libCall", fn: "bigint.eq", args: [a(), b()], type: BOOL, loc })];