@scriptc/compiler 0.3.5 → 0.4.0

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

@@ -1,15 +1,17 @@
 import { dynUndefinedExpr, boolLit, helperLoc, 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";
 import { lowerSystemErrorMap } from "./lower-system-errors.js";
 import { isPerfEntryType, perfEntryJson } from "./builtins/performance.js";
 import { recordMayKeepSource, recordSourceTest } from "./record-sources.js";
+import { nullProtoRecordShape, recordNullProtoTest } from "./null-prototype.js";
 /* ── IR construction shorthand ───────────────────────────────────────── */
 function concatAll(parts, loc) {
     if (parts.length === 0)
@@ -108,12 +110,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;
@@ -197,9 +204,10 @@ function inspectSupport(lowerer, t, visiting, out) {
                     ? null
                     : "error subclasses with declared fields have no inspect lowering yet (the extra own properties are runtime-dynamic)";
             }
-            // 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);
@@ -235,6 +243,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`;
     }
@@ -299,10 +311,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 {
@@ -322,7 +355,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",
@@ -425,6 +458,29 @@ function typeConstituents(lowerer, u) {
             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
@@ -455,8 +511,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);
@@ -763,6 +819,19 @@ function inspectHelper(lowerer, t, loc) {
                 const n = () => varRef("n.0", F64, loc);
                 const i = () => varRef("i.0", F64, loc);
                 const k = () => varRef("k.0", STRING, loc);
+                // A null-prototype record (Object.groupBy) prints Node's
+                // "[Object: null prototype]" base.
+                const nullProto = nullProtoRecordShape(lowerer, t) !== null;
+                const byProto = (plain, bare) => nullProto
+                    ? {
+                        kind: "ternary",
+                        cond: recordNullProtoTest(v(), t.shapeId, loc),
+                        then: strLit(bare, loc),
+                        else_: strLit(plain, loc),
+                        type: STRING,
+                        loc,
+                    }
+                    : strLit(plain, loc);
                 const keyedRead = () => ({
                     kind: "recordKeyGet",
                     obj: v(),
@@ -795,11 +864,17 @@ function inspectHelper(lowerer, t, loc) {
                     {
                         kind: "if",
                         cond: { kind: "bin", op: "===", left: n(), right: numLit(0, loc), type: BOOL, loc },
-                        then: [ret(strLit("{}", loc))],
+                        then: [ret(byProto("{}", "[Object: null prototype] {}"))],
+                        else_: null,
+                        loc,
+                    },
+                    {
+                        kind: "if",
+                        cond: { kind: "bin", op: ">", left: r(), right: d(), type: BOOL, loc },
+                        then: [ret(byProto("[Object]", "[Object: null prototype]"))],
                         else_: null,
                         loc,
                     },
-                    depthGate("[Object]"),
                     ...begin(),
                     {
                         kind: "for",
@@ -826,7 +901,7 @@ function inspectHelper(lowerer, t, loc) {
                         ],
                         loc,
                     },
-                    ret(end(strLit("", loc), strLit("{", loc), strLit("}", loc), false, boolLit(false, loc))),
+                    ret(end(byProto("", "[Object: null prototype]"), strLit("{", loc), strLit("}", loc), false, boolLit(false, loc))),
                 ];
                 break;
             }
@@ -837,6 +912,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);
@@ -1051,7 +1127,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;
@@ -1139,6 +1215,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: [
@@ -1151,6 +1230,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();
@@ -1278,15 +1376,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);
     }
@@ -1295,6 +1398,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) {
@@ -1302,18 +1409,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");
         }
@@ -1336,14 +1450,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") {
@@ -1352,14 +1466,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.
@@ -1368,10 +1495,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,
@@ -1396,7 +1555,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) {
@@ -1415,10 +1574,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,
@@ -1446,22 +1605,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 };
@@ -1469,17 +1635,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
@@ -1558,16 +1725,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");
         }
     }
@@ -1612,6 +1842,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") {
@@ -1643,19 +1876,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;
@@ -1663,6 +1892,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") {
@@ -1678,6 +1910,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;
             }
@@ -1697,17 +1942,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
@@ -1874,21 +2119,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 {
@@ -1906,10 +2151,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,
@@ -1920,24 +2165,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 })),
                 ],
@@ -1961,11 +2206,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",
@@ -1994,7 +2239,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"
@@ -2006,8 +2251,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"
@@ -2018,14 +2270,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 };
@@ -2037,7 +2292,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);
@@ -2059,11 +2314,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 };
     }
@@ -2117,9 +2372,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) => ({
@@ -2132,7 +2387,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,
                 }),