@scriptc/compiler 0.4.6 → 0.4.8

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

@@ -10,7 +10,7 @@ import { unsignedHex } from "../../format-integer.js";
 import { jsFuncNameOf } from "./lowerer.js";
 import { isJsSourceFile, locOf } from "../program.js";
 import { noLoweringDiag } from "../../diagnostics/diagnostic.js";
-import { BOOL, CAUGHT, DYN, F64, RUNTIME_ERROR_CLASSES, STRING, isUnitType, UNDEFINED_T, VOID, canConvertToDyn, canDynCheckTo, funcOf, arrayOf, CLASS_FIELD_ATTRIBUTES_PREFIX, classDynViewSupported, DYN_CLASS_PROPERTIES, isClassOwnEnumerableFieldName, isDirentShape, isDynTypedRefType, recordTextCodecClass, shapeHasAccessorSlots, shapeKeyOrders, typeKey, } from "../../ir/ir.js";
+import { BOOL, CAUGHT, DYN, F64, RUNTIME_ERROR_CLASSES, STRING, isUnitType, UNDEFINED_T, VOID, canConvertToDyn, canDynCheckTo, funcOf, arrayOf, CLASS_FIELD_ATTRIBUTES_PREFIX, classDynViewSupported, DYN_CLASS_PROPERTIES, isClassOwnEnumerableFieldName, isDirentShape, isDynTypedRefType, accessorSlotProp, recordTextCodecClass, shapeKeyOrders, typeKey, } from "../../ir/ir.js";
 import { accessorCall, findMethodOn } from "./lower-classes.js";
 import { isSafeToDiscard, isSafeToRepeat } from "./expressions/evaluation-safety.js";
 import { INSPECT_CUSTOM_MEMBER, symbolFieldDisplayName, TO_STRING_TAG_FIELD, } from "./symbol-fields.js";
@@ -19,6 +19,7 @@ import { dateRootOf } from "./builtins/date-classes.js";
 import { lowerSystemErrorMap } from "./lower-system-errors.js";
 import { isPerfEntryType, perfEntryJson } from "./builtins/performance.js";
 import { recordMayKeepSource, recordSourceTest } from "./record-sources.js";
+import { registerLinkedHelper } from "./record-links.js";
 import { nullProtoRecordShape, recordNullProtoTest } from "./null-prototype.js";
 import { dynArgumentPack } from "./call-arguments.js";
 /* ── IR construction shorthand ───────────────────────────────────────── */
@@ -222,14 +223,15 @@ function errorInstanceReachesItself(lowerer, c) {
 }
 /** 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. */
+ * or carry a `cause`: Node prints the error base — its stack, headed
+ * `Bailable [Error]: m` by improveStack, or the bracketed
+ * `[Bailable [Error]: m]` when the stack has no frame line — followed by
+ * the own properties, `{ bail: true }` after the last frame, 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);
@@ -548,10 +550,12 @@ function userErrorClasses(info) {
     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. */
+/** Node's improveStack over the rendering's base: 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. Two bases reach here: the
+ * bracket form (`[Error: m]`, an error whose stack is empty) and the stack
+ * itself (`Error: m\n    at ...`, whose first line carries the header). */
 function improvedErrorBase(lowerer, value, base, display, loc) {
     const str = (method, receiver, args, type) => ({
         kind: "strIntrinsic",
@@ -605,6 +609,36 @@ function improvedErrorBase(lowerer, value, base, display, loc) {
         type: STRING,
         loc,
     };
+    /** The name's length — where a stack base's header ends. */
+    const nameLength = () => str("length", nameRef(), [], F64);
+    /** The base's character at `name.length`: `:` or `\n` after the name, or
+     * the empty answer when the base is the name alone (Node's
+     * `stack.length === len` arm). */
+    const atNameEnd = () => str("charAt", baseRef(), [nameLength()], STRING);
+    const stackCond = and(and(eq(nameRef(), strLit(display, loc), true), str("endsWith", nameRef(), [strLit("Error", loc)], BOOL)), and(str("startsWith", baseRef(), [nameRef()], BOOL), {
+        kind: "logical",
+        op: "||",
+        left: {
+            kind: "logical",
+            op: "||",
+            left: eq(atNameEnd(), strLit(":", loc)),
+            right: eq(atNameEnd(), strLit("\n", loc)),
+            type: BOOL,
+            loc,
+        },
+        right: eq(atNameEnd(), strLit("", loc)),
+        type: BOOL,
+        loc,
+    }));
+    const stackRest = () => str("slice", baseRef(), [nameLength()], STRING);
+    const improvedStack = {
+        kind: "ternary",
+        cond: str("includes", strLit(display, loc), [nameRef()], BOOL),
+        then: concatAll([strLit(display, loc), stackRest()], loc),
+        else_: concatAll([strLit(`${display} [`, loc), nameRef(), strLit("]", loc), stackRest()], loc),
+        type: STRING,
+        loc,
+    };
     return {
         kind: "seqExpr",
         stmts: [
@@ -623,7 +657,21 @@ function improvedErrorBase(lowerer, value, base, display, loc) {
             },
             { kind: "varDecl", localId: "raw.0", init: base, loc },
         ],
-        result: { kind: "ternary", cond, then: improved, else_: baseRef(), type: STRING, loc },
+        result: {
+            kind: "ternary",
+            cond,
+            then: improved,
+            else_: {
+                kind: "ternary",
+                cond: stackCond,
+                then: improvedStack,
+                else_: baseRef(),
+                type: STRING,
+                loc,
+            },
+            type: STRING,
+            loc,
+        },
         type: STRING,
         loc,
     };
@@ -662,15 +710,9 @@ function inspectSupport(lowerer, t, visiting, out) {
             const shape = lowerer.shapes.get(t.shapeId);
             if (!shape)
                 return "this record shape has no inspect lowering";
-            const codec = recordTextCodecClass(shape);
-            if (codec !== null)
-                return `${codec} instances have no inspect lowering yet`;
-            // Accessor-carrying shapes: Node prints the accessor names as
-            // `x: [Getter]` / `[Setter]` / `[Getter/Setter]` in insertion order
-            // — a position the static field walk does not track (accessor slots
-            // live outside declaredOrder), so the render fences by name.
-            if (shapeHasAccessorSlots(shape)) {
-                return "shapes carrying get/set accessor properties have no inspect lowering yet (Node prints the accessor names as [Getter]/[Setter] in insertion order — read the properties explicitly)";
+            if (recordTextCodecClass(shape) !== null) {
+                visiting.delete(t.shapeId);
+                return null;
             }
             if (shape.indexValue !== undefined) {
                 // PURE index-signature shapes (Record<string, V> — no declared
@@ -689,6 +731,22 @@ function inspectSupport(lowerer, t, visiting, out) {
                 return null;
             }
             for (const f of shape.fields) {
+                // An accessor's closure slot never renders itself: the property's
+                // entry prints Node's label, or the getter's RESULT under the
+                // getters option (a setter-only property stays a label). A getter
+                // that returns nothing renders `[Getter: undefined]` — the label
+                // path already, so its void result is no fence.
+                const slot = accessorSlotProp(f.name);
+                if (slot && f.type.kind === "func") {
+                    if (slot.kind === "set")
+                        continue;
+                    if (f.type.ret.kind === "void")
+                        continue;
+                    const why = inspectSupport(lowerer, f.type.ret, visiting, out);
+                    if (why !== null)
+                        return why;
+                    continue;
+                }
                 const why = inspectSupport(lowerer, f.type, visiting, out);
                 if (why !== null)
                     return why;
@@ -930,10 +988,11 @@ function inspectMayRefuse(lowerer, t) {
 }
 function inspectExprBody(lowerer, t, value, recurse, depth, loc, ownRendering) {
     // A Dirent row renders through its dyn view: Node's `Dirent { ... }`
-    // with the Symbol(type) key.
+    // with the Symbol(type) key. So do TextEncoder and TextDecoder, through
+    // their handles' inspectors.
     if (t.kind === "record") {
         const shape = lowerer.shapes.get(t.shapeId);
-        if (shape && isDirentShape(shape)) {
+        if (shape && (isDirentShape(shape) || recordTextCodecClass(shape) !== null)) {
             return {
                 kind: "libCall",
                 fn: "insp.dyn",
@@ -1096,6 +1155,14 @@ export function typeReachesItself(lowerer, t) {
     };
     return walk(t);
 }
+/** Whether a record shape carries an accessor getter, whose result can be
+ * the walked value itself. */
+function shapeHasGetter(lowerer, shapeId) {
+    const shape = lowerer.shapes.get(shapeId);
+    if (!shape)
+        return false;
+    return shape.fields.some((f) => accessorSlotProp(f.name)?.kind === "get" && f.type.kind === "func");
+}
 /** True when a value of `t` can be cyclic: `t` or any type reachable from
  * it reaches itself. */
 export function typeReachesCycle(lowerer, t) {
@@ -1249,6 +1316,24 @@ export function typeReachesCustomInspect(lowerer, t) {
     };
     return walk(t);
 }
+/** Whether a `t` value can reach a TextEncoder or TextDecoder, whose
+ * handles print through Node's custom inspectors. */
+function typeReachesTextCodec(lowerer, t) {
+    const seen = new Set();
+    const walk = (u) => {
+        const k = typeKey(u);
+        if (seen.has(k))
+            return false;
+        seen.add(k);
+        if (u.kind === "record") {
+            const shape = lowerer.shapes.get(u.shapeId);
+            if (shape && recordTextCodecClass(shape) !== null)
+                return true;
+        }
+        return typeConstituents(lowerer, u).some(walk);
+    };
+    return walk(t);
+}
 /** `%util.inspCustom.<n>(v, r, d): string` — formatValue's custom hook
  * over a class whose instances have a `[util.inspect.custom]` method:
  * with ctx.customInspect set, the method's result (a string re-indented
@@ -1482,8 +1567,11 @@ function inspectHelper(lowerer, t, loc) {
     // 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.
+    // An accessor's getter answers any value — the walked value itself
+    // included — which no declared field type shows, so a shape with a
+    // getter keeps Node's circular bookkeeping on.
     const onCycle = (t.kind === "record" || t.kind === "array" || t.kind === "map" || t.kind === "object") &&
-        typeReachesItself(lowerer, t);
+        (typeReachesItself(lowerer, t) || (t.kind === "record" && shapeHasGetter(lowerer, t.shapeId)));
     const begin = () => [
         exprStmt({ kind: "libCall", fn: "insp.begin", args: [rPlus1()], type: { kind: "void" }, loc }),
         ...(onCycle
@@ -1581,6 +1669,15 @@ function inspectHelper(lowerer, t, loc) {
             const i = () => varRef("i.0", F64, loc);
             const next = () => varRef("next.0", F64, loc);
             const hasMore = () => lt(i(), n());
+            // The render's maxArrayLength: entries show while the output holds
+            // fewer than the limit, at every nesting level (Node's ctx).
+            const limit = () => ({
+                kind: "libCall",
+                fn: "insp.maxArrayLength",
+                args: [],
+                type: F64,
+                loc,
+            });
             // A foreign element (state 3) holds a value outside the element type.
             const foreignElements = elementMayBeForeign(lowerer, t.elem);
             const foreign = () => ({
@@ -1651,7 +1748,7 @@ function inspectHelper(lowerer, t, loc) {
                         kind: "logical",
                         op: "&&",
                         left: hasMore(),
-                        right: lt(shown(), numLit(100, loc)),
+                        right: lt(shown(), limit()),
                         type: BOOL,
                         loc,
                     },
@@ -1788,16 +1885,71 @@ function inspectHelper(lowerer, t, loc) {
                 break;
             }
             if (shape.tuple) {
-                // Tuples ARE arrays to Node: bracket form, array-extras grouping.
-                if (shape.fields.length === 0) {
+                // Tuples ARE arrays to Node: bracket form, array-extras grouping,
+                // and the same maxArrayLength bound on the entries shown.
+                const count = shape.fields.length;
+                if (count === 0) {
                     body = [ret(strLit("[]", loc))];
                     break;
                 }
-                body = [depthGate("[Array]"), ...begin()];
-                for (const f of shape.fields) {
-                    body.push(entry(child(f.type, get(f.name, f.type)), isNumberFlag(lowerer, f.type, () => get(f.name, f.type), loc)));
+                locals.push({ id: "lim.0", name: "lim", type: F64, mutable: false });
+                const lim = () => varRef("lim.0", F64, loc);
+                const lt = (left, right) => ({
+                    kind: "bin",
+                    op: "<",
+                    left,
+                    right,
+                    type: BOOL,
+                    loc,
+                });
+                const bounded = () => lt(lim(), numLit(count, loc));
+                body = [
+                    depthGate("[Array]"),
+                    {
+                        kind: "varDecl",
+                        localId: "lim.0",
+                        init: { kind: "libCall", fn: "insp.maxArrayLength", args: [], type: F64, loc },
+                        loc,
+                    },
+                    ...begin(),
+                ];
+                for (let i = 0; i < count; i++) {
+                    const f = shape.fields[i];
+                    body.push({
+                        kind: "if",
+                        cond: lt(numLit(i, loc), lim()),
+                        then: [
+                            entry(child(f.type, get(f.name, f.type)), isNumberFlag(lowerer, f.type, () => get(f.name, f.type), loc)),
+                        ],
+                        else_: null,
+                        loc,
+                    });
                 }
-                body.push(ret(end(strLit("", loc), strLit("[", loc), strLit("]", loc), true, boolLit(false, loc))));
+                body.push({
+                    kind: "if",
+                    cond: bounded(),
+                    then: [
+                        entry({
+                            kind: "libCall",
+                            fn: "insp.moreItems",
+                            args: [
+                                {
+                                    kind: "bin",
+                                    op: "-",
+                                    left: numLit(count, loc),
+                                    right: lim(),
+                                    type: F64,
+                                    loc,
+                                },
+                            ],
+                            type: STRING,
+                            loc,
+                        }, boolLit(false, loc)),
+                    ],
+                    else_: null,
+                    loc,
+                });
+                body.push(ret(end(strLit("", loc), strLit("[", loc), strLit("]", loc), true, bounded())));
                 break;
             }
             if (shape.indexValue && shape.fields.length === 0) {
@@ -1908,9 +2060,238 @@ function inspectHelper(lowerer, t, loc) {
             // reachability can settle this shape after the helper is first
             // interned, so rebuild the field walk once metadata is final.
             lowerer.keyOrder.observe(t);
+            const accessors = new Map();
+            for (const f of shape.fields) {
+                const slot = accessorSlotProp(f.name);
+                if (!slot || f.type.kind !== "func")
+                    continue;
+                const slots = accessors.get(slot.prop) ?? {};
+                if (slot.kind === "get")
+                    slots.get = f.type;
+                else
+                    slots.set = f.type;
+                accessors.set(slot.prop, slots);
+            }
+            if (accessors.size > 0) {
+                // The getters option, read once per render: the helper is shared
+                // by every call site, so the option is run-time state.
+                locals.push({ id: "gm.0", name: "gm", type: F64, mutable: false });
+                for (let i = 0; i < accessors.size; i++) {
+                    locals.push({ id: `a.${i}`, name: "a", type: STRING, mutable: true }, { id: `ae.${i}`, name: "ae", type: CAUGHT, mutable: false });
+                }
+            }
+            const ACCESSOR_PRIMITIVES = new Set([
+                "f64",
+                "string",
+                "bool",
+                "undefinedT",
+                "nullT",
+                "bigint",
+                "symbol",
+            ]);
+            let accessorIndex = 0;
+            const accessorValueLocals = new Set();
+            /** `key: <label>` for an accessor property, invoking its getter when
+             * the getters option names it: the result renders by kind (Node's
+             * formatProperty), a throw as `[Label: <Inspection threw (err)>]`. */
+            const accessorEntry = (name, slots) => {
+                const index = accessorIndex++;
+                const strId = `a.${index}`;
+                const caughtId = `ae.${index}`;
+                const label = slots.get ? (slots.set ? "Getter/Setter" : "Getter") : "Setter";
+                const s = () => varRef(strId, STRING, loc);
+                const entryOf = (value) => entry(concatAll([strLit(`${inspectKey(name)}: `, loc), value], loc), boolLit(false, loc));
+                const getType = slots.get;
+                if (getType === undefined) {
+                    return [
+                        { kind: "varDecl", localId: strId, init: strLit(`[${label}]`, loc), loc },
+                        entryOf(s()),
+                    ];
+                }
+                const called = {
+                    kind: "callValue",
+                    callee: {
+                        kind: "recordGet",
+                        obj: v(),
+                        shapeId: t.shapeId,
+                        field: `%get:${name}`,
+                        type: getType,
+                        loc,
+                    },
+                    args: [],
+                    type: getType.ret,
+                    loc,
+                };
+                const resultT = getType.ret;
+                // What the getter answered renders by RUNTIME kind (Node's
+                // formatProperty): a null and the primitives `[Label: <primitive>]`,
+                // an object or a function `[Label] <value>`. A checker union
+                // dispatches on the arm that holds; a checked-dynamic answer is
+                // classified by the runtime. A getter that returns nothing runs for
+                // its effects and renders Node's `[Getter: undefined]`.
+                const primitiveText = (armT, value) => concatAll([strLit(`[${label}: `, loc), child(armT, value), strLit("]", loc)], loc);
+                const rendered = (armT, value) => {
+                    if (armT.kind === "dyn")
+                        return {
+                            kind: "libCall",
+                            fn: "insp.accessorValue",
+                            args: [value, strLit(label, loc), rPlus1(), d()],
+                            type: STRING,
+                            loc,
+                        };
+                    return ACCESSOR_PRIMITIVES.has(armT.kind)
+                        ? primitiveText(armT, value)
+                        : concatAll([strLit(`[${label}] `, loc), child(armT, value)], loc);
+                };
+                // The getter runs in an inspection context of its own: util.inspect
+                // calls INSIDE it start from Node's fresh defaults and must leave
+                // this walk's options, frames and circular bookkeeping alone. What
+                // it answered renders in THIS context, at the property's level.
+                const valueId = `av.${index}`;
+                const tokenId = `at.${index}`;
+                const hasValue = resultT.kind !== "void";
+                if (hasValue && !accessorValueLocals.has(valueId)) {
+                    accessorValueLocals.add(valueId);
+                    // Declared by the try's varDecl, so the answer's release is the
+                    // try's; nothing reads it outside.
+                    locals.push({ id: valueId, name: "av", type: resultT, mutable: false });
+                }
+                if (!accessorValueLocals.has(tokenId)) {
+                    accessorValueLocals.add(tokenId);
+                    locals.push({ id: tokenId, name: "at", type: F64, mutable: true });
+                }
+                const val = () => varRef(valueId, resultT, loc);
+                const render = [];
+                if (resultT.kind === "void") {
+                    render.push({
+                        kind: "assign",
+                        localId: strId,
+                        value: strLit(`[${label}: undefined]`, loc),
+                        loc,
+                    });
+                }
+                else if (resultT.kind === "union") {
+                    const def = lowerer.unions.get(resultT.unionId);
+                    if (!def)
+                        throw new InternalCompilerError(`inspect of unknown union ${resultT.unionId}`);
+                    // The result is read once, then the arm holding decides the form.
+                    def.arms.forEach((arm, tag) => {
+                        const narrowed = {
+                            kind: "unionNarrow",
+                            unionId: resultT.unionId,
+                            tag,
+                            value: val(),
+                            type: arm,
+                            loc,
+                        };
+                        render.push({
+                            kind: "if",
+                            cond: {
+                                kind: "unionIsTag",
+                                unionId: resultT.unionId,
+                                tag,
+                                negated: false,
+                                value: val(),
+                                type: BOOL,
+                                loc,
+                            },
+                            then: [{ kind: "assign", localId: strId, value: rendered(arm, narrowed), loc }],
+                            else_: null,
+                            loc,
+                        });
+                    });
+                }
+                else {
+                    render.push({ kind: "assign", localId: strId, value: rendered(resultT, val()), loc });
+                }
+                const threw = concatAll([
+                    strLit(`[${label}: <Inspection threw (`, loc),
+                    child(DYN, {
+                        kind: "caughtToDyn",
+                        value: varRef(caughtId, CAUGHT, loc),
+                        type: DYN,
+                        loc,
+                    }),
+                    strLit(")>]", loc),
+                ], loc);
+                // Node's condition reads the option's truthiness first: `true`
+                // runs every getter, 'get' the ones without a setter and 'set' the
+                // ones with one.
+                const mode = (n) => ({
+                    kind: "bin",
+                    op: "===",
+                    left: varRef("gm.0", F64, loc),
+                    right: numLit(n, loc),
+                    type: BOOL,
+                    loc,
+                });
+                const either = (a, b) => ({
+                    kind: "logical",
+                    op: "||",
+                    left: a,
+                    right: b,
+                    type: BOOL,
+                    loc,
+                });
+                const libStmt = (fn, args = []) => ({
+                    kind: "exprStmt",
+                    expr: { kind: "libCall", fn, args, type: VOID, loc },
+                    loc,
+                });
+                const endCall = libStmt("insp.customCallEnd", [varRef(tokenId, F64, loc)]);
+                return [
+                    { kind: "varDecl", localId: strId, init: strLit(`[${label}]`, loc), loc },
+                    {
+                        kind: "if",
+                        cond: slots.set ? either(mode(1), mode(3)) : either(mode(1), mode(2)),
+                        then: [
+                            libStmt("insp.mark"),
+                            {
+                                kind: "assign",
+                                localId: tokenId,
+                                value: { kind: "libCall", fn: "insp.customCallBegin", args: [], type: F64, loc },
+                                loc,
+                            },
+                            {
+                                // Node's try spans the getter call AND the result's
+                                // rendering, so a throw from either answers the threw
+                                // label. The call's context ends before the result renders
+                                // (it renders in this walk's); the mark puts this walk's
+                                // options and frames back when the rendering throws and
+                                // left them open.
+                                kind: "tryCatch",
+                                tryBody: [
+                                    // Declared here, so the answer's release is the try's:
+                                    // nothing reads it outside.
+                                    hasValue
+                                        ? { kind: "varDecl", localId: valueId, init: called, loc }
+                                        : { kind: "exprStmt", expr: called, loc },
+                                    endCall,
+                                    ...render,
+                                    libStmt("insp.unwind"),
+                                ],
+                                catchLocalId: caughtId,
+                                // A throw from the getter leaves its call open; a throw
+                                // from the rendering leaves frames open. The mark returns
+                                // this walk to where it was either way.
+                                catchBody: [
+                                    libStmt("insp.unwind"),
+                                    { kind: "assign", localId: strId, value: threw, loc },
+                                ],
+                                finallyBody: null,
+                                loc,
+                            },
+                        ],
+                        else_: null,
+                        loc,
+                    },
+                    entryOf(s()),
+                ];
+            };
             rebuildShapeOrderBody = () => {
                 const current = lowerer.shapes.get(t.shapeId) ?? shape;
-                const order = current.declaredOrder ?? current.fields.map((f) => f.name);
+                accessorIndex = 0;
+                const order = current.accessorOrder ?? current.declaredOrder ?? current.fields.map((f) => f.name);
                 const byName = new Map(current.fields.map((f) => [f.name, f.type]));
                 // Optional fields render only while present (an omitted or
                 // deleted property is not shown; an explicit undefined is). A
@@ -1933,13 +2314,27 @@ function inspectHelper(lowerer, t, loc) {
                     });
                 }
                 body.push(depthGate("[Object]"), ...begin());
-                // One walk per key order (see perKeyOrder).
-                const orders = shapeKeyOrders(current);
+                if (accessors.size > 0) {
+                    body.push({
+                        kind: "varDecl",
+                        localId: "gm.0",
+                        init: { kind: "libCall", fn: "insp.gettersMode", args: [], type: F64, loc },
+                        loc,
+                    });
+                }
+                // One walk per key order (see perKeyOrder). An accessor-carrying
+                // shape enumerates in accessorOrder, exactly as its
+                // checked-dynamic copy does (dyn.ts).
+                const orders = current.accessorOrder !== undefined ? [current.accessorOrder] : shapeKeyOrders(current);
                 const walks = orders.map(() => []);
                 for (const [k, fname] of orders.flatMap((order, k) => order.map((name) => [k, name]))) {
                     const ft = byName.get(fname);
-                    if (!ft)
+                    if (!ft) {
+                        const slots = accessors.get(fname);
+                        if (slots)
+                            walks[k].push(...accessorEntry(fname, slots));
                         continue;
+                    }
                     const show = entry(concatAll([strLit(`${inspectKey(fname)}: `, loc), child(ft, get(fname, ft))], loc), boolLit(false, loc));
                     const present = lowerer.recordFieldPresent(v(), t.shapeId, fname, loc);
                     walks[k].push(present.kind === "recordHas"
@@ -1980,11 +2375,20 @@ function inspectHelper(lowerer, t, loc) {
             const keyT = isMap
                 ? t.key
                 : t.elem;
+            // Node's maxArrayLength bounds the entries shown; the tail counts the
+            // entries past the limit.
+            const limit = () => ({
+                kind: "libCall",
+                fn: "insp.maxArrayLength",
+                args: [],
+                type: F64,
+                loc,
+            });
             const hasMore = () => ({
                 kind: "bin",
                 op: ">",
                 left: n(),
-                right: numLit(100, loc),
+                right: limit(),
                 type: BOOL,
                 loc,
             });
@@ -2040,7 +2444,7 @@ function inspectHelper(lowerer, t, loc) {
                         },
                         {
                             kind: "if",
-                            cond: { kind: "bin", op: "===", left: c(), right: numLit(100, loc), type: BOOL, loc },
+                            cond: { kind: "bin", op: "===", left: c(), right: limit(), type: BOOL, loc },
                             then: [{ kind: "break", loc }],
                             else_: null,
                             loc,
@@ -2062,9 +2466,7 @@ function inspectHelper(lowerer, t, loc) {
                         entry({
                             kind: "libCall",
                             fn: "insp.moreItems",
-                            args: [
-                                { kind: "bin", op: "-", left: n(), right: numLit(100, loc), type: F64, loc },
-                            ],
+                            args: [{ kind: "bin", op: "-", left: n(), right: limit(), type: F64, loc }],
                             type: STRING,
                             loc,
                         }, boolLit(false, loc)),
@@ -2332,8 +2734,30 @@ function inspectHelper(lowerer, t, loc) {
         });
     }
     lowerer.liftedFns.push(fn);
+    if (t.kind === "record" && recordMayKeepSource(lowerer, t))
+        registerLinkedHelper(lowerer, fn, t.shapeId, "inspect");
     return name;
 }
+/** The rendering of `value` at recursion `r` and depth budget `d`: its
+ * type's inspect helper, or the checked-dynamic view's rendering when the
+ * type has no inspect lowering (a record with a function field). */
+export function inspectHelperCall(lowerer, value, r, d, loc) {
+    if (inspectSupport(lowerer, value.type, new Set(), { recursive: false }) !== null)
+        return {
+            kind: "libCall",
+            fn: "insp.dyn",
+            args: [{ kind: "dynFrom", value, liveRef: true, type: DYN, loc }, r, d],
+            type: STRING,
+            loc,
+        };
+    return {
+        kind: "call",
+        callee: inspectHelper(lowerer, value.type, loc),
+        args: [value, r, d],
+        type: STRING,
+        loc,
+    };
+}
 /* ── the console/format top-level value rendering ────────────────────── */
 /** Node's formatWithOptions REST-ARG rule over one statically-typed value
  * (console.log's non-format arguments, util.format's %s and trailing
@@ -2502,9 +2926,13 @@ function parseInspectOptions(lowerer, node, recursive, dir = false, atRunTime =
         breakLength: 80,
         compact: 3,
         sorted: false,
+        maxArrayLength: 100,
+        maxStringLength: 10000,
         runtime: false,
         depthKind: 0,
         customInspect: !dir,
+        showHidden: false,
+        getters: 0,
     };
     if (!node || (ts.isIdentifier(node) && node.text === "undefined"))
         return options;
@@ -2607,11 +3035,92 @@ function parseInspectOptions(lowerer, node, recursive, dir = false, atRunTime =
             }
             options.breakLength = n;
         }
+        else if (key === "maxStringLength") {
+            if (value.kind === ts.SyntaxKind.NullKeyword ||
+                (ts.isIdentifier(value) && value.text === "Infinity")) {
+                // Node resolves null to Infinity: every character shows.
+                options.maxStringLength = Infinity;
+            }
+            else {
+                const n = numeric();
+                if (n === null && atRunTime) {
+                    options.runtime = true;
+                    continue;
+                }
+                if (n === null || !Number.isInteger(n) || n < 0) {
+                    lowerer.noLowering(`${surface} with this maxStringLength option`, value, "maxStringLength must be a non-negative integer literal (or null)");
+                }
+                options.maxStringLength = n;
+            }
+        }
+        else if (key === "maxArrayLength") {
+            if (value.kind === ts.SyntaxKind.NullKeyword ||
+                (ts.isIdentifier(value) && value.text === "Infinity")) {
+                // Node resolves null to Infinity: every element shows.
+                options.maxArrayLength = Infinity;
+            }
+            else {
+                const n = numeric();
+                if (n === null && atRunTime) {
+                    options.runtime = true;
+                    continue;
+                }
+                if (n === null || !Number.isInteger(n) || n < 0) {
+                    lowerer.noLowering(`${surface} with this maxArrayLength option`, value, "maxArrayLength must be a non-negative integer literal (or null)");
+                }
+                options.maxArrayLength = n;
+            }
+        }
+        else if (key === "getters") {
+            // Node reads the option's truthiness first and compares it to true
+            // and to 'get'/'set' after: any other value keeps the labels.
+            const spelled = ts.isStringLiteral(value) ? value.text : null;
+            if (value.kind === ts.SyntaxKind.TrueKeyword)
+                options.getters = 1;
+            else if (value.kind === ts.SyntaxKind.FalseKeyword)
+                options.getters = 0;
+            else if (spelled === "get")
+                options.getters = 2;
+            else if (spelled === "set")
+                options.getters = 3;
+            else if (spelled !== null ||
+                numeric() !== null ||
+                value.kind === ts.SyntaxKind.NullKeyword ||
+                (ts.isIdentifier(value) && value.text === "undefined")) {
+                options.getters = 0;
+            }
+            else if (atRunTime) {
+                options.runtime = true;
+                continue;
+            }
+            else {
+                lowerer.noLowering(`${surface} with this getters option`, value, "getters must be true, false, 'get' or 'set'");
+            }
+        }
         else if (!dir &&
             key === "customInspect" &&
             (value.kind === ts.SyntaxKind.TrueKeyword || value.kind === ts.SyntaxKind.FalseKeyword)) {
             options.customInspect = value.kind === ts.SyntaxKind.TrueKeyword;
         }
+        else if (key === "showHidden") {
+            if (value.kind === ts.SyntaxKind.FalseKeyword) {
+                // util.inspect's and console.dir's default.
+            }
+            else if (dir) {
+                // console.dir's static entries carry no hidden keys; the option
+                // renders the value's checked-dynamic view instead (dirHidden).
+                if (value.kind !== ts.SyntaxKind.TrueKeyword) {
+                    lowerer.noLowering("console.dir with this showHidden option", value, "showHidden must be true or false");
+                }
+                options.showHidden = true;
+            }
+            else {
+                // The hidden entries (an array's [length], a typed array's extras,
+                // non-enumerable and symbol keys) render in the checked-dynamic
+                // walk, so the option takes the runtime reader.
+                options.runtime = true;
+            }
+        }
         else if (dir && key === "customInspect") {
             // console.dir's own default; only that value is lowered.
             if (value.kind !== ts.SyntaxKind.FalseKeyword) {
@@ -2619,49 +3128,111 @@ function parseInspectOptions(lowerer, node, recursive, dir = false, atRunTime =
             }
         }
         else {
-            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)"}`);
+            lowerer.noLowering(`${surface} with the '${key}' option`, prop, `the lowered options are depth (numeric literal or null), colors: false, showHidden (true or false), compact (false or a number), breakLength, maxArrayLength and maxStringLength (a non-negative integer or null), getters (true, false, 'get' or 'set'), ${dir ? "sorted (true or false), and customInspect: false" : "and sorted (true or false)"}`);
         }
     }
     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
- * however the render ends, an inspection refusal included. The render runs
- * in a lifted function, `(v) => { insp.layout(...); try { return render(v); }
- * finally { insp.layout(80, 3, false); } }`, since a seqExpr cannot hold the
- * try; `tag` names the render for the function's key. */
+/** A render under non-default breakLength/compact/sorted/maxArrayLength/
+ * maxStringLength/getters: the value is evaluated first, the options apply
+ * to this render only, and the defaults return however the render ends, an
+ * inspection refusal included. The render runs in a lifted function,
+ * `(v) => { set...; try { return render(v); } finally { restore...; } }`,
+ * since a seqExpr cannot hold the try; `tag` names the render for the
+ * function's key. */
 function withInspectLayout(lowerer, options, value, tag, render, loc) {
-    if (options.breakLength === 80 && options.compact === 3 && !options.sorted)
+    if (options.breakLength === 80 &&
+        options.compact === 3 &&
+        !options.sorted &&
+        options.maxArrayLength === 100 &&
+        options.maxStringLength === 10000 &&
+        options.getters === 0)
         return render(value);
-    const key = `layout:${tag}:${typeKey(value.type)}:${options.breakLength}:${options.compact}:${options.sorted}:${options.depth}`;
+    const key = `layout:${tag}:${typeKey(value.type)}:${options.breakLength}:${options.compact}:${options.sorted}:${options.maxArrayLength}:${options.maxStringLength}:${options.getters}:${options.depth}`;
     let name = lowerer.inspectHelpers.get(key);
     if (name === undefined) {
         name = keyedHelperName(lowerer, "%util.inspLayout", key);
         lowerer.inspectHelpers.set(key, name);
-        const layout = (breakLength, compact, sorted) => ({
+        const layout = (breakLength, compact, sorted, maxArrayLength) => ({
             kind: "exprStmt",
             expr: {
                 kind: "libCall",
                 fn: "insp.layout",
-                args: [numLit(breakLength, loc), numLit(compact, loc), boolLit(sorted, loc)],
+                args: [
+                    numLit(breakLength, loc),
+                    numLit(compact, loc),
+                    boolLit(sorted, loc),
+                    numLit(maxArrayLength, loc),
+                ],
                 type: VOID,
                 loc,
             },
             loc,
         });
+        const locals = [{ id: "v.0", name: "v", type: value.type, mutable: false }];
+        const apply = [
+            layout(options.breakLength, options.compact, options.sorted, options.maxArrayLength),
+        ];
+        const restore = [layout(80, 3, false, 100)];
+        if (options.maxStringLength !== 10000) {
+            // insp.maxStringLength answers the previous value.
+            const previous = `previous.${locals.length}`;
+            locals.push({ id: previous, name: "previous", type: F64, mutable: false });
+            const limit = (arg) => ({
+                kind: "libCall",
+                fn: "insp.maxStringLength",
+                args: [arg],
+                type: F64,
+                loc,
+            });
+            apply.push({
+                kind: "varDecl",
+                localId: previous,
+                init: limit(numLit(options.maxStringLength, loc)),
+                loc,
+            });
+            restore.unshift({
+                kind: "exprStmt",
+                expr: limit(varRef(previous, F64, loc)),
+                loc,
+            });
+        }
+        if (options.getters !== 0) {
+            // insp.getters answers the previous value.
+            const previous = `previous.${locals.length}`;
+            locals.push({ id: previous, name: "previous", type: F64, mutable: false });
+            const getters = (arg) => ({
+                kind: "libCall",
+                fn: "insp.getters",
+                args: [arg],
+                type: F64,
+                loc,
+            });
+            apply.push({
+                kind: "varDecl",
+                localId: previous,
+                init: getters(numLit(options.getters, loc)),
+                loc,
+            });
+            restore.unshift({
+                kind: "exprStmt",
+                expr: getters(varRef(previous, F64, loc)),
+                loc,
+            });
+        }
         lowerer.liftedFns.push({
             name,
             params: [{ localId: "v.0", name: "v", type: value.type }],
             returnType: STRING,
-            locals: [{ id: "v.0", name: "v", type: value.type, mutable: false }],
+            locals,
             body: [
-                layout(options.breakLength, options.compact, options.sorted),
+                ...apply,
                 {
                     kind: "tryCatch",
                     tryBody: [{ kind: "return", value: render(varRef("v.0", value.type, loc)), loc }],
                     catchBody: null,
                     catchLocalId: null,
-                    finallyBody: [layout(80, 3, false)],
+                    finallyBody: restore,
                     loc,
                 },
             ],
@@ -2788,14 +3359,18 @@ function lowerRuntimeInspect(lowerer, args, loc) {
  * walk that refuses a Buffer anywhere inside. */
 export function lowerInspectValue(lowerer, valueNode, optionsNode, loc, dir) {
     const surface = dir ? "console.dir" : "util.inspect";
+    // console.dir's showHidden renders the checked-dynamic walk with its
+    // hidden entries, so the baked forms below must not swallow the option.
+    const dirPreview = dir ? parseInspectOptions(lowerer, optionsNode, false, dir) : null;
     // Inline function/class literals and direct declared names render as
     // their baked forms; other function-typed values fence below.
     const direct = directCallableInspect(lowerer, valueNode, loc);
-    if (direct) {
+    if (direct && !dirPreview?.showHidden) {
         parseInspectOptions(lowerer, optionsNode, false, dir);
         return direct;
     }
-    if (ts.isArrowFunction(valueNode) || ts.isFunctionExpression(valueNode)) {
+    if ((ts.isArrowFunction(valueNode) || ts.isFunctionExpression(valueNode)) &&
+        !dirPreview?.showHidden) {
         parseInspectOptions(lowerer, optionsNode, false, dir);
         return strLit(valueNode.kind === ts.SyntaxKind.FunctionExpression &&
             valueNode.name
@@ -2811,6 +3386,23 @@ export function lowerInspectValue(lowerer, valueNode, optionsNode, loc, dir) {
         const name = jsFuncNameOf(valueNode);
         value = { kind: "dynFrom", value, type: DYN, ...(name !== null ? { fnName: name } : {}), loc };
     }
+    if (dirPreview?.showHidden) {
+        // console.dir's hidden entries (an array's [length], a typed array's
+        // extras, non-enumerable and symbol keys) render in the checked-dynamic
+        // walk with custom inspection off, dir's default; the value needs a
+        // checked view to reach it.
+        if (value.type.kind !== "dyn" && !lowerer.dynConvertible(value.type)) {
+            lowerer.noLowering(`console.dir with showHidden of '${lowerer.fmt(value.type)}' values`, valueNode, "the hidden entries render through the value's checked-dynamic view, which this type has no conversion to");
+        }
+        const input = value.type.kind === "dyn" ? value : { kind: "dynFrom", value, type: DYN, loc };
+        return withInspectLayout(lowerer, dirPreview, input, "dirHidden", (v) => ({
+            kind: "libCall",
+            fn: "console.dirHidden",
+            args: [v, numLit(dirPreview.depth, loc)],
+            type: STRING,
+            loc,
+        }), loc);
+    }
     if (value.type.kind === "bytes") {
         // One runtime representation serves Buffer AND Uint8Array; their
         // renderings differ (<Buffer aa> vs Uint8Array(1) [ 170 ]), so the
@@ -2852,36 +3444,60 @@ export function lowerInspectValue(lowerer, valueNode, optionsNode, loc, dir) {
     // unbounded depth given as Infinity or undefined, and customInspect:
     // false (console.dir's default), apply around the render when the value
     // can reach a custom method; the previous settings return afterwards.
-    const reachesCustom = typeReachesCustomInspect(lowerer, value.type) || typeReachesDyn(lowerer, value.type);
+    const reachesCustom = typeReachesCustomInspect(lowerer, value.type) ||
+        typeReachesDyn(lowerer, value.type) ||
+        typeReachesTextCodec(lowerer, value.type);
     const depthContext = reachesCustom && depth === Infinity && options.depthKind !== 1;
     const customContext = reachesCustom && !options.customInspect;
     if (depthContext || customContext) {
-        const stmts = [];
-        const restore = [];
-        const setting = (fn, arg, type) => {
-            const previous = lowerer.declareHiddenLocal("%inspectContext", type);
-            const call = (a) => ({ kind: "libCall", fn, args: [a], type, loc });
-            stmts.push({ kind: "varDecl", localId: previous.id, init: call(arg), loc });
-            restore.push({ kind: "exprStmt", expr: call(varRef(previous.id, type, loc)), loc });
-        };
-        if (customContext)
-            setting("insp.customInspect", boolLit(false, loc), BOOL);
-        if (depthContext)
-            setting("insp.depthKind", numLit(options.depthKind, loc), F64);
-        const text = lowerer.declareHiddenLocal("%inspectText", STRING);
-        stmts.push({
-            kind: "varDecl",
-            localId: text.id,
-            init: withInspectLayout(lowerer, options, value, "inspect", (input) => inspectExpr(lowerer, value.type, input, numLit(0, loc), numLit(depth, loc), loc), loc),
-            loc,
-        });
-        return {
-            kind: "seqExpr",
-            stmts: [...stmts, ...restore.reverse()],
-            result: varRef(text.id, STRING, loc),
-            type: STRING,
-            loc,
-        };
+        // The settings apply in a lifted function, `(v) => { set; try { return
+        // render(v); } finally { restore; } }`, so the previous ones return on
+        // every exit, an inspection refusal's throw included (a seqExpr cannot
+        // hold the try).
+        const key = `context:${typeKey(value.type)}:${customContext}:${depthContext}:${options.depthKind}:${options.breakLength}:${options.compact}:${options.sorted}:${options.maxArrayLength}:${options.maxStringLength}:${options.getters}:${depth}`;
+        let name = lowerer.inspectHelpers.get(key);
+        if (name === undefined) {
+            name = keyedHelperName(lowerer, "%util.inspContext", key);
+            lowerer.inspectHelpers.set(key, name);
+            const locals = [{ id: "v.0", name: "v", type: value.type, mutable: false }];
+            const stmts = [];
+            const restore = [];
+            const setting = (fn, arg, type) => {
+                const previous = `previous.${locals.length}`;
+                locals.push({ id: previous, name: "previous", type, mutable: false });
+                const call = (a) => ({ kind: "libCall", fn, args: [a], type, loc });
+                stmts.push({ kind: "varDecl", localId: previous, init: call(arg), loc });
+                restore.push({ kind: "exprStmt", expr: call(varRef(previous, type, loc)), loc });
+            };
+            if (customContext)
+                setting("insp.customInspect", boolLit(false, loc), BOOL);
+            if (depthContext)
+                setting("insp.depthKind", numLit(options.depthKind, loc), F64);
+            const input = varRef("v.0", value.type, loc);
+            stmts.push({
+                kind: "tryCatch",
+                tryBody: [
+                    {
+                        kind: "return",
+                        value: withInspectLayout(lowerer, options, input, "inspect", (v) => inspectExpr(lowerer, value.type, v, numLit(0, loc), numLit(depth, loc), loc), loc),
+                        loc,
+                    },
+                ],
+                catchBody: null,
+                catchLocalId: null,
+                finallyBody: restore.reverse(),
+                loc,
+            });
+            lowerer.liftedFns.push({
+                name,
+                params: [{ localId: "v.0", name: "v", type: value.type }],
+                returnType: STRING,
+                locals,
+                body: stmts,
+                loc,
+            });
+        }
+        return { kind: "call", callee: name, args: [value], type: STRING, loc };
     }
     if (dir && value.type.kind === "dyn") {
         return withInspectLayout(lowerer, options, value, "dirDyn", (input) => ({
@@ -2958,17 +3574,18 @@ function formatSValue(lowerer, node, value, depth, loc) {
     return inspectExpr(lowerer, t, value, numLit(0, loc), numLit(depth, loc), loc);
 }
 /** %O (depth 2) / %o (showHidden, depth 4) — inspect with the spec's
- * option deltas. A checked-dynamic argument renders through the runtime's
- * showHidden walk; static %o fences over arrays and nested dynamic values
- * (showHidden adds an array's hidden [length] entry, which the static
- * rendering has no lowering for). */
+ * option deltas. A showHidden argument that the checked-dynamic tree can
+ * hold (arrays — whose hidden [length] entry the static rendering has no
+ * lowering for — records, maps, sets, typed arrays and nested dynamic
+ * values) renders through the runtime's showHidden walk; the static
+ * rendering covers the default %O. */
 function formatOArg(lowerer, node, depth, loc) {
     const value = lowerer.lowerExpr(node);
-    if (depth === 4 && value.type.kind === "dyn") {
+    if (depth === 4 && (value.type.kind === "dyn" || lowerer.dynConvertible(value.type))) {
         return {
             kind: "libCall",
             fn: "insp.dynHidden",
-            args: [value, numLit(4, loc)],
+            args: [lowerer.coerceToExpected(value, DYN), numLit(4, loc)],
             type: STRING,
             loc,
         };
@@ -2984,6 +3601,8 @@ function formatOArg(lowerer, node, depth, loc) {
         lowerer.noLowering("util.format %o over values with [util.inspect.custom] methods", node, "%o passes showHidden to the methods — use %O");
     }
     if (depth === 4 && typeTreeHasHidden(lowerer, value.type, new Set())) {
+        // The static rendering below has no showHidden entries; the tree is
+        // not one the checked-dynamic walk can hold.
         lowerer.noLowering("util.format %o over arrays", node, "%o renders with showHidden (arrays gain a hidden [length] entry) — use %O for the default rendering, or pass the value as unknown");
     }
     return inspectExpr(lowerer, value.type, value, numLit(0, loc), numLit(depth, loc), loc);
@@ -3578,7 +4197,9 @@ export function heldFormatArgs(lowerer, argNodes, loc) {
         lowerer.noLowering(unconvertibleSurface(refused.type), refused.node, UNCONVERTIBLE_HINT);
     return { stmts, args, specifies, format, joinable };
 }
-/** Arrays anywhere in the tree — the %o (showHidden) gate. */
+/** Arrays, byte views or checked-dynamic values anywhere in the tree — the
+ * static %o (showHidden) gate, for the types the checked-dynamic walk
+ * cannot hold. */
 function typeTreeHasHidden(lowerer, t, visiting) {
     switch (t.kind) {
         case "array":