@scriptc/compiler 0.2.4 → 0.2.5

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

@@ -1,3 +1,4 @@
+import { dynUndefinedExpr, boolLit, numLit, strLit, varRef } from "../../ir/build.js";
 import { InternalCompilerError } from "../../errors.js";
 /* The node:util inspect/format lowering (a spoke module like
  * lower-assert.ts): STATIC util.inspect — one synthesized traversal
@@ -37,9 +38,8 @@ import { InternalCompilerError } from "../../errors.js";
 import * as ts from "../ts7/adapter.js";
 import { unsignedHex } from "../../format-integer.js";
 import { isJsSourceFile } from "../program.js";
-import { BOOL, DYN, F64, RUNTIME_ERROR_CLASSES, STRING, UNDEFINED_T, canConvertToDyn, canDynCheckTo, recordTextCodecClass, shapeHasAccessorSlots, typeKey } from "../../ir/ir.js";
+import { BOOL, DYN, F64, RUNTIME_ERROR_CLASSES, STRING, UNDEFINED_T, canConvertToDyn, canDynCheckTo, recordTextCodecClass, shapeHasAccessorSlots, typeKey, } from "../../ir/ir.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
-import { boolLit, numLit, strLit, varRef } from "../../ir/build.js";
 import { symbolFieldDisplayName } from "./symbol-fields.js";
 import { lowerSystemErrorMap } from "./lower-system-errors.js";
 /* ── IR construction shorthand ───────────────────────────────────────── */
@@ -58,13 +58,22 @@ function concatAll(parts, loc) {
  * Mirrors scr_inspect.c's insp_quote_into byte-for-byte. */
 function inspectQuote(s) {
     const hasSingle = s.includes("'");
-    const quote = !hasSingle ? "'" : !s.includes('"') ? '"' : !s.includes("`") && !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${unsignedHex(c).toUpperCase().padStart(2, "0")}`;
+            body +=
+                c >= 8 && c <= 13 && meta !== undefined
+                    ? meta
+                    : `\\x${unsignedHex(c).toUpperCase().padStart(2, "0")}`;
         }
         else if (c === 0x27 && quote === "'") {
             body += "\\'";
@@ -251,7 +260,15 @@ function isNumberFlag(lowerer, t, v, loc) {
         const def = lowerer.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 {
+                kind: "unionIsTag",
+                unionId: t.unionId,
+                tag,
+                negated: false,
+                value: v(),
+                type: BOOL,
+                loc,
+            };
         }
     }
     return boolLit(false, loc);
@@ -284,14 +301,38 @@ export function inspectExpr(lowerer, t, value, recurse, depth, 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 };
+            return {
+                kind: "libCall",
+                fn: "insp.jsval",
+                args: [value, recurse, depth],
+                type: STRING,
+                loc,
+            };
         case "object":
             if (isErrorClass(lowerer, t.className)) {
-                return { kind: "libCall", fn: "insp.error", args: [value, recurse, depth], type: STRING, loc };
+                return {
+                    kind: "libCall",
+                    fn: "insp.error",
+                    args: [value, recurse, depth],
+                    type: STRING,
+                    loc,
+                };
             }
-            return { kind: "call", callee: inspectHelper(lowerer, t, loc), args: [value, recurse, depth], type: STRING, loc };
+            return {
+                kind: "call",
+                callee: inspectHelper(lowerer, t, loc),
+                args: [value, recurse, depth],
+                type: STRING,
+                loc,
+            };
         default:
-            return { kind: "call", callee: inspectHelper(lowerer, t, loc), args: [value, recurse, depth], type: STRING, loc };
+            return {
+                kind: "call",
+                callee: inspectHelper(lowerer, t, loc),
+                args: [value, recurse, depth],
+                type: STRING,
+                loc,
+            };
     }
 }
 /** True when a VALUE of `t` can contain itself — t's type graph reaches t
@@ -368,7 +409,14 @@ function inspectHelper(lowerer, t, loc) {
     const v = () => varRef("v.0", t, loc);
     const r = () => varRef("r.0", F64, loc);
     const d = () => varRef("d.0", F64, loc);
-    const rPlus1 = () => ({ kind: "bin", op: "+", left: r(), right: numLit(1, loc), type: F64, loc });
+    const rPlus1 = () => ({
+        kind: "bin",
+        op: "+",
+        left: r(),
+        right: numLit(1, loc),
+        type: F64,
+        loc,
+    });
     const ret = (value) => ({ kind: "return", value, loc });
     const exprStmt = (expr) => ({ kind: "exprStmt", expr, loc });
     // CYCLE-CAPABLE composites (typeReachesItself) run Node's circular
@@ -382,7 +430,15 @@ function inspectHelper(lowerer, t, loc) {
     const begin = () => [
         exprStmt({ kind: "libCall", fn: "insp.begin", args: [rPlus1()], type: { kind: "void" }, loc }),
         ...(onCycle
-            ? [exprStmt({ kind: "libCall", fn: "insp.seenPush", args: [v()], type: { kind: "void" }, loc })]
+            ? [
+                exprStmt({
+                    kind: "libCall",
+                    fn: "insp.seenPush",
+                    args: [v()],
+                    type: { kind: "void" },
+                    loc,
+                }),
+            ]
             : []),
     ];
     const entry = (s, isNum) => exprStmt({ kind: "libCall", fn: "insp.entry", args: [s, isNum], type: { kind: "void" }, loc });
@@ -416,12 +472,52 @@ function inspectHelper(lowerer, t, loc) {
     let rebuildShapeOrderBody = null;
     switch (t.kind) {
         case "array": {
-            const at = (index) => ({ kind: "arrayGet", arr: v(), index, type: t.elem, loc });
-            const state = (index) => ({ kind: "arrayState", arr: v(), index, type: F64, loc });
-            const eq = (left, right) => ({ kind: "bin", op: "===", left, right, type: BOOL, loc });
-            const lt = (left, right) => ({ kind: "bin", op: "<", left, right, type: BOOL, loc });
-            const add = (left, right) => ({ kind: "bin", op: "+", left, right, type: F64, loc });
-            const sub = (left, right) => ({ kind: "bin", op: "-", left, right, type: F64, loc });
+            const at = (index) => ({
+                kind: "arrayGet",
+                arr: v(),
+                index,
+                type: t.elem,
+                loc,
+            });
+            const state = (index) => ({
+                kind: "arrayState",
+                arr: v(),
+                index,
+                type: F64,
+                loc,
+            });
+            const eq = (left, right) => ({
+                kind: "bin",
+                op: "===",
+                left,
+                right,
+                type: BOOL,
+                loc,
+            });
+            const lt = (left, right) => ({
+                kind: "bin",
+                op: "<",
+                left,
+                right,
+                type: BOOL,
+                loc,
+            });
+            const add = (left, right) => ({
+                kind: "bin",
+                op: "+",
+                left,
+                right,
+                type: F64,
+                loc,
+            });
+            const sub = (left, right) => ({
+                kind: "bin",
+                op: "-",
+                left,
+                right,
+                type: F64,
+                loc,
+            });
             locals.push({ id: "n.0", name: "n", type: F64, mutable: false }, { id: "s.0", name: "s", type: F64, mutable: true }, { id: "i.0", name: "i", type: F64, mutable: true }, { id: "next.0", name: "next", type: F64, mutable: false });
             const n = () => varRef("n.0", F64, loc);
             const shown = () => varRef("s.0", F64, loc);
@@ -429,48 +525,107 @@ function inspectHelper(lowerer, t, loc) {
             const next = () => varRef("next.0", F64, loc);
             const hasMore = () => lt(i(), n());
             const isNumber = () => ({
-                kind: "ternary", cond: eq(state(i()), numLit(1, loc)),
+                kind: "ternary",
+                cond: eq(state(i()), numLit(1, loc)),
                 then: isNumberFlag(lowerer, t.elem, () => at(i()), loc),
-                else_: boolLit(false, loc), type: BOOL, loc,
+                else_: boolLit(false, loc),
+                type: BOOL,
+                loc,
             });
             const holes = () => ({
-                kind: "strConcat", left: strLit("<", loc),
+                kind: "strConcat",
+                left: strLit("<", loc),
                 right: {
-                    kind: "strConcat", left: { kind: "toString", operand: sub(next(), i()), type: STRING, loc },
-                    right: { kind: "ternary", cond: eq(sub(next(), i()), numLit(1, loc)), then: strLit(" empty item>", loc), else_: strLit(" empty items>", loc), type: STRING, loc },
-                    type: STRING, loc,
-                }, type: STRING, loc,
+                    kind: "strConcat",
+                    left: { kind: "toString", operand: sub(next(), i()), type: STRING, loc },
+                    right: {
+                        kind: "ternary",
+                        cond: eq(sub(next(), i()), numLit(1, loc)),
+                        then: strLit(" empty item>", loc),
+                        else_: strLit(" empty items>", loc),
+                        type: STRING,
+                        loc,
+                    },
+                    type: STRING,
+                    loc,
+                },
+                type: STRING,
+                loc,
             });
             body = [
-                { kind: "varDecl", localId: "n.0", init: { kind: "arrIntrinsic", method: "length", receiver: v(), args: [], type: F64, loc }, loc },
-                { kind: "if", cond: eq(n(), numLit(0, loc)), then: [ret(strLit("[]", loc))], else_: null, loc },
+                {
+                    kind: "varDecl",
+                    localId: "n.0",
+                    init: { kind: "arrIntrinsic", method: "length", receiver: v(), args: [], type: F64, loc },
+                    loc,
+                },
+                {
+                    kind: "if",
+                    cond: eq(n(), numLit(0, loc)),
+                    then: [ret(strLit("[]", loc))],
+                    else_: null,
+                    loc,
+                },
                 depthGate("[Array]"),
                 { kind: "varDecl", localId: "s.0", init: numLit(0, loc), loc },
                 { kind: "varDecl", localId: "i.0", init: numLit(0, loc), loc },
                 ...begin(),
                 {
                     kind: "while",
-                    cond: { kind: "logical", op: "&&", left: hasMore(), right: lt(shown(), numLit(100, loc)), type: BOOL, loc },
+                    cond: {
+                        kind: "logical",
+                        op: "&&",
+                        left: hasMore(),
+                        right: lt(shown(), numLit(100, loc)),
+                        type: BOOL,
+                        loc,
+                    },
                     body: [
                         {
-                            kind: "if", cond: eq(state(i()), numLit(0, loc)),
+                            kind: "if",
+                            cond: eq(state(i()), numLit(0, loc)),
                             then: [
-                                { kind: "varDecl", localId: "next.0", init: { kind: "arrIntrinsic", method: "nextPresent", receiver: v(), args: [i()], type: F64, loc }, loc },
+                                {
+                                    kind: "varDecl",
+                                    localId: "next.0",
+                                    init: {
+                                        kind: "arrIntrinsic",
+                                        method: "nextPresent",
+                                        receiver: v(),
+                                        args: [i()],
+                                        type: F64,
+                                        loc,
+                                    },
+                                    loc,
+                                },
                                 entry(holes(), boolLit(false, loc)),
                                 { kind: "assign", localId: "i.0", value: next(), loc },
                             ],
                             else_: [
-                                entry({ kind: "ternary", cond: eq(state(i()), numLit(1, loc)), then: child(t.elem, at(i())), else_: strLit("undefined", loc), type: STRING, loc }, isNumber()),
+                                entry({
+                                    kind: "ternary",
+                                    cond: eq(state(i()), numLit(1, loc)),
+                                    then: child(t.elem, at(i())),
+                                    else_: strLit("undefined", loc),
+                                    type: STRING,
+                                    loc,
+                                }, isNumber()),
                                 { kind: "assign", localId: "i.0", value: add(i(), numLit(1, loc)), loc },
-                            ], loc,
+                            ],
+                            loc,
                         },
                         { kind: "assign", localId: "s.0", value: add(shown(), numLit(1, loc)), loc },
-                    ], loc,
+                    ],
+                    loc,
                 },
                 {
-                    kind: "if", cond: hasMore(),
-                    then: [entry({ kind: "libCall", fn: "insp.moreItems", args: [sub(n(), i())], type: STRING, loc }, isNumber())],
-                    else_: null, loc,
+                    kind: "if",
+                    cond: hasMore(),
+                    then: [
+                        entry({ kind: "libCall", fn: "insp.moreItems", args: [sub(n(), i())], type: STRING, loc }, isNumber()),
+                    ],
+                    else_: null,
+                    loc,
                 },
                 ret(end(strLit("", loc), strLit("[", loc), strLit("]", loc), true, hasMore())),
             ];
@@ -480,7 +635,14 @@ function inspectHelper(lowerer, t, loc) {
             const shape = lowerer.shapes.get(t.shapeId);
             if (!shape)
                 throw new InternalCompilerError(`inspect of unknown shape ${t.shapeId}`);
-            const get = (field, type) => ({ kind: "recordGet", obj: v(), shapeId: t.shapeId, field, type, loc });
+            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) {
@@ -508,10 +670,35 @@ function inspectHelper(lowerer, t, loc) {
                 const n = () => varRef("n.0", F64, loc);
                 const i = () => varRef("i.0", F64, loc);
                 const k = () => varRef("k.0", STRING, loc);
-                const keyedRead = () => ({ kind: "recordKeyGet", obj: v(), shapeId: t.shapeId, key: k(), overflowOnly: true, type: iv, loc });
+                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: "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: numLit(0, loc), type: BOOL, loc },
@@ -525,9 +712,19 @@ function inspectHelper(lowerer, t, loc) {
                         kind: "for",
                         init: { kind: "varDecl", localId: "i.0", init: numLit(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: numLit(1, loc), type: F64, loc }, loc },
+                        update: {
+                            kind: "assign",
+                            localId: "i.0",
+                            value: { kind: "bin", op: "+", left: i(), right: numLit(1, loc), type: F64, loc },
+                            loc,
+                        },
                         body: [
-                            { kind: "varDecl", localId: "k.0", init: { kind: "arrayGet", arr: ks(), index: i(), type: STRING, loc }, loc },
+                            {
+                                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 },
                                 strLit(": ", loc),
@@ -567,15 +764,38 @@ function inspectHelper(lowerer, t, loc) {
         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 };
+                ? {
+                    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 = () => varRef("n.0", F64, loc);
             const i = () => varRef("i.0", F64, loc);
             const c = () => varRef("c.0", F64, loc);
             const label = isMap ? "Map" : "Set";
-            const keyT = isMap ? t.key : t.elem;
-            const hasMore = () => ({ kind: "bin", op: ">", left: n(), right: numLit(100, loc), type: BOOL, loc });
+            const keyT = isMap
+                ? t.key
+                : t.elem;
+            const hasMore = () => ({
+                kind: "bin",
+                op: ">",
+                left: n(),
+                right: numLit(100, loc),
+                type: BOOL,
+                loc,
+            });
             const entryValue = () => {
                 const k = child(keyT, mi("iterKey", [i()], keyT));
                 if (!isMap)
@@ -598,12 +818,30 @@ function inspectHelper(lowerer, t, loc) {
                 {
                     kind: "for",
                     init: { kind: "varDecl", localId: "i.0", init: numLit(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: numLit(1, loc), type: F64, 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: numLit(1, loc), type: F64, loc },
+                        loc,
+                    },
                     body: [
                         {
                             kind: "if",
-                            cond: { kind: "unary", op: "!", operand: mi("iterLive", [i()], BOOL), type: BOOL, loc },
+                            cond: {
+                                kind: "unary",
+                                op: "!",
+                                operand: mi("iterLive", [i()], BOOL),
+                                type: BOOL,
+                                loc,
+                            },
                             then: [{ kind: "continue", loc }],
                             else_: null,
                             loc,
@@ -616,7 +854,12 @@ function inspectHelper(lowerer, t, loc) {
                             loc,
                         },
                         entry(entryValue(), boolLit(false, loc)),
-                        { kind: "assign", localId: "c.0", value: { kind: "bin", op: "+", left: c(), right: numLit(1, loc), type: F64, loc }, loc },
+                        {
+                            kind: "assign",
+                            localId: "c.0",
+                            value: { kind: "bin", op: "+", left: c(), right: numLit(1, loc), type: F64, loc },
+                            loc,
+                        },
                     ],
                     loc,
                 },
@@ -627,7 +870,9 @@ 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: numLit(100, loc), type: F64, loc },
+                            ],
                             type: STRING,
                             loc,
                         }, boolLit(false, loc)),
@@ -635,7 +880,11 @@ function inspectHelper(lowerer, t, loc) {
                     else_: null,
                     loc,
                 },
-                ret(end(strLit("", loc), concatAll([strLit(`${label}(`, loc), { kind: "toString", operand: n(), type: STRING, loc }, strLit(") {", loc)], loc), strLit("}", loc), false, hasMore())),
+                ret(end(strLit("", loc), concatAll([
+                    strLit(`${label}(`, loc),
+                    { kind: "toString", operand: n(), type: STRING, loc },
+                    strLit(") {", loc),
+                ], loc), strLit("}", loc), false, hasMore())),
             ];
             break;
         }
@@ -647,10 +896,25 @@ function inspectHelper(lowerer, t, loc) {
             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 };
+                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 },
+                    cond: {
+                        kind: "unionIsTag",
+                        unionId: t.unionId,
+                        tag,
+                        negated: false,
+                        value: v(),
+                        type: BOOL,
+                        loc,
+                    },
                     then: [ret(inspectExpr(lowerer, arm, narrowed, r(), d(), loc))],
                     else_: null,
                     loc,
@@ -675,7 +939,14 @@ function inspectHelper(lowerer, t, loc) {
                 body = [ret(strLit(`${display} {}`, loc))];
                 break;
             }
-            const get = (field, type) => ({ kind: "fieldGet", obj: v(), className: t.className, field, type, loc });
+            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
@@ -774,9 +1045,21 @@ function formatValueExpr(lowerer, t, value, depth, loc) {
         case "bigint":
             return { kind: "libCall", fn: "bigint.inspect", args: [value], type: STRING, loc };
         case "dyn":
-            return { kind: "libCall", fn: "insp.dynS", args: [value, numLit(depth, loc)], type: STRING, loc };
+            return {
+                kind: "libCall",
+                fn: "insp.dynS",
+                args: [value, numLit(depth, loc)],
+                type: STRING,
+                loc,
+            };
         case "union":
-            return { kind: "call", callee: formatUnionHelper(lowerer, t, depth, loc), args: [value], type: STRING, loc };
+            return {
+                kind: "call",
+                callee: formatUnionHelper(lowerer, t, depth, loc),
+                args: [value],
+                type: STRING,
+                loc,
+            };
         default:
             return inspectExpr(lowerer, t, value, numLit(0, loc), numLit(depth, loc), loc);
     }
@@ -798,10 +1081,25 @@ function formatUnionHelper(lowerer, t, depth, loc) {
     const v = () => ({ kind: "varRef", localId: "v.0", type: t, loc });
     const body = [];
     def.arms.forEach((arm, tag) => {
-        const narrowed = { kind: "unionNarrow", unionId: t.unionId, tag, value: v(), type: arm, loc };
+        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 },
+            cond: {
+                kind: "unionIsTag",
+                unionId: t.unionId,
+                tag,
+                negated: false,
+                value: v(),
+                type: BOOL,
+                loc,
+            },
             then: [{ kind: "return", value: formatValueExpr(lowerer, arm, narrowed, depth, loc), loc }],
             else_: null,
             loc,
@@ -840,7 +1138,10 @@ export function lowerConsoleInspectArg(lowerer, node, value, surface, loc) {
         // renderings differ, so the argument's checker type picks — and only
         // Buffer lowers (lowerInspectCall's stance).
         const tname = lowerer.checker.typeToString(lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(node)));
-        const isBuffer = tname === "Buffer" || tname === "NonSharedBuffer" || tname.startsWith("Buffer<") || tname.startsWith("NonSharedBuffer<");
+        const isBuffer = tname === "Buffer" ||
+            tname === "NonSharedBuffer" ||
+            tname.startsWith("Buffer<") ||
+            tname.startsWith("NonSharedBuffer<");
         if (t.elem !== "u8" || !isBuffer) {
             lowerer.unsupported("SC1090", node, `${surface} of '${tname}' values (Buffer's <Buffer ..> form is the lowered typed-array rendering; other typed arrays fence)`);
         }
@@ -877,13 +1178,16 @@ function parseInspectOptions(lowerer, node, recursive) {
         const numeric = () => {
             if (ts.isNumericLiteral(value))
                 return Number(value.text);
-            if (ts.isPrefixUnaryExpression(value) && value.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(value.operand)) {
+            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 (value.kind === ts.SyntaxKind.NullKeyword ||
+                (ts.isIdentifier(value) && value.text === "Infinity")) {
                 // Unbounded depth is safe over recursive types too: the circular
                 // machinery ([Circular *N]) cuts every cycle, so the walk is
                 // bounded by the (finite) object graph — exactly Node.
@@ -974,7 +1278,10 @@ function lowerInspectCall(lowerer, expr, loc) {
     }
     if (ts.isArrowFunction(valueNode) || ts.isFunctionExpression(valueNode)) {
         parseInspectOptions(lowerer, expr.arguments[1], false);
-        return strLit(valueNode.kind === ts.SyntaxKind.FunctionExpression && valueNode.name ? `[Function: ${valueNode.name.text}]` : "[Function (anonymous)]", loc);
+        return strLit(valueNode.kind === ts.SyntaxKind.FunctionExpression &&
+            valueNode.name
+            ? `[Function: ${valueNode.name.text}]`
+            : "[Function (anonymous)]", loc);
     }
     const value = lowerer.lowerExpr(valueNode);
     if (value.type.kind === "bytes") {
@@ -984,7 +1291,10 @@ function lowerInspectCall(lowerer, expr, loc) {
         // Nested bytes fence in inspectSupport (no checker type survives
         // into shapes).
         const tname = lowerer.checker.typeToString(lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(valueNode)));
-        const isBuffer = tname === "Buffer" || tname === "NonSharedBuffer" || tname.startsWith("Buffer<") || tname.startsWith("NonSharedBuffer<");
+        const isBuffer = tname === "Buffer" ||
+            tname === "NonSharedBuffer" ||
+            tname.startsWith("Buffer<") ||
+            tname.startsWith("NonSharedBuffer<");
         if (value.type.elem !== "u8" || !isBuffer) {
             lowerer.noLowering(`util.inspect of '${tname}' values`, valueNode, "Buffer's <Buffer ..> form is the lowered typed-array rendering; other typed arrays fence");
         }
@@ -1024,7 +1334,13 @@ function formatSArg(lowerer, node, depth, loc) {
     if (t.kind === "bigint")
         return { kind: "libCall", fn: "bigint.inspect", args: [value], type: STRING, loc };
     if (t.kind === "dyn") {
-        return { kind: "libCall", fn: "insp.dynS", args: [value, numLit(depth, loc)], type: STRING, loc };
+        return {
+            kind: "libCall",
+            fn: "insp.dynS",
+            args: [value, numLit(depth, loc)],
+            type: STRING,
+            loc,
+        };
     }
     // A UNION argument dispatches per arm at runtime: a string arm prints
     // VERBATIM (typeof arg === 'string' in Node's formatter — inspect's
@@ -1126,14 +1442,29 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions) {
                 if (value.type.kind === "f64")
                     return { kind: "libCall", fn: "insp.f64", args: [value], type: STRING, loc };
                 if (value.type.kind === "string") {
-                    const parsed = { kind: "libCall", fn: "num.fromString", args: [value], type: F64, loc };
+                    const parsed = {
+                        kind: "libCall",
+                        fn: "num.fromString",
+                        args: [value],
+                        type: F64,
+                        loc,
+                    };
                     return { kind: "libCall", fn: "insp.f64", args: [parsed], type: STRING, loc };
                 }
                 if (value.type.kind === "bool") {
                     return {
                         kind: "libCall",
                         fn: "insp.f64",
-                        args: [{ kind: "ternary", cond: value, then: numLit(1, loc), else_: numLit(0, loc), type: F64, loc }],
+                        args: [
+                            {
+                                kind: "ternary",
+                                cond: value,
+                                then: numLit(1, loc),
+                                else_: numLit(0, loc),
+                                type: F64,
+                                loc,
+                            },
+                        ],
                         type: STRING,
                         loc,
                     };
@@ -1158,9 +1489,19 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions) {
             case 105: {
                 // %i — parseInt(ToString(arg)): the spec-exact composition.
                 const value = lowerer.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, numLit(0, loc)], type: F64, loc };
+                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, numLit(0, loc)],
+                        type: F64,
+                        loc,
+                    };
                     return { kind: "libCall", fn: "insp.f64", args: [parsed], type: STRING, loc };
                 }
                 lowerer.noLowering(`util.format %i of '${lowerer.fmt(value.type)}' values`, node);
@@ -1177,7 +1518,7 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions) {
                 // side-effect-free reads compose (the typeof-fold stance).
                 if (value.type.kind === "symbol") {
                     if (!isSafeToRepeat(value)) {
-                        lowerer.noLowering(`util.format %j of computed symbol values`, node, "bind the symbol to a const first (the %j text is always \"undefined\")");
+                        lowerer.noLowering(`util.format %j of computed symbol values`, node, 'bind the symbol to a const first (the %j text is always "undefined")');
                     }
                     return strLit("undefined", loc);
                 }
@@ -1210,7 +1551,8 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions) {
                     case 100: // d
                     case 79: // O
                     case 111: // o
-                    case 105: { // i
+                    case 105: {
+                        // i
                         const node = args[++a];
                         if (lastPos !== i - 1)
                             parts.push(strLit(fmt.slice(lastPos, i - 1), loc));
@@ -1273,7 +1615,7 @@ function typeTreeHasArray(lowerer, t, visiting) {
             return (shape?.fields ?? []).some((f) => typeTreeHasArray(lowerer, f.type, visiting));
         }
         case "map":
-            return typeTreeHasArray(lowerer, t.key, visiting) || typeTreeHasArray(lowerer, t.value, visiting);
+            return (typeTreeHasArray(lowerer, t.key, visiting) || typeTreeHasArray(lowerer, t.value, visiting));
         case "set":
             return typeTreeHasArray(lowerer, t.elem, visiting);
         case "union": {
@@ -1311,8 +1653,9 @@ export function lowerUtilModuleCall(lowerer, expr, bi, loc) {
             // Save all inputs before evaluating surplus arguments: comparison may
             // read mutable objects or throw, so it must happen after every argument.
             for (let i = 0; i < 3; i++) {
-                const input = expr.arguments[i] ? lowerer.lowerExprExpecting(expr.arguments[i], DYN)
-                    : { kind: "dynFrom", value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, type: DYN, loc };
+                const input = expr.arguments[i]
+                    ? lowerer.lowerExprExpecting(expr.arguments[i], DYN)
+                    : dynUndefinedExpr(loc);
                 const saved = lowerer.declareHiddenLocal("%utilInput", DYN);
                 stmts.push({ kind: "varDecl", localId: saved.id, init: input, loc });
                 args.push(varRef(saved.id, DYN, loc));
@@ -1320,13 +1663,23 @@ export function lowerUtilModuleCall(lowerer, expr, bi, loc) {
             for (const arg of expr.arguments.slice(3))
                 stmts.push({ kind: "exprStmt", expr: lowerer.lowerExpr(arg), loc });
             const type = bi.member === "styleText" ? STRING : BOOL;
-            return { kind: "seqExpr", stmts, result: { kind: "libCall", fn: `util.${bi.member}`, args, type, loc }, type, loc };
+            return {
+                kind: "seqExpr",
+                stmts,
+                result: { kind: "libCall", fn: `util.${bi.member}`, args, type, loc },
+                type,
+                loc,
+            };
         }
         case "getSystemErrorMap": {
             if (expr.arguments.some(ts.isSpreadElement))
                 lowerer.noLowering("util.getSystemErrorMap with spread arguments", expr);
             const result = lowerSystemErrorMap(lowerer, loc);
-            const stmts = expr.arguments.map((arg) => ({ kind: "exprStmt", expr: lowerer.lowerExpr(arg), loc }));
+            const stmts = expr.arguments.map((arg) => ({
+                kind: "exprStmt",
+                expr: lowerer.lowerExpr(arg),
+                loc,
+            }));
             return stmts.length ? { kind: "seqExpr", stmts, result, type: result.type, loc } : result;
         }
         case "getSystemErrorName":
@@ -1335,14 +1688,35 @@ export function lowerUtilModuleCall(lowerer, expr, bi, loc) {
         case "toUSVString": {
             if (expr.arguments.some(ts.isSpreadElement))
                 lowerer.noLowering(`util.${bi.member} with spread arguments`, expr);
-            const input = expr.arguments[0] ? lowerer.lowerExprExpecting(expr.arguments[0], DYN)
-                : { kind: "dynFrom", value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, type: DYN, loc };
+            const input = expr.arguments[0]
+                ? lowerer.lowerExprExpecting(expr.arguments[0], DYN)
+                : {
+                    kind: "dynFrom",
+                    value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc },
+                    type: DYN,
+                    loc,
+                };
             if (expr.arguments.length <= 1)
                 return { kind: "libCall", fn: `util.${bi.member}`, args: [input], type: STRING, loc };
             const saved = lowerer.declareHiddenLocal("%utilInput", DYN);
-            return { kind: "seqExpr", stmts: [{ kind: "varDecl", localId: saved.id, init: input, loc },
-                    ...expr.arguments.slice(1).map((arg) => ({ kind: "exprStmt", expr: lowerer.lowerExpr(arg), loc }))],
-                result: { kind: "libCall", fn: `util.${bi.member}`, args: [varRef(saved.id, DYN, loc)], type: STRING, loc }, type: STRING, loc };
+            return {
+                kind: "seqExpr",
+                stmts: [
+                    { kind: "varDecl", localId: saved.id, init: input, loc },
+                    ...expr.arguments
+                        .slice(1)
+                        .map((arg) => ({ kind: "exprStmt", expr: lowerer.lowerExpr(arg), loc })),
+                ],
+                result: {
+                    kind: "libCall",
+                    fn: `util.${bi.member}`,
+                    args: [varRef(saved.id, DYN, loc)],
+                    type: STRING,
+                    loc,
+                },
+                type: STRING,
+                loc,
+            };
         }
         case "inspect":
             return lowerInspectCall(lowerer, expr, loc);
@@ -1356,11 +1730,20 @@ export function lowerUtilModuleCall(lowerer, expr, bi, loc) {
             if (expr.arguments.length > 1 || expr.arguments.some(ts.isSpreadElement)) {
                 lowerer.noLowering("util.parseEnv with spread or extra arguments", expr);
             }
-            const input = expr.arguments[0] ? lowerer.lowerExprExpecting(expr.arguments[0], DYN)
-                : { kind: "dynFrom", value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, type: DYN, loc };
-            const parsed = { kind: "libCall", fn: "util.parseEnv", args: [input], type: DYN, loc };
+            const input = expr.arguments[0]
+                ? lowerer.lowerExprExpecting(expr.arguments[0], DYN)
+                : dynUndefinedExpr(loc);
+            const parsed = {
+                kind: "libCall",
+                fn: "util.parseEnv",
+                args: [input],
+                type: DYN,
+                loc,
+            };
             const result = lowerer.mapTypeOf(lowerer.typeOf(expr));
-            if (result && result.kind !== "dyn" && result.kind !== "jsval" &&
+            if (result &&
+                result.kind !== "dyn" &&
+                result.kind !== "jsval" &&
                 canDynCheckTo(result, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
                 return { kind: "dynCheck", value: parsed, type: result, loc };
             }
@@ -1400,8 +1783,7 @@ function lowerParseArgsCall(lowerer, expr, loc) {
             // capsules so that default arrays can leave the dyn result as the
             // original static reference; the runtime still snapshots `args` and
             // the option schema before parsing, matching Node's synchronous read.
-            const liveRef = raw.type.kind === "record" || raw.type.kind === "array" ||
-                raw.type.kind === "bytes";
+            const liveRef = raw.type.kind === "record" || raw.type.kind === "array" || raw.type.kind === "bytes";
             config = {
                 kind: "dynFrom",
                 value: raw,
@@ -1422,7 +1804,10 @@ function lowerParseArgsCall(lowerer, expr, loc) {
         loc,
     };
     const result = lowerer.mapTypeOf(lowerer.typeOf(expr));
-    if (result !== null && result.kind !== "dyn" && result.kind !== "jsval" && result.kind !== "void" &&
+    if (result !== null &&
+        result.kind !== "dyn" &&
+        result.kind !== "jsval" &&
+        result.kind !== "void" &&
         canDynCheckTo(result, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
         return { kind: "dynCheck", value: parsed, type: result, loc };
     }
@@ -1451,7 +1836,12 @@ function lowerGetCallSitesCall(lowerer, expr, loc) {
             kind: "dynObjLit",
             fields: [
                 field("functionName", { kind: "strLit", value: "", type: STRING, loc }),
-                field("scriptName", { kind: "strLit", value: expr.getSourceFile().fileName, 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 }),