@scriptc/compiler 0.0.0 → 0.0.1

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

@@ -0,0 +1,1069 @@
+/* The node:util inspect/format lowering (a spoke module like
+ * lower-assert.ts): STATIC util.inspect — one synthesized traversal
+ * helper per argument type (the deepStrictEqual precedent, interned per
+ * typeKey), producing Node v24's byte-exact DEFAULT-options rendering —
+ * and util.format/formatWithOptions over compile-time format strings.
+ *
+ * The division of labor: the synthesized helpers own the TRAVERSAL the
+ * static type dictates (fields, elements, entries, union arms, depth
+ * bookkeeping); scr_inspect.c owns everything the type cannot know —
+ * scalar formatting (-0, the quoting ladder, string splitting), Buffer
+ * hex, and the layout engine (frames, break-length, grid grouping).
+ * Checked-dynamic values render ENTIRELY in the runtime (the dyn DOM
+ * carries its own shape); island `any` values render their scalar kinds
+ * and throw catchably on composites (the runtime tag is all there is).
+ *
+ * Options fence honestly, never approximate: depth takes any numeric
+ * literal (null/Infinity only over non-recursive types — a cycle would
+ * render forever), colors:false / compact:3 / breakLength:80 are the
+ * accepted no-op spellings, and everything else names itself in the
+ * diagnostic. Values whose rendering would need runtime type identity
+ * the static type lacks fence the same way: class hierarchies (a
+ * subclass's name and extra fields are dynamic), function values inside
+ * composites (no runtime name exists), Uint8Array-vs-Buffer ambiguity.
+ *
+ * Known-divergence corners (SEMANTICS.md): errors render the STACKLESS
+ * `[Name: message]` form (compiled binaries carry no JS stack), cyclic
+ * runtime data renders depth placeholders instead of `<ref *1>`/
+ * `[Circular *1]`, and record/class property order follows declaration
+ * order (SEMANTICS.md 36's existing stance). */
+import * as ts from "../ts7/adapter.js";
+import { isJsSourceFile } from "../program.js";
+import { BOOL, DYN, F64, RUNTIME_ERROR_CLASSES, STRING, shapeHasAccessorSlots, typeKey } from "../../ir/nodes.js";
+import { pureReemittable } from "./lower-exprs.js";
+/* ── IR construction shorthand ───────────────────────────────────────── */
+const str = (value, loc) => ({ kind: "strLit", value, type: STRING, loc });
+const num = (value, loc) => ({ kind: "numLit", value, type: F64, loc });
+const boolLit = (value, loc) => ({ kind: "boolLit", value, type: BOOL, loc });
+function concatAll(parts, loc) {
+    if (parts.length === 0)
+        return str("", loc);
+    let out = parts[0];
+    for (let i = 1; i < parts.length; i++) {
+        out = { kind: "strConcat", left: out, right: parts[i], type: STRING, loc };
+    }
+    return out;
+}
+/* ── property-name rendering (compile-time keys) ─────────────────────── */
+/** strEscape's quote ladder over a COMPILE-TIME string (record field
+ * names, format-string chunks never pass through here — only keys).
+ * Mirrors scr_inspect.c's insp_quote_into byte-for-byte. */
+export function inspectQuote(s) {
+    const hasSingle = s.includes("'");
+    const quote = !hasSingle ? "'" : !s.includes('"') ? '"' : !s.includes("`") && !s.includes("${") ? "`" : "'";
+    let body = "";
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (c < 0x20) {
+            const meta = ["\\b", "\\t", "\\n", undefined, "\\f", "\\r"][c - 8];
+            body += c >= 8 && c <= 13 && meta !== undefined ? meta : `\\x${c.toString(16).toUpperCase().padStart(2, "0")}`;
+        }
+        else if (c === 0x27 && quote === "'") {
+            body += "\\'";
+        }
+        else if (c === 0x5c) {
+            body += "\\\\";
+        }
+        else if (c >= 0x7f && c <= 0x9f) {
+            body += `\\x${c.toString(16).toUpperCase().padStart(2, "0")}`;
+        }
+        else if (c >= 0xd800 && c <= 0xdfff) {
+            const next = i + 1 < s.length ? s.charCodeAt(i + 1) : 0;
+            if (c <= 0xdbff && next >= 0xdc00 && next <= 0xdfff) {
+                body += s[i] + s[i + 1];
+                i++;
+            }
+            else {
+                body += `\\u${c.toString(16)}`;
+            }
+        }
+        else {
+            body += s[i];
+        }
+    }
+    return quote + body + quote;
+}
+/** formatProperty's key rendering: bare identifiers stay bare
+ * ('__proto__' excepted), everything else quotes. */
+function inspectKey(name) {
+    if (name === "__proto__")
+        return "['__proto__']";
+    return /^[a-zA-Z_][a-zA-Z_0-9]*$/.test(name) ? name : inspectQuote(name);
+}
+/* ── type support ────────────────────────────────────────────────────── */
+/** The error-hierarchy gate: `info`'s instances render through the
+ * runtime's name/message/code slots, which subclasses inherit — sound
+ * only when NO descendant adds declared fields (they would be own
+ * properties Node prints). */
+function errorRenderable(info) {
+    // The builtin classes' name/message/code live in runtime slots (the
+    // ScrError prefix insp.error reads), not IR fields; only USER-declared
+    // fields are own properties the runtime rendering would miss.
+    if (!info.builtinError && info.def.fields.length > 0)
+        return false;
+    return info.subclasses.every((s) => errorRenderable(s));
+}
+function isErrorClass(L, className) {
+    if (RUNTIME_ERROR_CLASSES.has(className))
+        return true;
+    return L.isSubclassOf(className, "%Error");
+}
+/** inspUnsupportedReason: the deepUnsupportedReason twin. Fences name the
+ * FIRST unsupported constituent. `visiting` terminates recursive shapes
+ * and records their existence (the depth-null gate). */
+function inspectSupport(L, t, visiting, out) {
+    switch (t.kind) {
+        case "f64":
+        case "string":
+        case "bool":
+        case "undefinedT":
+        case "nullT":
+        case "regex":
+        case "symbol":
+        case "dyn":
+        case "jsval":
+            return null;
+        case "array":
+            return inspectSupport(L, 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)";
+        case "record": {
+            if (visiting.has(t.shapeId)) {
+                out.recursive = true;
+                return null;
+            }
+            visiting.add(t.shapeId);
+            const shape = L.shapes.get(t.shapeId);
+            if (!shape)
+                return "this record shape has no inspect lowering";
+            // 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 (shape.indexValue !== undefined) {
+                // PURE index-signature shapes (Record<string, V> — no declared
+                // fields) render like the dyn DOM's objects: a runtime key walk
+                // (recordOvfKeys), each key through insp.key's bare-or-quoted
+                // ladder. Hybrids keep the fence — JS orders integer keys first
+                // ACROSS the declared and overflow stores, an interleave the
+                // declared-then-overflow walk cannot honor.
+                if (shape.fields.length > 0) {
+                    return "index-signature records with declared fields have no inspect lowering yet (JS interleaves integer keys across the declared and dynamic key sets)";
+                }
+                const why = inspectSupport(L, shape.indexValue, visiting, out);
+                if (why !== null)
+                    return why;
+                visiting.delete(t.shapeId);
+                return null;
+            }
+            for (const f of shape.fields) {
+                const why = inspectSupport(L, f.type, visiting, out);
+                if (why !== null)
+                    return why;
+            }
+            visiting.delete(t.shapeId);
+            return null;
+        }
+        case "map": {
+            const keyWhy = inspectSupport(L, t.key, visiting, out);
+            if (keyWhy !== null)
+                return keyWhy;
+            return inspectSupport(L, t.value, visiting, out);
+        }
+        case "set":
+            return inspectSupport(L, t.elem, visiting, out);
+        case "union": {
+            const def = L.unions.get(t.unionId);
+            if (!def)
+                return "this union has no inspect lowering";
+            if (visiting.has(t.unionId)) {
+                out.recursive = true;
+                return null;
+            }
+            visiting.add(t.unionId);
+            for (const arm of def.arms) {
+                const why = inspectSupport(L, arm, visiting, out);
+                if (why !== null)
+                    return why;
+            }
+            visiting.delete(t.unionId);
+            return null;
+        }
+        case "func":
+            return "function values have no inspect lowering (no runtime name exists — Node prints '[Function: name]'; pass the function's declared identifier directly to util.inspect for the baked form)";
+        case "object": {
+            const info = L.classes.get(t.className);
+            if (!info)
+                return `class '${t.className}' has no inspect lowering`;
+            if (isErrorClass(L, t.className)) {
+                return errorRenderable(info)
+                    ? null
+                    : "error subclasses with declared fields have no inspect lowering yet (the extra own properties are runtime-dynamic)";
+            }
+            if (info.subclasses.length > 0) {
+                return `inspect of '${t.className}' values is not lowered (the class has subclasses — the runtime value's constructor name and fields are dynamic)`;
+            }
+            if (visiting.has(t.className)) {
+                out.recursive = true;
+                return null;
+            }
+            visiting.add(t.className);
+            for (const f of info.def.fields) {
+                const why = inspectSupport(L, f.type, visiting, out);
+                if (why !== null)
+                    return why;
+            }
+            visiting.delete(t.className);
+            return null;
+        }
+        default:
+            return `'${L.fmt(t)}' values have no inspect lowering`;
+    }
+}
+/* ── the per-type rendering expression ───────────────────────────────── */
+/** True when a runtime value of `t` at index expr `v` answers
+ * `typeof v === 'number'` — the grid-grouping order flag. */
+function isNumberFlag(L, t, v, loc) {
+    if (t.kind === "f64")
+        return boolLit(true, loc);
+    if (t.kind === "union") {
+        const def = L.unions.get(t.unionId);
+        const tag = def ? def.arms.findIndex((a) => a.kind === "f64") : -1;
+        if (tag >= 0) {
+            return { kind: "unionIsTag", unionId: t.unionId, tag, negated: false, value: v(), type: BOOL, loc };
+        }
+    }
+    return boolLit(false, loc);
+}
+/** The rendering of one value of type `t` at runtime depth `recurse`
+ * with the depth budget `depth` — a direct scalar libCall or a call of
+ * the interned per-type helper. */
+function inspectExpr(L, t, value, recurse, depth, loc) {
+    switch (t.kind) {
+        case "f64":
+            return { kind: "libCall", fn: "insp.f64", args: [value], type: STRING, loc };
+        case "string":
+            return { kind: "libCall", fn: "insp.str", args: [value], type: STRING, loc };
+        case "bool":
+            return { kind: "toString", operand: value, type: STRING, loc };
+        case "undefinedT":
+            return str("undefined", loc);
+        case "nullT":
+            return str("null", loc);
+        case "regex":
+            return { kind: "libCall", fn: "insp.regex", args: [value], type: STRING, loc };
+        case "symbol":
+            // inspect(sym) IS Symbol.prototype.toString's text ("Symbol(foo)")
+            // — Node prints it unquoted at every depth.
+            return { kind: "libCall", fn: "sym.toString", args: [value], type: STRING, loc };
+        case "bytes":
+            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 "jsval":
+            return { kind: "libCall", fn: "insp.jsval", args: [value, recurse, depth], type: STRING, loc };
+        case "object":
+            if (isErrorClass(L, t.className)) {
+                return { kind: "libCall", fn: "insp.error", args: [value, recurse, depth], type: STRING, loc };
+            }
+            return { kind: "call", callee: inspectHelper(L, t, loc), args: [value, recurse, depth], type: STRING, loc };
+        default:
+            return { kind: "call", callee: inspectHelper(L, t, loc), args: [value, recurse, depth], type: STRING, loc };
+    }
+}
+/* ── 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
+ * order), the depth budget answers `[Array]`/`[Object]`/`[Map]`/
+ * `[Set]`/`[ClassName]`, and non-empty composites drive the runtime
+ * frame engine (begin / entry / end). Registered in the cache BEFORE the
+ * body builds, so recursive shapes call themselves by name. */
+function inspectHelper(L, t, loc) {
+    const key = `insp:${typeKey(t)}`;
+    const existing = L.inspectHelpers.get(key);
+    if (existing)
+        return existing;
+    const name = `%util.insp.${L.inspectHelpers.size}`;
+    L.inspectHelpers.set(key, name);
+    const ref = (localId, type) => ({ kind: "varRef", localId, type, loc });
+    const v = () => ref("v.0", t);
+    const r = () => ref("r.0", F64);
+    const d = () => ref("d.0", F64);
+    const rPlus1 = () => ({ kind: "bin", op: "+", left: r(), right: num(1, loc), type: F64, loc });
+    const ret = (value) => ({ kind: "return", value, loc });
+    const exprStmt = (expr) => ({ kind: "exprStmt", expr, loc });
+    const begin = () => exprStmt({ kind: "libCall", fn: "insp.begin", args: [rPlus1()], type: { kind: "void" }, loc });
+    const entry = (s, isNum) => exprStmt({ kind: "libCall", fn: "insp.entry", args: [s, isNum], type: { kind: "void" }, loc });
+    const end = (base, b0, b1, arrayExtras, trailingMore) => ({
+        kind: "libCall",
+        fn: "insp.end",
+        args: [base, b0, b1, rPlus1(), boolLit(arrayExtras, loc), trailingMore],
+        type: STRING,
+        loc,
+    });
+    /** if (r > d) return "<placeholder>"; */
+    const depthGate = (placeholder) => ({
+        kind: "if",
+        cond: { kind: "bin", op: ">", left: r(), right: d(), type: BOOL, loc },
+        then: [ret(str(placeholder, loc))],
+        else_: null,
+        loc,
+    });
+    const child = (elemT, value) => inspectExpr(L, elemT, value, rPlus1(), d(), loc);
+    const locals = [
+        { id: "v.0", name: "v", type: t, mutable: false },
+        { id: "r.0", name: "r", type: F64, mutable: false },
+        { id: "d.0", name: "d", type: F64, mutable: false },
+    ];
+    let body;
+    switch (t.kind) {
+        case "array": {
+            const len = () => ({ kind: "arrIntrinsic", method: "length", receiver: v(), args: [], type: F64, loc });
+            const at = (i) => ({ kind: "arrayGet", arr: v(), index: i, type: t.elem, loc });
+            locals.push({ id: "n.0", name: "n", type: F64, mutable: false }, { id: "s.0", name: "s", type: F64, mutable: false }, { id: "i.0", name: "i", type: F64, mutable: true });
+            const n = () => ref("n.0", F64);
+            const shown = () => ref("s.0", F64);
+            const i = () => ref("i.0", F64);
+            const hasMore = () => ({ kind: "bin", op: ">", left: n(), right: num(100, loc), type: BOOL, loc });
+            body = [
+                { kind: "varDecl", localId: "n.0", init: len(), loc },
+                {
+                    kind: "if",
+                    cond: { kind: "bin", op: "===", left: n(), right: num(0, loc), type: BOOL, loc },
+                    then: [ret(str("[]", loc))],
+                    else_: null,
+                    loc,
+                },
+                depthGate("[Array]"),
+                { kind: "varDecl", localId: "s.0", init: { kind: "ternary", cond: hasMore(), then: num(100, loc), else_: n(), type: F64, loc }, loc },
+                begin(),
+                {
+                    kind: "for",
+                    init: { kind: "varDecl", localId: "i.0", init: num(0, loc), loc },
+                    cond: { kind: "bin", op: "<", left: i(), right: shown(), type: BOOL, loc },
+                    update: { kind: "assign", localId: "i.0", value: { kind: "bin", op: "+", left: i(), right: num(1, loc), type: F64, loc }, loc },
+                    body: [entry(child(t.elem, at(i())), isNumberFlag(L, t.elem, () => at(i()), loc))],
+                    loc,
+                },
+                {
+                    kind: "if",
+                    cond: hasMore(),
+                    then: [
+                        entry({
+                            kind: "libCall",
+                            fn: "insp.moreItems",
+                            args: [{ kind: "bin", op: "-", left: n(), right: num(100, loc), type: F64, loc }],
+                            type: STRING,
+                            loc,
+                        }, isNumberFlag(L, t.elem, () => at(num(100, loc)), loc)),
+                    ],
+                    else_: null,
+                    loc,
+                },
+                ret(end(str("", loc), str("[", loc), str("]", loc), true, hasMore())),
+            ];
+            break;
+        }
+        case "record": {
+            const shape = L.shapes.get(t.shapeId);
+            if (!shape)
+                throw new Error(`inspect of unknown shape ${t.shapeId}`);
+            const get = (field, type) => ({ kind: "recordGet", obj: v(), shapeId: t.shapeId, field, type, loc });
+            if (shape.tuple) {
+                // Tuples ARE arrays to Node: bracket form, array-extras grouping.
+                if (shape.fields.length === 0) {
+                    body = [ret(str("[]", loc))];
+                    break;
+                }
+                body = [depthGate("[Array]"), begin()];
+                for (const f of shape.fields) {
+                    body.push(entry(child(f.type, get(f.name, f.type)), isNumberFlag(L, f.type, () => get(f.name, f.type), loc)));
+                }
+                body.push(ret(end(str("", loc), str("[", loc), str("]", loc), true, boolLit(false, loc))));
+                break;
+            }
+            if (shape.indexValue && shape.fields.length === 0) {
+                // The PURE index-signature shape (Record<string, V>): a runtime
+                // key walk in insertion order (recordOvfKeys — SEMANTICS.md 36's
+                // key-order stance), each key rendered through insp.key's
+                // bare-or-quoted ladder, each value read back through the keyed
+                // get. No 100-entry cap: Node truncates arrays and iterables,
+                // never plain objects.
+                const iv = shape.indexValue;
+                const ksT = { kind: "array", elem: STRING };
+                locals.push({ id: "ks.0", name: "ks", type: ksT, mutable: false }, { id: "n.0", name: "n", type: F64, mutable: false }, { id: "i.0", name: "i", type: F64, mutable: true }, { id: "k.0", name: "k", type: STRING, mutable: false });
+                const ks = () => ref("ks.0", ksT);
+                const n = () => ref("n.0", F64);
+                const i = () => ref("i.0", F64);
+                const k = () => ref("k.0", STRING);
+                const keyedRead = () => ({ kind: "recordKeyGet", obj: v(), shapeId: t.shapeId, key: k(), overflowOnly: true, type: iv, loc });
+                body = [
+                    { kind: "varDecl", localId: "ks.0", init: { kind: "recordOvfKeys", obj: v(), shapeId: t.shapeId, type: ksT, loc }, loc },
+                    { kind: "varDecl", localId: "n.0", init: { kind: "arrIntrinsic", method: "length", receiver: ks(), args: [], type: F64, loc }, loc },
+                    {
+                        kind: "if",
+                        cond: { kind: "bin", op: "===", left: n(), right: num(0, loc), type: BOOL, loc },
+                        then: [ret(str("{}", loc))],
+                        else_: null,
+                        loc,
+                    },
+                    depthGate("[Object]"),
+                    begin(),
+                    {
+                        kind: "for",
+                        init: { kind: "varDecl", localId: "i.0", init: num(0, loc), loc },
+                        cond: { kind: "bin", op: "<", left: i(), right: n(), type: BOOL, loc },
+                        update: { kind: "assign", localId: "i.0", value: { kind: "bin", op: "+", left: i(), right: num(1, loc), type: F64, loc }, loc },
+                        body: [
+                            { kind: "varDecl", localId: "k.0", init: { kind: "arrayGet", arr: ks(), index: i(), type: STRING, loc }, loc },
+                            entry(concatAll([
+                                { kind: "libCall", fn: "insp.key", args: [k()], type: STRING, loc },
+                                str(": ", loc),
+                                child(iv, keyedRead()),
+                            ], loc), boolLit(false, loc)),
+                        ],
+                        loc,
+                    },
+                    ret(end(str("", loc), str("{", loc), str("}", loc), false, boolLit(false, loc))),
+                ];
+                break;
+            }
+            if (shape.fields.length === 0) {
+                body = [ret(str("{}", loc))];
+                break;
+            }
+            // Object.keys' declared order (SEMANTICS.md 36's stance).
+            const order = shape.declaredOrder ?? shape.fields.map((f) => f.name);
+            const byName = new Map(shape.fields.map((f) => [f.name, f.type]));
+            body = [depthGate("[Object]"), begin()];
+            for (const fname of order) {
+                const ft = byName.get(fname);
+                if (!ft)
+                    continue;
+                body.push(entry(concatAll([str(`${inspectKey(fname)}: `, loc), child(ft, get(fname, ft))], loc), boolLit(false, loc)));
+            }
+            body.push(ret(end(str("", loc), str("{", loc), str("}", loc), false, boolLit(false, loc))));
+            break;
+        }
+        case "map":
+        case "set": {
+            const isMap = t.kind === "map";
+            const mi = (method, args, type) => isMap
+                ? { kind: "mapIntrinsic", method: method, receiver: v(), args, type, loc }
+                : { kind: "setIntrinsic", method: method, receiver: v(), args, type, loc };
+            locals.push({ id: "n.0", name: "n", type: F64, mutable: false }, { id: "i.0", name: "i", type: F64, mutable: true }, { id: "c.0", name: "c", type: F64, mutable: true });
+            const n = () => ref("n.0", F64);
+            const i = () => ref("i.0", F64);
+            const c = () => ref("c.0", F64);
+            const label = isMap ? "Map" : "Set";
+            const keyT = isMap ? t.key : t.elem;
+            const hasMore = () => ({ kind: "bin", op: ">", left: n(), right: num(100, loc), type: BOOL, loc });
+            const entryValue = () => {
+                const k = child(keyT, mi("iterKey", [i()], keyT));
+                if (!isMap)
+                    return k;
+                const valueT = t.value;
+                return concatAll([k, str(" => ", loc), child(valueT, mi("iterValue", [i()], valueT))], loc);
+            };
+            body = [
+                { kind: "varDecl", localId: "n.0", init: mi("size", [], F64), loc },
+                {
+                    kind: "if",
+                    cond: { kind: "bin", op: "===", left: n(), right: num(0, loc), type: BOOL, loc },
+                    then: [ret(str(`${label}(0) {}`, loc))],
+                    else_: null,
+                    loc,
+                },
+                depthGate(`[${label}]`),
+                begin(),
+                { kind: "varDecl", localId: "c.0", init: num(0, loc), loc },
+                {
+                    kind: "for",
+                    init: { kind: "varDecl", localId: "i.0", init: num(0, loc), loc },
+                    cond: { kind: "bin", op: "<", left: i(), right: mi("iterCount", [], F64), type: BOOL, loc },
+                    update: { kind: "assign", localId: "i.0", value: { kind: "bin", op: "+", left: i(), right: num(1, loc), type: F64, loc }, loc },
+                    body: [
+                        {
+                            kind: "if",
+                            cond: { kind: "unary", op: "!", operand: mi("iterLive", [i()], BOOL), type: BOOL, loc },
+                            then: [{ kind: "continue", loc }],
+                            else_: null,
+                            loc,
+                        },
+                        {
+                            kind: "if",
+                            cond: { kind: "bin", op: "===", left: c(), right: num(100, loc), type: BOOL, loc },
+                            then: [{ kind: "break", loc }],
+                            else_: null,
+                            loc,
+                        },
+                        entry(entryValue(), boolLit(false, loc)),
+                        { kind: "assign", localId: "c.0", value: { kind: "bin", op: "+", left: c(), right: num(1, loc), type: F64, loc }, loc },
+                    ],
+                    loc,
+                },
+                {
+                    kind: "if",
+                    cond: hasMore(),
+                    then: [
+                        entry({
+                            kind: "libCall",
+                            fn: "insp.moreItems",
+                            args: [{ kind: "bin", op: "-", left: n(), right: num(100, loc), type: F64, loc }],
+                            type: STRING,
+                            loc,
+                        }, boolLit(false, loc)),
+                    ],
+                    else_: null,
+                    loc,
+                },
+                ret(end(str("", loc), concatAll([str(`${label}(`, loc), { kind: "toString", operand: n(), type: STRING, loc }, str(") {", loc)], loc), str("}", loc), false, hasMore())),
+            ];
+            break;
+        }
+        case "union": {
+            const def = L.unions.get(t.unionId);
+            if (!def)
+                throw new Error(`inspect of unknown union ${t.unionId}`);
+            body = [];
+            def.arms.forEach((arm, tag) => {
+                // The union wrapper is not a nesting level: arms render at the
+                // SAME recursion depth (formatValue dispatches on the value).
+                const narrowed = { kind: "unionNarrow", unionId: t.unionId, tag, value: v(), type: arm, loc };
+                body.push({
+                    kind: "if",
+                    cond: { kind: "unionIsTag", unionId: t.unionId, tag, negated: false, value: v(), type: BOOL, loc },
+                    then: [ret(inspectExpr(L, arm, narrowed, r(), d(), loc))],
+                    else_: null,
+                    loc,
+                });
+            });
+            body.push(ret(str("", loc))); // unreachable: some arm always matches
+            break;
+        }
+        case "object": {
+            const info = L.classes.get(t.className);
+            if (!info)
+                throw new Error(`inspect of unknown class ${t.className}`);
+            // Node prints the class's OWN name — the declaration's, never the
+            // IR name's module qualifier (`m0.Timer` is the frontend's spelling
+            // for a class declared in a non-entry module).
+            const display = info.decl?.name?.text ?? info.def.name.replace(/^%/, "");
+            if (info.def.fields.length === 0) {
+                body = [ret(str(`${display} {}`, loc))];
+                break;
+            }
+            const get = (field, type) => ({ kind: "fieldGet", obj: v(), className: t.className, field, type, loc });
+            body = [depthGate(`[${display}]`), begin()];
+            // def.fields carries layout order: the base chain first, then own —
+            // exactly the own-property insertion order of a constructor that
+            // assigns in declaration order (SEMANTICS.md 36's stance). SYMBOL-
+            // keyed fields render LAST ([[OwnPropertyKeys]] lists all string
+            // keys before all symbol keys — Node's inspect order) and their
+            // layout name IS Node's key spelling (`Symbol(limit)`), printed
+            // verbatim, never quoted.
+            const symNames = new Set(info.symbolFields?.values() ?? []);
+            const ordered = [
+                ...info.def.fields.filter((f) => !symNames.has(f.name)),
+                ...info.def.fields.filter((f) => symNames.has(f.name)),
+            ];
+            for (const f of ordered) {
+                const key = symNames.has(f.name) ? f.name : inspectKey(f.name);
+                body.push(entry(concatAll([str(`${key}: `, loc), child(f.type, get(f.name, f.type))], loc), boolLit(false, loc)));
+            }
+            body.push(ret(end(str("", loc), str(`${display} {`, loc), str("}", loc), false, boolLit(false, loc))));
+            break;
+        }
+        default:
+            throw new Error(`inspect helper over unexpected type ${typeKey(t)}`);
+    }
+    L.liftedFns.push({
+        name,
+        params: [
+            { localId: "v.0", name: "v", type: t },
+            { localId: "r.0", name: "r", type: F64 },
+            { localId: "d.0", name: "d", type: F64 },
+        ],
+        returnType: STRING,
+        locals,
+        body,
+        loc,
+    });
+    return name;
+}
+/* ── 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. */
+function parseInspectOptions(L, node, recursive) {
+    if (!node || (ts.isIdentifier(node) && node.text === "undefined"))
+        return 2;
+    if (!ts.isObjectLiteralExpression(node)) {
+        L.noLowering("util.inspect 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) {
+        if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) {
+            L.noLowering("util.inspect options in this form", prop, "plain `key: literal` entries are the lowered options");
+        }
+        const key = prop.name.text;
+        const value = prop.initializer;
+        const numeric = () => {
+            if (ts.isNumericLiteral(value))
+                return Number(value.text);
+            if (ts.isPrefixUnaryExpression(value) && value.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(value.operand)) {
+                return -Number(value.operand.text);
+            }
+            return null;
+        };
+        if (key === "depth") {
+            if (value.kind === ts.SyntaxKind.NullKeyword || (ts.isIdentifier(value) && value.text === "Infinity")) {
+                if (recursive) {
+                    L.noLowering("util.inspect with unbounded depth over a recursive type", value, "cyclic runtime data would render forever — pass a numeric depth");
+                }
+                depth = Infinity;
+            }
+            else if (!(ts.isIdentifier(value) && value.text === "undefined")) {
+                const n = numeric();
+                if (n === null) {
+                    L.noLowering("util.inspect with a non-literal depth option", value, "depth must be a numeric literal (or null)");
+                }
+                depth = n;
+            }
+        }
+        else if (key === "colors") {
+            if (value.kind !== ts.SyntaxKind.FalseKeyword) {
+                L.noLowering("util.inspect with colors: true", value, "ANSI styling has no lowering — only colors: false");
+            }
+        }
+        else if (key === "compact") {
+            if (numeric() !== 3) {
+                L.noLowering("util.inspect with a non-default compact option", value, "only the default compact: 3 is lowered");
+            }
+        }
+        else if (key === "breakLength") {
+            if (numeric() !== 80) {
+                L.noLowering("util.inspect with a non-default breakLength option", value, "only the default breakLength: 80 is lowered");
+            }
+        }
+        else {
+            L.noLowering(`util.inspect with the '${key}' option`, prop, "the lowered options are depth (numeric literal or null), colors: false, compact: 3, and breakLength: 80");
+        }
+    }
+    return depth;
+}
+/** `util.inspect(fn)` / `util.inspect(Cls)` over a DIRECT identifier
+ * naming a declared function or class: the name is compile-time truth,
+ * so `[Function: name]` / `[class X extends Y]` bake as literals. Null
+ * when the identifier is not such a declaration. */
+function directCallableInspect(L, node, loc) {
+    if (!ts.isIdentifier(node))
+        return null;
+    const sym = L.resolveValueSymbol(node);
+    if (!sym)
+        return null;
+    const cls = L.classBySymbol.get(sym) ?? L.builtinErrorInfoOf(sym);
+    // A rebindable decorated name is not compile-time truth — the binding
+    // holds the decoration result; no literal folds.
+    if (cls?.classDecorators?.valueGlobalId !== undefined)
+        return null;
+    if (cls) {
+        if (cls.builtinError) {
+            // Node's Error constructors are native functions, not classes.
+            return str(`[Function: ${cls.def.name.replace(/^%/, "")}]`, loc);
+        }
+        const base = cls.base ? ` extends ${cls.base.def.name.replace(/^%/, "")}` : "";
+        return str(`[class ${cls.def.name}${base}]`, loc);
+    }
+    const decl = L.checker.declarationsOf(sym)[0];
+    if (!decl)
+        return null;
+    if (ts.isFunctionDeclaration(decl) && decl.name) {
+        return str(`[Function: ${decl.name.text}]`, loc);
+    }
+    if (ts.isVariableDeclaration(decl) &&
+        ts.isIdentifier(decl.name) &&
+        decl.initializer &&
+        (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
+        // JS name inference: the binding names the function value — unless
+        // the function expression carries its OWN name, which wins.
+        const own = ts.isFunctionExpression(decl.initializer) ? decl.initializer.name?.text : undefined;
+        return str(`[Function: ${own ?? decl.name.text}]`, loc);
+    }
+    return null;
+}
+/** util.inspect(value[, options]) — the spoke's inspect entry. */
+function lowerInspectCall(L, expr, loc) {
+    if (expr.arguments.length < 1 || expr.arguments.length > 2) {
+        L.noLowering(`util.inspect with ${expr.arguments.length} arguments`, expr, "the supported forms are inspect(value) and inspect(value, options)");
+    }
+    const valueNode = expr.arguments[0];
+    // Inline function/class literals and direct declared names render as
+    // their baked forms; other function-typed values fence below.
+    const direct = directCallableInspect(L, valueNode, loc);
+    if (direct) {
+        parseInspectOptions(L, expr.arguments[1], false);
+        return direct;
+    }
+    if (ts.isArrowFunction(valueNode) || ts.isFunctionExpression(valueNode)) {
+        parseInspectOptions(L, expr.arguments[1], false);
+        return str(valueNode.kind === ts.SyntaxKind.FunctionExpression && valueNode.name ? `[Function: ${valueNode.name.text}]` : "[Function (anonymous)]", loc);
+    }
+    const value = L.lowerExpr(valueNode);
+    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).
+        const tname = L.checker.typeToString(L.checker.getBaseTypeOfLiteralType(L.typeOf(valueNode)));
+        const isBuffer = tname === "Buffer" || tname === "NonSharedBuffer" || tname.startsWith("Buffer<") || tname.startsWith("NonSharedBuffer<");
+        if (value.type.elem !== "u8" || !isBuffer) {
+            L.noLowering(`util.inspect of '${tname}' values`, valueNode, "Buffer's <Buffer ..> form is the lowered typed-array rendering; other typed arrays fence");
+        }
+        const bufDepth = parseInspectOptions(L, expr.arguments[1], false);
+        void bufDepth; // Buffers render fully at any depth (custom inspect)
+        return inspectExpr(L, value.type, value, num(0, loc), num(2, loc), loc);
+    }
+    const walk = { recursive: false };
+    const reason = inspectSupport(L, value.type, new Set(), walk);
+    if (reason !== null) {
+        L.noLowering(`util.inspect of '${L.fmt(value.type)}' values`, valueNode, reason);
+    }
+    const depth = parseInspectOptions(L, expr.arguments[1], walk.recursive);
+    return inspectExpr(L, value.type, value, num(0, loc), num(depth, loc), loc);
+}
+/* ── util.format / util.formatWithOptions ────────────────────────────── */
+/** One argument as format's %s conversion (Node: numbers via
+ * formatNumber, strings verbatim, objects through inspect at the given
+ * depth). Null = fence with the given reason. */
+function formatSArg(L, node, depth, loc) {
+    const value = L.lowerExpr(node);
+    const t = value.type;
+    if (t.kind === "string")
+        return value;
+    if (t.kind === "f64")
+        return { kind: "libCall", fn: "insp.f64", args: [value], type: STRING, loc };
+    if (t.kind === "bool")
+        return { kind: "toString", operand: value, type: STRING, loc };
+    if (t.kind === "undefinedT")
+        return str("undefined", loc);
+    if (t.kind === "nullT")
+        return str("null", loc);
+    // %s of a symbol prints inspect's text ("Symbol(foo)") — String(sym)'s
+    // answer too, one runtime call either way.
+    if (t.kind === "symbol")
+        return { kind: "libCall", fn: "sym.toString", args: [value], type: STRING, loc };
+    if (t.kind === "dyn") {
+        return { kind: "libCall", fn: "insp.dynS", args: [value, num(depth, loc)], type: STRING, loc };
+    }
+    if (t.kind === "object" && !isErrorClass(L, t.className)) {
+        // hasBuiltInToString: a class with its OWN toString goes through
+        // String(arg) in Node, not inspect — call it explicitly instead.
+        for (let info = L.classes.get(t.className) ?? null; info; info = info.base) {
+            if (info.methods.has("toString")) {
+                L.noLowering("util.format %s over a class with its own toString", node, "Node calls the override (String(arg)) — call it explicitly");
+            }
+        }
+    }
+    if (t.kind === "bytes") {
+        L.noLowering(`util.format %s of typed-array values`, node, "pass util.inspect(buf) explicitly");
+    }
+    const walk = { recursive: false };
+    const reason = inspectSupport(L, t, new Set(), walk);
+    if (reason !== null)
+        L.noLowering(`util.format %s of '${L.fmt(t)}' values`, node, reason);
+    return inspectExpr(L, t, value, num(0, loc), num(depth, loc), loc);
+}
+/** %O (depth 2) / %o (showHidden, depth 4) — inspect with the spec's
+ * option deltas; %o fences over arrays (showHidden adds their hidden
+ * [length] entry, which has no lowering). */
+function formatOArg(L, node, depth, loc) {
+    const value = L.lowerExpr(node);
+    if (value.type.kind === "bytes") {
+        L.noLowering(`util.format %${depth === 4 ? "o" : "O"} of typed-array values`, node, "pass util.inspect(buf) explicitly");
+    }
+    const walk = { recursive: false };
+    const reason = inspectSupport(L, value.type, new Set(), walk);
+    if (reason !== null)
+        L.noLowering(`util.format %${depth === 4 ? "o" : "O"} of '${L.fmt(value.type)}' values`, node, reason);
+    if (depth === 4 && typeTreeHasArray(L, value.type, new Set())) {
+        L.noLowering("util.format %o over arrays", node, "%o renders with showHidden (arrays gain a hidden [length] entry) — use %O for the default rendering");
+    }
+    return inspectExpr(L, value.type, value, num(0, loc), num(depth, loc), 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(L, expr, loc, withOptions) {
+    const argNodes = [...expr.arguments];
+    if (withOptions) {
+        const opts = argNodes.shift();
+        if (!opts || !ts.isObjectLiteralExpression(opts) || opts.properties.length > 0) {
+            L.noLowering("util.formatWithOptions with a non-empty options literal", opts ?? expr, "only the empty literal {} (the defaults — exactly util.format) is lowered");
+        }
+    }
+    if (argNodes.length === 0)
+        return str("", loc);
+    const first = argNodes[0];
+    const firstIsLiteral = ts.isStringLiteral(first) || ts.isNoSubstitutionTemplateLiteral(first);
+    /** The rest-args tail: ` ` + (strings verbatim, everything else
+     * inspected at the default depth). */
+    const restArg = (node) => formatSArg(L, node, 2, loc);
+    if (!firstIsLiteral) {
+        const firstT = L.mapTypeOf(L.typeOf(first));
+        if (firstT?.kind === "string" && argNodes.length > 1) {
+            L.noLowering("util.format with a runtime format string and further arguments", first, "the %-substitution positions are runtime-dependent — use a string literal");
+        }
+        // No substitutions possible: every argument joins with spaces.
+        const parts = [];
+        for (let i = 0; i < argNodes.length; i++) {
+            if (i > 0)
+                parts.push(str(" ", loc));
+            parts.push(restArg(argNodes[i]));
+        }
+        return concatAll(parts, loc);
+    }
+    const fmt = first.text;
+    // Node's early return: a lone string first argument passes VERBATIM —
+    // no substitution runs, "%%" stays "%%".
+    if (argNodes.length === 1)
+        return str(fmt, loc);
+    const parts = [];
+    let a = 0; // the arg cursor over argNodes (0 = the format string)
+    let lastPos = 0;
+    const args = argNodes;
+    const convert = (spec, node) => {
+        switch (spec) {
+            case 115: // %s
+                return formatSArg(L, node, 0, loc);
+            case 100: {
+                // %d — Number(arg) formatted: numbers as-is, booleans 1/0;
+                // the full ToNumber string grammar has no static lowering.
+                const value = L.lowerExpr(node);
+                if (value.type.kind === "f64")
+                    return { kind: "libCall", fn: "insp.f64", args: [value], type: STRING, loc };
+                if (value.type.kind === "bool") {
+                    return {
+                        kind: "libCall",
+                        fn: "insp.f64",
+                        args: [{ kind: "ternary", cond: value, then: num(1, loc), else_: num(0, loc), type: F64, loc }],
+                        type: STRING,
+                        loc,
+                    };
+                }
+                // 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 DOM value throws the
+                // catchable TypeError where Node would print its ToNumber (NaN
+                // for objects) — loud, never a silent wrong answer (SEMANTICS.md).
+                if (value.type.kind === "dyn") {
+                    return {
+                        kind: "libCall",
+                        fn: "insp.f64",
+                        args: [{ kind: "dynCheck", value, type: F64, loc }],
+                        type: STRING,
+                        loc,
+                    };
+                }
+                L.noLowering(`util.format %d of '${L.fmt(value.type)}' values`, node, "numbers and booleans lower; ToNumber over other types has no static lowering");
+                break;
+            }
+            case 105: {
+                // %i — parseInt(ToString(arg)): the spec-exact composition.
+                const value = L.lowerExpr(node);
+                if (value.type.kind === "f64" || value.type.kind === "bool" || value.type.kind === "string") {
+                    const text = value.type.kind === "string" ? value : { kind: "toString", operand: value, type: STRING, loc };
+                    const parsed = { kind: "libCall", fn: "num.parseInt", args: [text, num(0, loc)], type: F64, loc };
+                    return { kind: "libCall", fn: "insp.f64", args: [parsed], type: STRING, loc };
+                }
+                L.noLowering(`util.format %i of '${L.fmt(value.type)}' values`, node);
+                break;
+            }
+            case 106: {
+                // %j — JSON.stringify; undefined-valued args print "undefined"
+                // (Node appends the non-string result of tryStringify).
+                const value = L.lowerExpr(node);
+                if (value.type.kind === "undefinedT")
+                    return str("undefined", loc);
+                // JSON.stringify(sym) is undefined in Node — %j prints the
+                // "undefined" text. Folding drops the operand, so only
+                // side-effect-free reads compose (the typeof-fold stance).
+                if (value.type.kind === "symbol") {
+                    if (!pureReemittable(value)) {
+                        L.noLowering(`util.format %j of computed symbol values`, node, "bind the symbol to a const first (the %j text is always \"undefined\")");
+                    }
+                    return str("undefined", loc);
+                }
+                // A checked-dynamic argument (`console.error('headers: %j',
+                // headers)` — the suite's http logging idiom): the runtime DOM
+                // walk stringifies JS-exactly (root undefined/function prints
+                // "undefined"; a handle in the tree throws the loud fence).
+                if (value.type.kind === "dyn") {
+                    return { kind: "libCall", fn: "insp.jsonDyn", args: [value], type: STRING, loc };
+                }
+                if (!L.jsonSafe(value.type)) {
+                    L.noLowering(`util.format %j of '${L.fmt(value.type)}' values`, node, "only JSON-safe static types lower");
+                }
+                return { kind: "jsonStringify", value, type: STRING, loc };
+            }
+            case 79: // %O — inspect at the defaults
+                return formatOArg(L, node, 2, loc);
+            case 111: // %o — showHidden semantics; depth 4
+                return formatOArg(L, node, 4, loc);
+        }
+        throw new Error("unreachable format spec");
+    };
+    for (let i = 0; i < fmt.length - 1; i++) {
+        if (fmt.charCodeAt(i) === 37 /* % */) {
+            const nextChar = fmt.charCodeAt(++i);
+            if (a + 1 !== args.length) {
+                switch (nextChar) {
+                    case 115: // s
+                    case 106: // j
+                    case 100: // d
+                    case 79: // O
+                    case 111: // o
+                    case 105: { // i
+                        const node = args[++a];
+                        if (lastPos !== i - 1)
+                            parts.push(str(fmt.slice(lastPos, i - 1), loc));
+                        parts.push(convert(nextChar, node));
+                        lastPos = i + 1;
+                        continue;
+                    }
+                    case 102: // f — parseFloat's full grammar has no static lowering
+                        L.noLowering("util.format %f", expr, "parseFloat has no static lowering (it runs with --dynamic)");
+                        break;
+                    case 99: // c — consumes its argument, contributes nothing
+                        a += 1;
+                        if (lastPos !== i - 1)
+                            parts.push(str(fmt.slice(lastPos, i - 1), loc));
+                        lastPos = i + 1;
+                        continue;
+                    case 37: // %%
+                        parts.push(str(fmt.slice(lastPos, i), loc));
+                        lastPos = i + 1;
+                        continue;
+                    default:
+                        continue;
+                }
+            }
+            else if (nextChar === 37) {
+                parts.push(str(fmt.slice(lastPos, i), loc));
+                lastPos = i + 1;
+            }
+        }
+    }
+    if (lastPos !== 0) {
+        a++;
+        if (lastPos < fmt.length)
+            parts.push(str(fmt.slice(lastPos), loc));
+    }
+    else {
+        // No substitution touched the format string: it joins verbatim, and
+        // the cursor advances past it.
+        parts.push(str(fmt, loc));
+        a++;
+    }
+    for (; a < args.length; a++) {
+        parts.push(str(" ", loc));
+        parts.push(restArg(args[a]));
+    }
+    return concatAll(parts, loc);
+}
+/** Arrays anywhere in the tree — the %o (showHidden) gate. */
+function typeTreeHasArray(L, t, visiting) {
+    switch (t.kind) {
+        case "array":
+            return true;
+        case "record": {
+            if (visiting.has(t.shapeId))
+                return false;
+            visiting.add(t.shapeId);
+            const shape = L.shapes.get(t.shapeId);
+            if (shape?.tuple)
+                return true;
+            return (shape?.fields ?? []).some((f) => typeTreeHasArray(L, f.type, visiting));
+        }
+        case "map":
+            return typeTreeHasArray(L, t.key, visiting) || typeTreeHasArray(L, t.value, visiting);
+        case "set":
+            return typeTreeHasArray(L, t.elem, visiting);
+        case "union": {
+            if (visiting.has(t.unionId))
+                return false;
+            visiting.add(t.unionId);
+            return (L.unions.get(t.unionId)?.arms ?? []).some((a) => typeTreeHasArray(L, a, visiting));
+        }
+        case "object": {
+            if (visiting.has(t.className))
+                return false;
+            visiting.add(t.className);
+            return (L.classes.get(t.className)?.def.fields ?? []).some((f) => typeTreeHasArray(L, f.type, visiting));
+        }
+        case "bytes":
+            return true;
+        default:
+            return false;
+    }
+}
+/* ── the module dispatch ─────────────────────────────────────────────── */
+/** The spoke's entry, called from both the named-import and namespace/
+ * default-import call paths. Null for other modules and members (the
+ * module tables' fence takes over). */
+export function lowerUtilModuleCall(L, expr, bi, loc) {
+    if (bi.module !== "util")
+        return null;
+    switch (bi.member) {
+        case "inspect":
+            return lowerInspectCall(L, expr, loc);
+        case "format":
+            return lowerFormatCall(L, expr, loc, false);
+        case "formatWithOptions":
+            return lowerFormatCall(L, expr, loc, true);
+        case "getCallSites":
+            return lowerGetCallSitesCall(L, expr, loc);
+        default:
+            return null;
+    }
+}
+/** util.getCallSites() in a JS source: compiled binaries keep no runtime
+ * call stacks, so the honest STATIC answer is a fixed-shape placeholder —
+ * a fresh DOM array of three call-site records whose scriptName is the
+ * CALL SITE's own file (compile-time-knowable) and whose line/column are
+ * 0 (SEMANTICS.md; the fields exist so consumers like test/common's
+ * mustNotCall — `callSite.scriptName`:`callSite.lineNumber` in the
+ * failure text — read a printable value instead of throwing). Argument
+ * forms and TypeScript keep the SC2020 fence: a typed consumer asserting
+ * real frames must fail loudly at compile time, not read placeholders. */
+function lowerGetCallSitesCall(L, expr, loc) {
+    if (expr.arguments.length !== 0)
+        return null;
+    if (!isJsSourceFile(expr.getSourceFile()))
+        return null;
+    const frame = () => {
+        const field = (name, value) => ({
+            key: { kind: "strLit", value: name, type: STRING, loc },
+            value: { kind: "dynFrom", value, type: DYN, loc },
+        });
+        return {
+            kind: "dynObjLit",
+            fields: [
+                field("functionName", { kind: "strLit", value: "", type: STRING, loc }),
+                field("scriptName", { kind: "strLit", value: expr.getSourceFile().fileName, type: STRING, loc }),
+                field("scriptId", { kind: "strLit", value: "0", type: STRING, loc }),
+                field("lineNumber", { kind: "numLit", value: 0, type: F64, loc }),
+                field("column", { kind: "numLit", value: 0, type: F64, loc }),
+            ],
+            type: DYN,
+            loc,
+        };
+    };
+    return { kind: "dynArrLit", elems: [frame(), frame(), frame()], type: DYN, loc };
+}
+//# sourceMappingURL=lower-inspect.js.map