@scriptc/compiler 0.3.6 → 0.4.1

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

@@ -1,9 +1,10 @@
-import { dynUndefinedExpr, boolLit, helperLoc, numLit, strLit, varRef } from "../../ir/build.js";
+import { dynUndefinedExpr, boolLit, helperLoc, nodeThrowExpr, numLit, strLit, varRef, } from "../../ir/build.js";
+import { builtinClassDynValueOf, builtinClassKindOf } from "./builtins/builtin-class-dyn.js";
 import { InternalCompilerError } from "../../errors.js";
 import * as ts from "../ts7/adapter.js";
 import { unsignedHex } from "../../format-integer.js";
 import { isJsSourceFile } from "../program.js";
-import { BOOL, DYN, F64, RUNTIME_ERROR_CLASSES, STRING, isUnitType, UNDEFINED_T, VOID, canConvertToDyn, canDynCheckTo, isDirentShape, isDynTypedRefType, recordTextCodecClass, shapeHasAccessorSlots, typeKey, } from "../../ir/ir.js";
+import { BOOL, DYN, F64, RUNTIME_ERROR_CLASSES, STRING, isUnitType, UNDEFINED_T, VOID, canConvertToDyn, canDynCheckTo, CLASS_FIELD_ATTRIBUTES_PREFIX, classDynViewSupported, DYN_CLASS_PROPERTIES, isClassOwnEnumerableFieldName, isDirentShape, isDynTypedRefType, recordTextCodecClass, shapeHasAccessorSlots, typeKey, } from "../../ir/ir.js";
 import { isSafeToDiscard, isSafeToRepeat } from "./expressions/evaluation-safety.js";
 import { symbolFieldDisplayName } from "./symbol-fields.js";
 import { eventTargetRootOf } from "./lower-event-target.js";
@@ -84,13 +85,540 @@ function inspectKey(name) {
 function errorRenderable(info) {
     // The builtin classes' name/message/code live in runtime slots (the
     // ScrError prefix insp.error reads), not IR fields; only USER-declared
-    // fields are own properties the runtime rendering would miss. #private
-    // fields are NOT own properties — Node never prints them — so they
-    // don't disqualify.
-    if (!info.builtinError && info.def.fields.some((f) => !f.name.startsWith("#")))
-        return false;
+    // fields are own properties the runtime rendering would miss. A user
+    // class's layout repeats its builtin base's prefix fields, which are
+    // those same slots. #private fields are NOT own properties — Node never
+    // prints them — so they don't disqualify.
+    if (!info.builtinError) {
+        const inherited = new Set();
+        for (let c = info.base; c; c = c.base) {
+            if (c.builtinError || c.def.runtime)
+                for (const f of c.def.fields)
+                    inherited.add(f.name);
+        }
+        if (info.def.fields.some((f) => !f.name.startsWith("#") && !inherited.has(f.name)))
+            return false;
+    }
     return info.subclasses.every((s) => errorRenderable(s));
 }
+/** The accessors that change what Node reads for an error's header. The
+ * runtime renders the instance's own name and message slots. */
+const ERROR_HEADER_ACCESSORS = [
+    "get:name",
+    "set:name",
+    "get:message",
+    "set:message",
+    "get:stack",
+    "set:stack",
+];
+/** Whether Node's header for an instance of `info`'s hierarchy can differ
+ * from the runtime's slots: a program class among its ancestors or
+ * descendants declares a `name`, `message` or `stack` accessor, or the
+ * program writes a prototype's `name` or `message`. */
+function errorHeaderOverridden(lowerer, info) {
+    if (lowerer.prototypeMethodAccesses.has("name") || lowerer.prototypeMethodAccesses.has("message"))
+        return true;
+    const declares = (c) => !c.builtinError && !c.def.runtime && ERROR_HEADER_ACCESSORS.some((m) => c.methods.has(m));
+    for (let c = info.base; c; c = c.base)
+        if (declares(c))
+            return true;
+    const below = (c) => declares(c) || c.subclasses.some(below);
+    return below(info);
+}
+/** Error keys Node's error inspector folds into the base or hides. */
+const ERROR_SPECIAL_KEYS = new Set(["name", "message", "stack", "cause", "errors"]);
+/** The declared own (enumerable) fields of a user error class, in layout
+ * order (the base chain first). */
+function ownErrorFields(info) {
+    // The builtin bases' layout fields (name, message) are runtime slots the
+    // error base already renders, not own enumerable properties.
+    const builtin = new Set();
+    for (let c = info.base; c; c = c.base) {
+        if (c.builtinError || c.def.runtime)
+            for (const f of c.def.fields)
+                builtin.add(f.name);
+    }
+    return info.def.fields.filter((f) => isClassOwnEnumerableFieldName(f.name) && !builtin.has(f.name));
+}
+/** `info` and its descendants that declare fields, most-derived first (a
+ * runtime instance tests against its own class before an ancestor's). */
+function fieldedErrorClasses(info) {
+    const out = [];
+    const visit = (c) => {
+        for (const s of c.subclasses)
+            visit(s);
+        if (!c.builtinError && !c.def.runtime && ownErrorFields(c).length > 0)
+            out.push(c);
+    };
+    visit(info);
+    return out;
+}
+/** Why a fielded error class's own properties have no static rendering,
+ * or null when every field renders. `visiting` and `out` are the caller's
+ * inspectSupport walk: a field typed as the class itself (`next?: Chain`)
+ * is a recursive shape, not a new walk. */
+function fieldedErrorReason(lowerer, info, visiting = new Set(), out = { recursive: false }) {
+    const key = `error:${info.def.name}`;
+    if (visiting.has(key)) {
+        out.recursive = true;
+        return null;
+    }
+    visiting.add(key);
+    try {
+        for (let c = info; c && !c.builtinError && !c.def.runtime; c = c.base) {
+            // Node prints the own properties in creation order, which puts a
+            // declared `cause` among the fields; the cause renders after them.
+            if (c.fieldOrder.some((f) => f.errorCause))
+                return "its field 'cause' is one Node's error inspector treats specially";
+            // A JavaScript class's fields exist once its constructor creates them,
+            // which can be conditional; the layout reads every field.
+            if (c.decl && isJsSourceFile(c.decl.getSourceFile()) && ownErrorFields(c).length > 0)
+                return "its fields are JavaScript properties, which its constructor may not create";
+        }
+        for (const f of ownErrorFields(info)) {
+            if (ERROR_SPECIAL_KEYS.has(f.name))
+                return `its field '${f.name}' is one Node's error inspector treats specially`;
+            const why = inspectSupport(lowerer, f.type, visiting, out);
+            if (why !== null)
+                return `its field '${f.name}': ${why}`;
+        }
+        return null;
+    }
+    finally {
+        visiting.delete(key);
+    }
+}
+/** True when an instance of `c` can contain itself: its fields reach `c`
+ * or one of its bases, whose slots can hold a `c` (`next: Chain` in a
+ * subclass of Chain, a field typed as Error). */
+function errorInstanceReachesItself(lowerer, c) {
+    const holders = new Set();
+    for (let a = c; a; a = a.base)
+        holders.add(a.def.name);
+    const seen = new Set();
+    const walk = (u) => {
+        for (const x of typeConstituents(lowerer, u)) {
+            if (x.kind === "object" && holders.has(x.className))
+                return true;
+            const k = typeKey(x);
+            if (!seen.has(k)) {
+                seen.add(k);
+                if (walk(x))
+                    return true;
+            }
+        }
+        return false;
+    };
+    return walk({ kind: "object", className: c.def.name });
+}
+/** An error value whose runtime class may be a program-declared subclass,
+ * which may declare fields (`class Bailable extends Error { bail = false }`)
+ * or carry a `cause`: Node prints the error base (`[Bailable [Error]: m]`,
+ * the stackless form compiled errors use) followed by the own properties,
+ * `[Bailable [Error]: m] { bail: true }`, with the usual single-line/
+ * multi-line choice counting the base. Each program class (most-derived
+ * first) is an instanceof arm; other values keep the runtime's error
+ * rendering. Beyond the depth budget an instance with own properties
+ * prints `[Name]`, as Node does for any object with keys; one without
+ * prints its header. */
+function errorInspectHelper(lowerer, t, info, loc) {
+    const key = `insp.userError:${typeKey(t)}`;
+    const existing = lowerer.inspectHelpers.get(key);
+    if (existing)
+        return existing;
+    const name = `%util.insp.${lowerer.inspectHelpers.size}`;
+    lowerer.inspectHelpers.set(key, name);
+    const v = () => varRef("v.0", t, loc);
+    const r = () => varRef("r.0", F64, loc);
+    const d = () => varRef("d.0", F64, loc);
+    const rPlus1 = () => ({
+        kind: "bin",
+        op: "+",
+        left: r(),
+        right: numLit(1, loc),
+        type: F64,
+        loc,
+    });
+    const base = () => ({
+        kind: "libCall",
+        fn: "insp.error",
+        args: [v(), r(), d()],
+        type: STRING,
+        loc,
+    });
+    const error = () => lowerer.upcastTo(v(), "%Error");
+    const hasCause = () => ({
+        kind: "libCall",
+        fn: "insp.errorHasCause",
+        args: [error()],
+        type: BOOL,
+        loc,
+    });
+    const entry = (text) => ({
+        kind: "exprStmt",
+        expr: {
+            kind: "libCall",
+            fn: "insp.entry",
+            args: [text, boolLit(false, loc)],
+            type: VOID,
+            loc,
+        },
+        loc,
+    });
+    /** The own properties of an instance of `c`: its fields, then its
+     * `cause` (an assignment in the constructor or later, or the
+     * constructor's options, which Node lists last as `[cause]`). */
+    const propertiesArm = (c, display, fields) => {
+        const cls = { kind: "object", className: c.def.name };
+        const instance = c.def.name === t.className ? v() : { kind: "downcast", value: v(), type: cls, loc };
+        // A class whose fields can hold the instance itself (`next: Chain`)
+        // runs Node's circular machinery, as other cycle-capable objects do:
+        // an instance already on the traversal stack renders [Circular *N],
+        // before the depth answer, and the frame's text gets the <ref *N>
+        // prefix when the walk found it circular.
+        const onCycle = errorInstanceReachesItself(lowerer, c);
+        const circular = () => varRef("cc.0", F64, loc);
+        const arm = [
+            ...(onCycle
+                ? [
+                    {
+                        kind: "varDecl",
+                        localId: "cc.0",
+                        init: { kind: "libCall", fn: "insp.circCheck", args: [v()], type: F64, loc },
+                        loc,
+                    },
+                    {
+                        kind: "if",
+                        cond: {
+                            kind: "bin",
+                            op: ">",
+                            left: circular(),
+                            right: numLit(0, loc),
+                            type: BOOL,
+                            loc,
+                        },
+                        then: [
+                            {
+                                kind: "return",
+                                value: {
+                                    kind: "libCall",
+                                    fn: "insp.circular",
+                                    args: [circular()],
+                                    type: STRING,
+                                    loc,
+                                },
+                                loc,
+                            },
+                        ],
+                        else_: null,
+                        loc,
+                    },
+                ]
+                : []),
+            {
+                kind: "if",
+                cond: { kind: "bin", op: ">", left: r(), right: d(), type: BOOL, loc },
+                then: [{ kind: "return", value: strLit(`[${display}]`, loc), loc }],
+                else_: null,
+                loc,
+            },
+            {
+                kind: "varDecl",
+                localId: "base.0",
+                init: improvedErrorBase(lowerer, v(), base(), display, loc),
+                loc,
+            },
+            {
+                kind: "exprStmt",
+                expr: { kind: "libCall", fn: "insp.begin", args: [rPlus1()], type: VOID, loc },
+                loc,
+            },
+            ...(onCycle
+                ? [
+                    {
+                        kind: "exprStmt",
+                        expr: { kind: "libCall", fn: "insp.seenPush", args: [v()], type: VOID, loc },
+                        loc,
+                    },
+                ]
+                : []),
+        ];
+        for (const f of fields) {
+            const read = {
+                kind: "fieldGet",
+                obj: instance,
+                className: c.def.name,
+                field: f.name,
+                type: f.type,
+                loc,
+            };
+            arm.push(entry(concatAll([
+                strLit(`${inspectKey(f.name)}: `, loc),
+                inspectExpr(lowerer, f.type, read, rPlus1(), d(), loc),
+            ], loc)));
+        }
+        arm.push({
+            kind: "if",
+            cond: hasCause(),
+            then: [
+                entry({
+                    kind: "libCall",
+                    fn: "insp.errorCause",
+                    args: [error(), rPlus1(), d()],
+                    type: STRING,
+                    loc,
+                }),
+            ],
+            else_: null,
+            loc,
+        });
+        const ended = {
+            kind: "libCall",
+            fn: "insp.end",
+            args: [
+                varRef("base.0", STRING, loc),
+                strLit("{", loc),
+                strLit("}", loc),
+                rPlus1(),
+                boolLit(false, loc),
+                boolLit(false, loc),
+            ],
+            type: STRING,
+            loc,
+        };
+        arm.push({
+            kind: "return",
+            value: onCycle
+                ? { kind: "libCall", fn: "insp.refWrap", args: [v(), ended], type: STRING, loc }
+                : ended,
+            loc,
+        });
+        return arm;
+    };
+    const body = [];
+    for (const c of userErrorClasses(info)) {
+        const display = c.def.jsName ?? c.decl?.name?.text ?? c.def.name.replace(/^%/, "");
+        const fields = ownErrorFields(c);
+        const why = fields.length > 0 ? fieldedErrorReason(lowerer, c) : null;
+        let arm;
+        if (why !== null) {
+            // An instance of a subclass whose own properties have no rendering
+            // throws a named refusal instead of printing a partial object.
+            arm = [
+                {
+                    kind: "return",
+                    value: nodeThrowExpr(0, "SC2020", `inspecting a '${display}' error (${why}) is not supported yet`, STRING, loc),
+                    loc,
+                },
+            ];
+        }
+        else if (fields.length === 0) {
+            // A field-less program class: without a `cause` it has no own
+            // properties, and Node prints the header alone at any depth.
+            arm = [
+                {
+                    kind: "if",
+                    cond: { kind: "unary", op: "!", operand: hasCause(), type: BOOL, loc },
+                    then: [
+                        { kind: "return", value: improvedErrorBase(lowerer, v(), base(), display, loc), loc },
+                    ],
+                    else_: null,
+                    loc,
+                },
+                ...propertiesArm(c, display, fields),
+            ];
+        }
+        else {
+            arm = propertiesArm(c, display, fields);
+        }
+        if (c.def.name === t.className) {
+            body.push({ kind: "block", body: arm, loc });
+            break;
+        }
+        body.push({
+            kind: "if",
+            cond: { kind: "instanceOf", value: v(), className: c.def.name, type: BOOL, loc },
+            then: arm,
+            else_: null,
+            loc,
+        });
+    }
+    if (body.at(-1)?.kind !== "block")
+        body.push({ kind: "return", value: base(), loc });
+    const fn = {
+        name,
+        params: [
+            { localId: "v.0", name: "v", type: t },
+            { localId: "r.0", name: "r", type: F64 },
+            { localId: "d.0", name: "d", type: F64 },
+        ],
+        returnType: STRING,
+        locals: [
+            { id: "v.0", name: "v", type: t, mutable: false },
+            { id: "r.0", name: "r", type: F64, mutable: false },
+            { id: "d.0", name: "d", type: F64, mutable: false },
+            { id: "base.0", name: "base", type: STRING, mutable: false },
+            { id: "cc.0", name: "cc", type: F64, mutable: false },
+            { id: "name.0", name: "name", type: STRING, mutable: true },
+            { id: "raw.0", name: "raw", type: STRING, mutable: true },
+        ],
+        body,
+        loc,
+    };
+    // Dynamic stores (a JavaScript class's `this.x = ...` outside its
+    // declared fields, or a write through an untyped reference) add a
+    // property bag to a class after this helper was built. The rendering
+    // reads only a `cause` from it, so an instance whose bag holds another
+    // property throws a named refusal instead of printing a partial object.
+    lowerer.shapeOrderHelperFinalizers.push(() => {
+        const bagged = [info, ...userErrorClasses(info)].filter((c) => !c.builtinError &&
+            !c.def.runtime &&
+            c.def.fields.some((f) => f.name === DYN_CLASS_PROPERTIES));
+        if (bagged.length === 0)
+            return;
+        fn.body = [
+            ...bagged.map((c) => ({
+                kind: "if",
+                cond: {
+                    kind: "logical",
+                    op: "&&",
+                    left: { kind: "instanceOf", value: v(), className: c.def.name, type: BOOL, loc },
+                    right: {
+                        kind: "libCall",
+                        fn: "insp.errorBagHasProperties",
+                        args: [
+                            {
+                                kind: "fieldGet",
+                                obj: c.def.name === t.className
+                                    ? v()
+                                    : {
+                                        kind: "downcast",
+                                        value: v(),
+                                        type: { kind: "object", className: c.def.name },
+                                        loc,
+                                    },
+                                className: c.def.name,
+                                field: DYN_CLASS_PROPERTIES,
+                                type: DYN,
+                                loc,
+                            },
+                        ],
+                        type: BOOL,
+                        loc,
+                    },
+                    type: BOOL,
+                    loc,
+                },
+                then: [
+                    {
+                        kind: "return",
+                        value: nodeThrowExpr(0, "SC2020", `inspecting a '${c.def.jsName ?? c.def.name.replace(/^%/, "")}' error with properties created at run time is not supported yet`, STRING, loc),
+                        loc,
+                    },
+                ],
+                else_: null,
+                loc,
+            })),
+            ...body,
+        ];
+    });
+    lowerer.liftedFns.push(fn);
+    return name;
+}
+/** The program-declared classes among `info` and its descendants, most
+ * derived first (an instance tests against its own class before an
+ * ancestor's). Runtime-provided error classes are not among them. */
+function userErrorClasses(info) {
+    const out = [];
+    const visit = (c) => {
+        for (const s of c.subclasses)
+            visit(s);
+        if (!c.builtinError && !c.def.runtime)
+            out.push(c);
+    };
+    visit(info);
+    return out;
+}
+/** Node's improveStack over the stackless base (`[Error: m]`): when the
+ * instance's constructor name differs from its `name` and the name ends in
+ * "Error", the header names both — `[Bailable [Error]: m]`, or
+ * `[FetchError: m]` when the constructor name already contains it. */
+function improvedErrorBase(lowerer, value, base, display, loc) {
+    const str = (method, receiver, args, type) => ({
+        kind: "strIntrinsic",
+        method,
+        receiver,
+        args,
+        type,
+        loc,
+    });
+    const and = (left, right) => ({
+        kind: "logical",
+        op: "&&",
+        left,
+        right,
+        type: BOOL,
+        loc,
+    });
+    const eq = (left, right, negated = false) => ({
+        kind: "strEq",
+        negated,
+        left,
+        right,
+        type: BOOL,
+        loc,
+    });
+    const nameRef = () => varRef("name.0", STRING, loc);
+    const baseRef = () => varRef("raw.0", STRING, loc);
+    const after = () => ({
+        kind: "bin",
+        op: "+",
+        left: str("length", nameRef(), [], F64),
+        right: numLit(1, loc),
+        type: F64,
+        loc,
+    });
+    const next = () => str("charAt", baseRef(), [after()], STRING);
+    const cond = and(and(eq(nameRef(), strLit(display, loc), true), str("endsWith", nameRef(), [strLit("Error", loc)], BOOL)), and(str("startsWith", baseRef(), [concatAll([strLit("[", loc), nameRef()], loc)], BOOL), {
+        kind: "logical",
+        op: "||",
+        left: eq(next(), strLit(":", loc)),
+        right: eq(next(), strLit("]", loc)),
+        type: BOOL,
+        loc,
+    }));
+    const rest = () => str("slice", baseRef(), [after()], STRING);
+    const improved = {
+        kind: "ternary",
+        cond: str("includes", strLit(display, loc), [nameRef()], BOOL),
+        then: concatAll([strLit(`[${display}`, loc), rest()], loc),
+        else_: concatAll([strLit(`[${display} [`, loc), nameRef(), strLit("]", loc), rest()], loc),
+        type: STRING,
+        loc,
+    };
+    return {
+        kind: "seqExpr",
+        stmts: [
+            {
+                kind: "varDecl",
+                localId: "name.0",
+                init: {
+                    kind: "fieldGet",
+                    obj: lowerer.upcastTo(value, "%Error"),
+                    className: "%Error",
+                    field: "name",
+                    type: STRING,
+                    loc,
+                },
+                loc,
+            },
+            { kind: "varDecl", localId: "raw.0", init: base, loc },
+        ],
+        result: { kind: "ternary", cond, then: improved, else_: baseRef(), type: STRING, loc },
+        type: STRING,
+        loc,
+    };
+}
 function isErrorClass(lowerer, className) {
     if (RUNTIME_ERROR_CLASSES.has(className))
         return true;
@@ -109,12 +637,17 @@ function inspectSupport(lowerer, t, visiting, out) {
         case "regex":
         case "symbol":
         case "bigint":
+        case "date":
         case "dyn":
             return null;
         case "array":
             return inspectSupport(lowerer, t.elem, visiting, out);
         case "bytes":
-            return "typed arrays inside composites have no inspect lowering yet (Buffer's <Buffer ..> form vs Uint8Array's is not recorded in the static type here)";
+            // A Uint8Array and a Buffer share the u8 representation and print
+            // differently; the other element kinds are never Buffers.
+            return t.elem === "u8"
+                ? "Uint8Array and Buffer values inside composites have no inspect lowering yet (Buffer's <Buffer ..> form vs Uint8Array's is not recorded in the static type here)"
+                : null;
         case "record": {
             if (visiting.has(t.shapeId)) {
                 out.recursive = true;
@@ -194,13 +727,24 @@ function inspectSupport(lowerer, t, visiting, out) {
             if (eventTargetRootOf(info) !== null)
                 return null;
             if (isErrorClass(lowerer, t.className)) {
-                return errorRenderable(info)
-                    ? null
-                    : "error subclasses with declared fields have no inspect lowering yet (the extra own properties are runtime-dynamic)";
+                if (userErrorClasses(info).length > 0 && errorHeaderOverridden(lowerer, info))
+                    return "error subclasses whose name, message or stack is an accessor or a prototype property have no inspect lowering yet";
+                if (errorRenderable(info))
+                    return null;
+                // Subclasses with declared fields render the error base followed
+                // by their own properties. The static class's own fields must
+                // render; a subclass whose fields cannot is a runtime refusal on
+                // its own instances only (see errorInspectHelper).
+                const own = fieldedErrorClasses(info).find((c) => c === info);
+                const ownWhy = own ? fieldedErrorReason(lowerer, own, visiting, out) : null;
+                if (ownWhy !== null)
+                    return `'${t.className.replace(/^%(m\d+\.)?/, "")}' error values (${ownWhy})`;
+                return null;
             }
-            // A class with subclasses renders through its checked-dynamic view,
-            // which names the instance's own class and holds its own fields.
-            if (info.subclasses.length > 0) {
+            // A class with subclasses, or a JavaScript class, renders through its
+            // checked-dynamic view, which names the instance's own class and holds
+            // its own properties.
+            if (classInspectsThroughView(lowerer, info)) {
                 if (!isDynTypedRefType(t) || visiting.has(t.className))
                     return null;
                 visiting.add(t.className);
@@ -236,6 +780,10 @@ function inspectSupport(lowerer, t, visiting, out) {
             visiting.delete(t.className);
             return null;
         }
+        // Generator objects print through their checked capsule: Node's
+        // `Object [Generator] {}`, or the tag of the iterator they implement.
+        case "generator":
+            return null;
         default:
             return `'${lowerer.fmt(t)}' values have no inspect lowering`;
     }
@@ -300,10 +848,31 @@ export function inspectExpr(lowerer, t, value, recurse, depth, loc) {
             return { kind: "libCall", fn: "sym.toString", args: [value], type: STRING, loc };
         case "bigint":
             return { kind: "libCall", fn: "bigint.inspect", args: [value], type: STRING, loc };
+        case "date":
+            // Node prints a Date's toISOString() at every depth, and its
+            // toString() ("Invalid Date") when the time value is NaN.
+            return { kind: "libCall", fn: "insp.date", args: [value], type: STRING, loc };
         case "bytes":
+            if (t.elem !== "u8") {
+                return {
+                    kind: "libCall",
+                    fn: "insp.typedArray",
+                    args: [value, recurse, depth],
+                    type: STRING,
+                    loc,
+                };
+            }
             return { kind: "libCall", fn: "insp.buffer", args: [value], type: STRING, loc };
         case "dyn":
             return { kind: "libCall", fn: "insp.dyn", args: [value, recurse, depth], type: STRING, loc };
+        case "generator":
+            return {
+                kind: "libCall",
+                fn: "insp.dyn",
+                args: [lowerer.coerceToExpected(value, DYN), recurse, depth],
+                type: STRING,
+                loc,
+            };
         case "object":
             if (eventTargetRootOf(lowerer.classes.get(t.className)) !== null) {
                 return {
@@ -315,6 +884,16 @@ export function inspectExpr(lowerer, t, value, recurse, depth, loc) {
                 };
             }
             if (isErrorClass(lowerer, t.className)) {
+                const info = lowerer.classes.get(t.className);
+                if (info && userErrorClasses(info).length > 0) {
+                    return {
+                        kind: "call",
+                        callee: errorInspectHelper(lowerer, t, info, loc),
+                        args: [value, recurse, depth],
+                        type: STRING,
+                        loc,
+                    };
+                }
                 return {
                     kind: "libCall",
                     fn: "insp.error",
@@ -323,7 +902,7 @@ export function inspectExpr(lowerer, t, value, recurse, depth, loc) {
                     loc,
                 };
             }
-            if (lowerer.classes.get(t.className)?.subclasses.length) {
+            if (classInspectsThroughView(lowerer, lowerer.classes.get(t.className))) {
                 return {
                     kind: "libCall",
                     fn: "insp.dyn",
@@ -420,12 +999,46 @@ function typeConstituents(lowerer, u) {
             return [u.key, u.value];
         case "union":
             return lowerer.unions.get(u.unionId)?.arms.slice() ?? [];
-        case "object":
-            return lowerer.classes.get(u.className)?.def.fields.map((f) => f.type) ?? [];
+        case "object": {
+            const info = lowerer.classes.get(u.className);
+            if (!info)
+                return [];
+            const types = info.def.fields.map((f) => f.type);
+            // An error value can be an instance of a program-declared subclass,
+            // whose own fields its inspection renders (errorInspectHelper).
+            if (isErrorClass(lowerer, u.className))
+                for (const c of userErrorClasses(info))
+                    for (const f of ownErrorFields(c))
+                        types.push(f.type);
+            return types;
+        }
         default:
             return [];
     }
 }
+/** Whether instances of a class render through its checked-dynamic view
+ * instead of a helper over the declared layout. The view names the
+ * instance's own class, which a base-typed value may not know statically,
+ * and lists own properties in creation order. A JavaScript class needs that
+ * order: its fields can be created conditionally, outside the constructor,
+ * or by writes to the instance after construction. */
+function classInspectsThroughView(lowerer, info) {
+    if (info === undefined)
+        return false;
+    if (info.subclasses.length > 0)
+        return true;
+    return (info.decl != null &&
+        isJsSourceFile(ts.getSourceFileOfNode(info.decl)) &&
+        classDynViewSupported(info.def.fields, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)));
+}
+/** Whether a class holds properties added outside its declared layout, or
+ * fields Object.defineProperty can make non-enumerable, which only its
+ * checked-dynamic view lists as Node does. Decided after lowering, when the
+ * class has its final fields. */
+function classInspectsAddedProperties(lowerer, info) {
+    return (info.def.fields.some((field) => field.name === DYN_CLASS_PROPERTIES || field.name.startsWith(CLASS_FIELD_ATTRIBUTES_PREFIX)) &&
+        classDynViewSupported(info.def.fields, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)));
+}
 /* ── the interned per-type helper ────────────────────────────────────── */
 /** `%util.insp.<n>(v, r, d): string` — formatValue over the static type:
  * empty composites answer their literals (before the depth check, Node's
@@ -456,8 +1069,8 @@ function inspectHelper(lowerer, t, loc) {
     // CYCLE-CAPABLE composites (typeReachesItself) run Node's circular
     // machinery: circCheck first (a value already on the traversal stack
     // renders [Circular *N] — before the empty/depth answers, Node's
-    // order), seen-push after begin, and refWrap around end's result (the
-    // <ref *N> prefix on values the walk found circular). Acyclic types
+    // order), seen-push after begin, and refWrap around end's result (end
+    // adds the <ref *N> prefix on values the walk found circular). Acyclic types
     // keep the zero-cost path.
     const onCycle = (t.kind === "record" || t.kind === "array" || t.kind === "map" || t.kind === "object") &&
         typeReachesItself(lowerer, t);
@@ -857,6 +1470,7 @@ function inspectHelper(lowerer, t, loc) {
             // Object.keys' declared order (SEMANTICS.md 36's stance). Retained
             // reachability can settle this shape after the helper is first
             // interned, so rebuild the field walk once metadata is final.
+            lowerer.keyOrder.observe(t);
             rebuildShapeOrderBody = () => {
                 const current = lowerer.shapes.get(t.shapeId) ?? shape;
                 const order = current.declaredOrder ?? current.fields.map((f) => f.name);
@@ -1071,7 +1685,7 @@ function inspectHelper(lowerer, t, loc) {
             // #private fields never render: they are not properties in any
             // observable way — Node's inspect omits them entirely (verified),
             // so a class whose only fields are private prints as `C {}`.
-            const visible = info.def.fields.filter((f) => !f.name.startsWith("#"));
+            const visible = info.def.fields.filter((f) => isClassOwnEnumerableFieldName(f.name));
             if (visible.length === 0) {
                 body = [ret(strLit(display === "" ? "{}" : `${display} {}`, loc))];
                 break;
@@ -1159,6 +1773,9 @@ function inspectHelper(lowerer, t, loc) {
         };
         prependCycleGuard();
     }
+    // Typed as the IR function itself: the finalizer below replaces the
+    // body of the very object liftedFns holds (natively, a differently typed
+    // literal would be copied into the list).
     const fn = {
         name,
         params: [
@@ -1171,6 +1788,25 @@ function inspectHelper(lowerer, t, loc) {
         body,
         loc,
     };
+    const inspected = t.kind === "object" ? lowerer.classes.get(t.className) : undefined;
+    if (inspected !== undefined) {
+        // Dynamic stores add a property bag to the class after this helper was
+        // built. The checked-dynamic view lists the bag's properties after the
+        // declared fields, so a class that has one renders through the view.
+        lowerer.shapeOrderHelperFinalizers.push(() => {
+            if (!classInspectsAddedProperties(lowerer, inspected))
+                return;
+            fn.body = [
+                ret({
+                    kind: "libCall",
+                    fn: "insp.dyn",
+                    args: [{ kind: "dynFrom", value: v(), liveRef: true, type: DYN, loc }, r(), d()],
+                    type: STRING,
+                    loc,
+                }),
+            ];
+        });
+    }
     if (rebuildShapeOrderBody !== null) {
         lowerer.shapeOrderHelperFinalizers.push(() => {
             rebuildShapeOrderBody();
@@ -1298,15 +1934,20 @@ export function lowerConsoleInspectArg(lowerer, node, value, surface, loc) {
     }
     if (t.kind === "bytes") {
         // One runtime representation serves Buffer AND Uint8Array; their
-        // renderings differ, so the argument's checker type picks — and only
-        // Buffer lowers (lowerInspectCall's stance).
+        // renderings differ, so the argument's checker type picks
+        // (lowerInspectCall's stance).
         const tname = lowerer.checker.typeToString(lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(node)));
-        const isBuffer = tname === "Buffer" ||
-            tname === "NonSharedBuffer" ||
-            tname.startsWith("Buffer<") ||
-            tname.startsWith("NonSharedBuffer<");
-        if (t.elem !== "u8" || !isBuffer) {
-            lowerer.unsupported("SC1090", node, `${surface} of '${tname}' values (Buffer's <Buffer ..> form is the lowered typed-array rendering; other typed arrays fence)`);
+        if (isDataViewTypeName(tname)) {
+            lowerer.unsupported("SC1090", node, `${surface} of '${tname}' values (Buffer and the numeric typed arrays are the lowered byte renderings; DataView has none yet)`);
+        }
+        if (!isBufferTypeName(tname)) {
+            return {
+                kind: "libCall",
+                fn: "insp.typedArray",
+                args: [value, numLit(0, loc), numLit(2, loc)],
+                type: STRING,
+                loc,
+            };
         }
         return inspectExpr(lowerer, t, value, numLit(0, loc), numLit(2, loc), loc);
     }
@@ -1315,6 +1956,10 @@ export function lowerConsoleInspectArg(lowerer, node, value, surface, loc) {
         // is not a value here, so the composition fences with the rewrite.
         lowerer.unsupported("SC1090", node, `${surface} of a void call result (call it as its own statement, then ${surface}(undefined))`);
     }
+    // A read that always throws (an ambient name, a binding whose
+    // initializer threw) never produces a value to render.
+    if (value.kind === "libCall" && value.fn === "global.undefRead")
+        return formatValueExpr(lowerer, DYN, { ...value, type: DYN }, 2, loc);
     const walk = { recursive: false };
     const reason = inspectSupport(lowerer, t, new Set(), walk);
     if (reason !== null) {
@@ -1322,18 +1967,25 @@ export function lowerConsoleInspectArg(lowerer, node, value, surface, loc) {
     }
     return formatValueExpr(lowerer, t, value, 2, loc);
 }
-/* ── the callsite: options, direct function/class names ──────────────── */
-/** The parsed options literal: the resolved depth (numeric; Infinity for
- * `null`), with every non-default knob fenced by name. */
+/** The checker's spelling of a Buffer, whose bytes print as <Buffer ..>. */
+function isBufferTypeName(tname) {
+    return (tname === "Buffer" ||
+        tname === "NonSharedBuffer" ||
+        tname.startsWith("Buffer<") ||
+        tname.startsWith("NonSharedBuffer<"));
+}
+function isDataViewTypeName(tname) {
+    return tname === "DataView" || tname.startsWith("DataView<");
+}
 function parseInspectOptions(lowerer, node, recursive, dir = false) {
     const surface = dir ? "console.dir" : "util.inspect";
+    const options = { depth: 2, breakLength: 80, compact: 3, sorted: false };
     if (!node || (ts.isIdentifier(node) && node.text === "undefined"))
-        return 2;
+        return options;
     if (!ts.isObjectLiteralExpression(node)) {
         lowerer.noLowering(`${surface} with a non-literal options argument`, node, "the options must be an object literal ({ depth, colors: false, ... }) so the knobs resolve at compile time");
     }
-    let depth = 2;
-    for (const prop of node.properties) {
+    for (const prop of node.properties.nodes) {
         if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) {
             lowerer.noLowering(`${surface} options in this form`, prop, "plain `key: literal` entries are the lowered options");
         }
@@ -1356,14 +2008,14 @@ function parseInspectOptions(lowerer, node, recursive, dir = false) {
                 // machinery ([Circular *N]) cuts every cycle, so the walk is
                 // bounded by the (finite) object graph — exactly Node.
                 void recursive;
-                depth = Infinity;
+                options.depth = Infinity;
             }
             else if (!(ts.isIdentifier(value) && value.text === "undefined")) {
                 const n = numeric();
                 if (n === null) {
                     lowerer.noLowering(`${surface} with a non-literal depth option`, value, "depth must be a numeric literal (or null)");
                 }
-                depth = n;
+                options.depth = n;
             }
         }
         else if (key === "colors") {
@@ -1372,14 +2024,27 @@ function parseInspectOptions(lowerer, node, recursive, dir = false) {
             }
         }
         else if (key === "compact") {
-            if (numeric() !== 3) {
-                lowerer.noLowering(`${surface} with a non-default compact option`, value, "only the default compact: 3 is lowered");
+            // Node tries the single-line form and groups arrays only for a
+            // compact of at least 1; false and smaller numbers break every
+            // composite onto its own lines. compact: true is the older layout.
+            const n = value.kind === ts.SyntaxKind.FalseKeyword ? 0 : numeric();
+            if (n === null || Number.isNaN(n)) {
+                lowerer.noLowering(`${surface} with this compact option`, value, "compact must be false or a numeric literal (compact: true has no lowering)");
             }
+            options.compact = Math.max(n, 0);
+        }
+        else if (key === "sorted") {
+            if (value.kind !== ts.SyntaxKind.TrueKeyword && value.kind !== ts.SyntaxKind.FalseKeyword) {
+                lowerer.noLowering(`${surface} with this sorted option`, value, "sorted must be true or false (a comparator function has no lowering)");
+            }
+            options.sorted = value.kind === ts.SyntaxKind.TrueKeyword;
         }
         else if (key === "breakLength") {
-            if (numeric() !== 80) {
-                lowerer.noLowering(`${surface} with a non-default breakLength option`, value, "only the default breakLength: 80 is lowered");
+            const n = ts.isIdentifier(value) && value.text === "Infinity" ? Infinity : numeric();
+            if (n === null || Number.isNaN(n)) {
+                lowerer.noLowering(`${surface} with a non-literal breakLength option`, value, "breakLength must be a numeric literal or Infinity");
             }
+            options.breakLength = n;
         }
         else if (dir && key === "customInspect") {
             // console.dir's own default; only that value is lowered.
@@ -1388,10 +2053,42 @@ function parseInspectOptions(lowerer, node, recursive, dir = false) {
             }
         }
         else {
-            lowerer.noLowering(`${surface} with the '${key}' option`, prop, `the lowered options are depth (numeric literal or null), colors: false, compact: 3, ${dir ? "breakLength: 80, and customInspect: false" : "and breakLength: 80"}`);
+            lowerer.noLowering(`${surface} with the '${key}' option`, prop, `the lowered options are depth (numeric literal or null), colors: false, compact (false or a number), breakLength, ${dir ? "sorted (true or false), and customInspect: false" : "and sorted (true or false)"}`);
         }
     }
-    return depth;
+    return options;
+}
+/** A render under non-default breakLength/compact/sorted: the value is evaluated
+ * first, the layout applies to this render only, and the defaults return
+ * afterwards. */
+function withInspectLayout(lowerer, options, value, render, loc) {
+    if (options.breakLength === 80 && options.compact === 3 && !options.sorted)
+        return render(value);
+    const input = lowerer.declareHiddenLocal("%inspectInput", value.type);
+    const text = lowerer.declareHiddenLocal("%inspectText", STRING);
+    const layout = (breakLength, compact, sorted) => ({
+        kind: "exprStmt",
+        expr: {
+            kind: "libCall",
+            fn: "insp.layout",
+            args: [numLit(breakLength, loc), numLit(compact, loc), boolLit(sorted, loc)],
+            type: VOID,
+            loc,
+        },
+        loc,
+    });
+    return {
+        kind: "seqExpr",
+        stmts: [
+            { kind: "varDecl", localId: input.id, init: value, loc },
+            layout(options.breakLength, options.compact, options.sorted),
+            { kind: "varDecl", localId: text.id, init: render(varRef(input.id, value.type, loc)), loc },
+            layout(80, 3, false),
+        ],
+        result: varRef(text.id, STRING, loc),
+        type: STRING,
+        loc,
+    };
 }
 /** `util.inspect(fn)` / `util.inspect(Cls)` over a DIRECT identifier
  * naming a declared function or class: the name is compile-time truth,
@@ -1416,7 +2113,7 @@ function directCallableInspect(lowerer, node, loc) {
         const base = cls.base ? ` extends ${cls.base.def.name.replace(/^%/, "")}` : "";
         return strLit(`[class ${cls.def.name}${base}]`, loc);
     }
-    const decl = lowerer.checker.declarationsOf(sym)[0];
+    const decl = sym.declarations[0];
     if (!decl)
         return null;
     if (ts.isFunctionDeclaration(decl) && decl.name) {
@@ -1435,10 +2132,10 @@ function directCallableInspect(lowerer, node, loc) {
 }
 /** util.inspect(value[, options]) — the spoke's inspect entry. */
 function lowerInspectCall(lowerer, expr, loc) {
-    if (expr.arguments.length < 1 || expr.arguments.length > 2) {
-        lowerer.noLowering(`util.inspect with ${expr.arguments.length} arguments`, expr, "the supported forms are inspect(value) and inspect(value, options)");
+    if (expr.arguments.nodes.length < 1 || expr.arguments.nodes.length > 2) {
+        lowerer.noLowering(`util.inspect with ${expr.arguments.nodes.length} arguments`, expr, "the supported forms are inspect(value) and inspect(value, options)");
     }
-    return lowerInspectValue(lowerer, expr.arguments[0], expr.arguments[1], loc, false);
+    return lowerInspectValue(lowerer, expr.arguments.nodes[0], expr.arguments.nodes[1], loc, false);
 }
 /** `inspect(value, options)` over one value node: the shared body of
  * util.inspect and console.dir. console.dir is Node's `inspect(object,
@@ -1466,22 +2163,29 @@ export function lowerInspectValue(lowerer, valueNode, optionsNode, loc, dir) {
     if (value.type.kind === "bytes") {
         // One runtime representation serves Buffer AND Uint8Array; their
         // renderings differ (<Buffer aa> vs Uint8Array(1) [ 170 ]), so the
-        // TOP-LEVEL argument's checker type picks — and only Buffer lowers.
-        // Nested bytes fence in inspectSupport (no checker type survives
-        // into shapes).
+        // TOP-LEVEL argument's checker type picks. Nested u8 bytes fence in
+        // inspectSupport (no checker type survives into shapes).
         const tname = lowerer.checker.typeToString(lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(valueNode)));
-        const isBuffer = tname === "Buffer" ||
-            tname === "NonSharedBuffer" ||
-            tname.startsWith("Buffer<") ||
-            tname.startsWith("NonSharedBuffer<");
-        if (dir) {
+        const isBuffer = isBufferTypeName(tname);
+        if (dir && isBuffer) {
             lowerer.noLowering(`console.dir of '${tname}' values`, valueNode, "console.dir disables custom inspection, and the typed-array rendering it falls back to has no lowering yet — use console.log");
         }
-        if (value.type.elem !== "u8" || !isBuffer) {
-            lowerer.noLowering(`util.inspect of '${tname}' values`, valueNode, "Buffer's <Buffer ..> form is the lowered typed-array rendering; other typed arrays fence");
+        if (isDataViewTypeName(tname)) {
+            lowerer.noLowering(`util.inspect of '${tname}' values`, valueNode, "Buffer and the numeric typed arrays are the lowered byte renderings; DataView has none yet");
+        }
+        const options = parseInspectOptions(lowerer, optionsNode, false, dir);
+        if (!isBuffer) {
+            // A numeric typed array: Uint8Array(n) [ ... ] under the depth and
+            // layout options.
+            return withInspectLayout(lowerer, options, value, (input) => ({
+                kind: "libCall",
+                fn: "insp.typedArray",
+                args: [input, numLit(0, loc), numLit(options.depth, loc)],
+                type: STRING,
+                loc,
+            }), loc);
         }
-        const bufDepth = parseInspectOptions(lowerer, optionsNode, false, dir);
-        void bufDepth; // Buffers render fully at any depth (custom inspect)
+        // Buffers render fully at any depth and on one line (custom inspect).
         return inspectExpr(lowerer, value.type, value, numLit(0, loc), numLit(2, loc), loc);
     }
     const walk = { recursive: false };
@@ -1489,17 +2193,18 @@ export function lowerInspectValue(lowerer, valueNode, optionsNode, loc, dir) {
     if (reason !== null) {
         lowerer.noLowering(`${surface} of '${lowerer.fmt(value.type)}' values`, valueNode, reason);
     }
-    const depth = parseInspectOptions(lowerer, optionsNode, walk.recursive, dir);
+    const options = parseInspectOptions(lowerer, optionsNode, walk.recursive, dir);
+    const depth = options.depth;
     if (dir && value.type.kind === "dyn") {
-        return {
+        return withInspectLayout(lowerer, options, value, (input) => ({
             kind: "libCall",
             fn: "console.dirDyn",
-            args: [value, numLit(depth, loc)],
+            args: [input, numLit(depth, loc)],
             type: STRING,
             loc,
-        };
+        }), loc);
     }
-    return inspectExpr(lowerer, value.type, value, numLit(0, loc), numLit(depth, loc), loc);
+    return withInspectLayout(lowerer, options, value, (input) => inspectExpr(lowerer, value.type, input, numLit(0, loc), numLit(depth, loc), loc), loc);
 }
 /* ── util.format / util.formatWithOptions ────────────────────────────── */
 /** One argument as format's %s conversion (Node: numbers via
@@ -1578,16 +2283,79 @@ function formatOArg(lowerer, node, depth, loc) {
     }
     return inspectExpr(lowerer, value.type, value, numLit(0, loc), numLit(depth, loc), loc);
 }
+/** %d and %i over a checked-dynamic argument, as Node's formatWithOptions
+ * reads it: a bigint prints as `${n}n`, a symbol as NaN, and any other
+ * value as `number` (Number(arg) for %d, parseInt(String(arg)) for %i)
+ * formatted. The argument evaluates once. */
+function formatDynInteger(lowerer, value, number, loc) {
+    const held = lowerer.declareHiddenLocal("%formatArg", DYN);
+    const ref = () => varRef(held.id, DYN, loc);
+    return {
+        kind: "seqExpr",
+        stmts: [{ kind: "varDecl", localId: held.id, init: value, loc }],
+        result: {
+            kind: "ternary",
+            cond: { kind: "dynTest", test: "bigint", value: ref(), type: BOOL, loc },
+            then: {
+                kind: "strConcat",
+                left: { kind: "libCall", fn: "dyn.toStringCoerce", args: [ref()], type: STRING, loc },
+                right: strLit("n", loc),
+                type: STRING,
+                loc,
+            },
+            else_: {
+                kind: "ternary",
+                cond: { kind: "dynTest", test: "symbol", value: ref(), type: BOOL, loc },
+                then: strLit("NaN", loc),
+                else_: { kind: "libCall", fn: "insp.f64", args: [number(ref())], type: STRING, loc },
+                type: STRING,
+                loc,
+            },
+            type: STRING,
+            loc,
+        },
+        type: STRING,
+        loc,
+    };
+}
+/** %d and %i over the argument types Node formats without a number
+ * conversion: a bigint prints as `${n}n` (formatBigInt) and a symbol as NaN;
+ * null is Number(null) (0) under %d and parseInt("null") (NaN) under %i, and
+ * undefined (including a void call) is NaN under both. Other arguments
+ * still evaluate. Null for other types. */
+function formatIntegerFixed(value, spec, loc) {
+    if (value.type.kind === "bigint") {
+        return { kind: "libCall", fn: "bigint.inspect", args: [value], type: STRING, loc };
+    }
+    let text;
+    if (value.type.kind === "symbol" ||
+        value.type.kind === "undefinedT" ||
+        value.type.kind === "void")
+        text = "NaN";
+    else if (value.type.kind === "nullT")
+        text = spec === "%d" ? "0" : "NaN";
+    else
+        return null;
+    if (value.kind === "unitLit")
+        return strLit(text, loc);
+    return {
+        kind: "seqExpr",
+        stmts: [{ kind: "exprStmt", expr: value, loc }],
+        result: strLit(text, loc),
+        type: STRING,
+        loc,
+    };
+}
 /** util.format(...) / util.formatWithOptions({}, ...): the compile-time
  * %-substitution over a literal format string (formatWithOptionsInternal
  * ported exactly — the arg cursor, the args-exhausted guard, %c's
  * consume-and-drop), with per-static-type conversions. Non-literal
  * format strings lower only in the substitution-free shapes. */
 export function lowerFormatCall(lowerer, expr, loc, withOptions, argNodesOverride, literalPrefix = "") {
-    const argNodes = [...(argNodesOverride ?? expr.arguments)];
+    const argNodes = [...(argNodesOverride ?? expr.arguments.nodes)];
     if (withOptions) {
         const opts = argNodes.shift();
-        if (!opts || !ts.isObjectLiteralExpression(opts) || opts.properties.length > 0) {
+        if (!opts || !ts.isObjectLiteralExpression(opts) || opts.properties.nodes.length > 0) {
             lowerer.noLowering("util.formatWithOptions with a non-empty options literal", opts ?? expr, "only the empty literal {} (the defaults — exactly util.format) is lowered");
         }
     }
@@ -1632,6 +2400,9 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions, argNodesOverrid
                 // strings through the runtime's ECMA-exact StringToNumber
                 // (num.fromString — the same lowering Number(aString) takes).
                 const value = lowerer.lowerExpr(node);
+                const fixed = formatIntegerFixed(value, "%d", loc);
+                if (fixed)
+                    return fixed;
                 if (value.type.kind === "f64")
                     return { kind: "libCall", fn: "insp.f64", args: [value], type: STRING, loc };
                 if (value.type.kind === "string") {
@@ -1663,19 +2434,15 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions, argNodesOverrid
                     };
                 }
                 // A checked-dynamic argument (`console.log('... actual %d.',
-                // context.actual)` — test/common's exit report): VALIDATE it as a
-                // number (dynCheck) and format. A non-number dyn value throws the
-                // catchable TypeError where Node would print its ToNumber (NaN
-                // for objects) — it throws instead of returning a wrong result
-                // (SEMANTICS.md).
+                // context.actual)` — test/common's exit report): Number(arg).
                 if (value.type.kind === "dyn") {
-                    return {
+                    return formatDynInteger(lowerer, value, (held) => ({
                         kind: "libCall",
-                        fn: "insp.f64",
-                        args: [{ kind: "dynCheck", value, type: F64, loc }],
-                        type: STRING,
+                        fn: "dyn.numberConstructor",
+                        args: [held],
+                        type: F64,
                         loc,
-                    };
+                    }), loc);
                 }
                 lowerer.noLowering(`util.format %d of '${lowerer.fmt(value.type)}' values`, node, "numbers, booleans, and strings lower; ToNumber over other types has no static lowering");
                 break;
@@ -1683,6 +2450,9 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions, argNodesOverrid
             case 105: {
                 // %i — parseInt(ToString(arg)): the spec-exact composition.
                 const value = lowerer.lowerExpr(node);
+                const fixed = formatIntegerFixed(value, "%i", loc);
+                if (fixed)
+                    return fixed;
                 if (value.type.kind === "f64" ||
                     value.type.kind === "bool" ||
                     value.type.kind === "string") {
@@ -1698,6 +2468,19 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions, argNodesOverrid
                     };
                     return { kind: "libCall", fn: "insp.f64", args: [parsed], type: STRING, loc };
                 }
+                // parseInt(String(arg)) over a checked-dynamic argument.
+                if (value.type.kind === "dyn") {
+                    return formatDynInteger(lowerer, value, (held) => ({
+                        kind: "libCall",
+                        fn: "num.parseInt",
+                        args: [
+                            { kind: "libCall", fn: "dyn.toStringCoerce", args: [held], type: STRING, loc },
+                            numLit(0, loc),
+                        ],
+                        type: F64,
+                        loc,
+                    }), loc);
+                }
                 lowerer.noLowering(`util.format %i of '${lowerer.fmt(value.type)}' values`, node);
                 break;
             }
@@ -1717,17 +2500,17 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions, argNodesOverrid
                     return strLit("undefined", loc);
                 }
                 // A checked-dynamic argument (`console.error('headers: %j',
-                // headers)` — the suite's http logging idiom): the runtime dyn
-                // walk stringifies JS-exactly (root undefined/function prints
-                // "undefined"; a handle in the tree throws the "not supported yet"
-                // Error).
+                // headers)` — the suite's http logging idiom): the runtime runs
+                // JSON.stringify's walk (toJSON hooks included; a root it drops
+                // prints "undefined") and prints "[Circular]" for a circular
+                // structure. A typed argument prints "[Circular]" the same way.
                 if (value.type.kind === "dyn") {
                     return { kind: "libCall", fn: "insp.jsonDyn", args: [value], type: STRING, loc };
                 }
                 if (!lowerer.jsonStringifySafe(value.type)) {
                     lowerer.noLowering(`util.format %j of '${lowerer.fmt(value.type)}' values`, node, "only JSON-safe static types lower");
                 }
-                return { kind: "jsonStringify", value, type: STRING, loc };
+                return { kind: "jsonStringify", value, circular: true, type: STRING, loc };
             }
             case 102: {
                 // %f — parseFloat(String(arg)) formatted: a number keeps its value
@@ -1894,21 +2677,21 @@ export function lowerUtilModuleCall(lowerer, expr, bi, loc) {
     switch (bi.member) {
         case "styleText":
         case "isDeepStrictEqual": {
-            if (expr.arguments.some(ts.isSpreadElement))
+            if (expr.arguments.nodes.some(ts.isSpreadElement))
                 lowerer.noLowering(`util.${bi.member} with spread arguments`, expr);
             const stmts = [];
             const args = [];
             // Save all inputs before evaluating surplus arguments: comparison may
             // read mutable objects or throw, so it must happen after every argument.
             for (let i = 0; i < 3; i++) {
-                const input = expr.arguments[i]
-                    ? lowerer.lowerExprExpecting(expr.arguments[i], DYN)
+                const input = expr.arguments.nodes[i]
+                    ? lowerer.lowerExprExpecting(expr.arguments.nodes[i], DYN)
                     : dynUndefinedExpr(loc);
                 const saved = lowerer.declareHiddenLocal("%utilInput", DYN);
                 stmts.push({ kind: "varDecl", localId: saved.id, init: input, loc });
                 args.push(varRef(saved.id, DYN, loc));
             }
-            for (const arg of expr.arguments.slice(3))
+            for (const arg of expr.arguments.nodes.slice(3))
                 stmts.push({ kind: "exprStmt", expr: lowerer.lowerExpr(arg), loc });
             const type = bi.member === "styleText" ? STRING : BOOL;
             return {
@@ -1926,10 +2709,10 @@ export function lowerUtilModuleCall(lowerer, expr, bi, loc) {
         case "debug":
             return lowerUtilCallableCall(lowerer, expr, bi.member, loc);
         case "getSystemErrorMap": {
-            if (expr.arguments.some(ts.isSpreadElement))
+            if (expr.arguments.nodes.some(ts.isSpreadElement))
                 lowerer.noLowering("util.getSystemErrorMap with spread arguments", expr);
             const result = lowerSystemErrorMap(lowerer, loc);
-            const stmts = expr.arguments.map((arg) => ({
+            const stmts = expr.arguments.nodes.map((arg) => ({
                 kind: "exprStmt",
                 expr: lowerer.lowerExpr(arg),
                 loc,
@@ -1940,24 +2723,24 @@ export function lowerUtilModuleCall(lowerer, expr, bi, loc) {
         case "getSystemErrorMessage":
         case "stripVTControlCharacters":
         case "toUSVString": {
-            if (expr.arguments.some(ts.isSpreadElement))
+            if (expr.arguments.nodes.some(ts.isSpreadElement))
                 lowerer.noLowering(`util.${bi.member} with spread arguments`, expr);
-            const input = expr.arguments[0]
-                ? lowerer.lowerExprExpecting(expr.arguments[0], DYN)
+            const input = expr.arguments.nodes[0]
+                ? lowerer.lowerExprExpecting(expr.arguments.nodes[0], DYN)
                 : {
                     kind: "dynFrom",
                     value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc },
                     type: DYN,
                     loc,
                 };
-            if (expr.arguments.length <= 1)
+            if (expr.arguments.nodes.length <= 1)
                 return { kind: "libCall", fn: `util.${bi.member}`, args: [input], type: STRING, loc };
             const saved = lowerer.declareHiddenLocal("%utilInput", DYN);
             return {
                 kind: "seqExpr",
                 stmts: [
                     { kind: "varDecl", localId: saved.id, init: input, loc },
-                    ...expr.arguments
+                    ...expr.arguments.nodes
                         .slice(1)
                         .map((arg) => ({ kind: "exprStmt", expr: lowerer.lowerExpr(arg), loc })),
                 ],
@@ -1981,11 +2764,11 @@ export function lowerUtilModuleCall(lowerer, expr, bi, loc) {
         case "parseArgs":
             return lowerParseArgsCall(lowerer, expr, loc);
         case "parseEnv": {
-            if (expr.arguments.length > 1 || expr.arguments.some(ts.isSpreadElement)) {
+            if (expr.arguments.nodes.length > 1 || expr.arguments.nodes.some(ts.isSpreadElement)) {
                 lowerer.noLowering("util.parseEnv with spread or extra arguments", expr);
             }
-            const input = expr.arguments[0]
-                ? lowerer.lowerExprExpecting(expr.arguments[0], DYN)
+            const input = expr.arguments.nodes[0]
+                ? lowerer.lowerExprExpecting(expr.arguments.nodes[0], DYN)
                 : dynUndefinedExpr(loc);
             const parsed = {
                 kind: "libCall",
@@ -2014,7 +2797,7 @@ export function lowerUtilModuleCall(lowerer, expr, bi, loc) {
  * answer native dyn wrappers; a static function slot checks the wrapper
  * when it receives it, and dyn slots keep calling it with JS arity. */
 function lowerUtilCallableCall(lowerer, expr, member, loc) {
-    if (expr.arguments.some(ts.isSpreadElement))
+    if (expr.arguments.nodes.some(ts.isSpreadElement))
         lowerer.noLowering(`util.${member} with spread arguments`, expr);
     const fn = member === "inherits"
         ? "util.inherits"
@@ -2026,8 +2809,15 @@ function lowerUtilCallableCall(lowerer, expr, member, loc) {
     const arity = member === "deprecate" ? 4 : member === "callbackify" ? 1 : 2;
     // Program classes keep static prototypes: there is no function object
     // whose prototype chain the runtime could relink or wrap.
+    // EventEmitter and the stream classes are the exception as superCtor:
+    // the runtime has untyped constructors for them (builtin-class-dyn.ts).
     const classArgs = member === "inherits" ? 2 : member === "deprecate" ? 1 : 0;
-    for (const arg of expr.arguments.slice(0, classArgs)) {
+    const builtinBase = member === "inherits" && expr.arguments.nodes[1] !== undefined
+        ? builtinClassKindOf(lowerer, expr.arguments.nodes[1])
+        : null;
+    for (const [index, arg] of expr.arguments.nodes.slice(0, classArgs).entries()) {
+        if (index === 1 && builtinBase !== null)
+            continue;
         if (lowerer.mapTypeOf(lowerer.typeOf(arg))?.kind === "classval")
             lowerer.noLowering(`util.${member} over a class constructor`, arg, member === "inherits"
                 ? "declare the subclass with extends"
@@ -2038,14 +2828,17 @@ function lowerUtilCallableCall(lowerer, expr, member, loc) {
     const stmts = [];
     const args = [];
     for (let i = 0; i < arity; i++) {
-        const input = expr.arguments[i]
-            ? lowerer.lowerExprExpecting(expr.arguments[i], DYN)
-            : dynUndefinedExpr(loc);
+        const node = expr.arguments.nodes[i];
+        const input = !node
+            ? dynUndefinedExpr(loc)
+            : i === 1 && builtinBase !== null
+                ? (builtinClassDynValueOf(lowerer, node) ?? lowerer.lowerExprExpecting(node, DYN))
+                : lowerer.lowerExprExpecting(node, DYN);
         const saved = lowerer.declareHiddenLocal("%utilInput", DYN);
         stmts.push({ kind: "varDecl", localId: saved.id, init: input, loc });
         args.push(varRef(saved.id, DYN, loc));
     }
-    for (const arg of expr.arguments.slice(arity))
+    for (const arg of expr.arguments.nodes.slice(arity))
         stmts.push({ kind: "exprStmt", expr: lowerer.lowerExpr(arg), loc });
     const type = fn === "util.inherits" ? VOID : DYN;
     const result = { kind: "libCall", fn, args, type, loc };
@@ -2057,7 +2850,7 @@ function lowerUtilCallableCall(lowerer, expr, member, loc) {
  * a statically typed callback parameter cannot receive a value its type
  * excludes. Untyped (JavaScript or unknown) slots keep the wrapper dyn. */
 function callbackifyErrorExcludesNull(lowerer, expr) {
-    if (isJsSourceFile(expr.getSourceFile()))
+    if (isJsSourceFile(ts.getSourceFileOfNode(expr)))
         return false;
     const checker = lowerer.checker;
     const slot = checker.getContextualType(expr) ?? lowerer.typeOf(expr);
@@ -2079,11 +2872,11 @@ function callbackifyErrorExcludesNull(lowerer, expr) {
  * variants and a null-prototype values object); statically typed member
  * reads leave that tree through the ordinary dyn checks. */
 function lowerParseArgsCall(lowerer, expr, loc) {
-    if (expr.arguments.length > 1 || expr.arguments.some(ts.isSpreadElement)) {
-        lowerer.noLowering(`util.parseArgs with ${expr.arguments.length} arguments`, expr, "the lowered form is parseArgs() or parseArgs(config)");
+    if (expr.arguments.nodes.length > 1 || expr.arguments.nodes.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`util.parseArgs with ${expr.arguments.nodes.length} arguments`, expr, "the lowered form is parseArgs() or parseArgs(config)");
     }
     let config;
-    const configNode = expr.arguments[0];
+    const configNode = expr.arguments.nodes[0];
     if (!configNode) {
         config = { kind: "dynObjLit", fields: [], type: DYN, loc };
     }
@@ -2137,9 +2930,9 @@ function lowerParseArgsCall(lowerer, expr, loc) {
  * forms and TypeScript keep the SC2020 fence: a typed consumer asserting
  * real frames must fail at compile time instead of reading placeholders. */
 function lowerGetCallSitesCall(lowerer, expr, loc) {
-    if (expr.arguments.length !== 0)
+    if (expr.arguments.nodes.length !== 0)
         return null;
-    if (!isJsSourceFile(expr.getSourceFile()))
+    if (!isJsSourceFile(ts.getSourceFileOfNode(expr)))
         return null;
     const frame = () => {
         const field = (name, value) => ({
@@ -2152,7 +2945,7 @@ function lowerGetCallSitesCall(lowerer, expr, loc) {
                 field("functionName", { kind: "strLit", value: "", type: STRING, loc }),
                 field("scriptName", {
                     kind: "strLit",
-                    value: expr.getSourceFile().fileName,
+                    value: ts.getSourceFileOfNode(expr).fileName,
                     type: STRING,
                     loc,
                 }),