@scriptc/compiler 0.2.4 → 0.2.6

package/dist/frontend/lowering/lower-builtin-values.js

@@ -1,14 +1,29 @@
+import { lowerWorkerMetadata } from "./builtins/workers.js";
 import * as ts from "../ts7/adapter.js";
-import { BOOL, DYN, F64, NULL_T, STRING, UNDEFINED_T, arrayOf } from "../../ir/ir.js";
+import { BOOL, DYN, F64, STRING, UNDEFINED_T, arrayOf, } from "../../ir/ir.js";
 import { strLit, varRef } from "../../ir/build.js";
-import { BUILTIN_MODULE_CONSTS, BUILTIN_MODULE_FNS, OBJECT_CALLABLE_VALUES, builtinConstLit, builtinModuleConstOf, builtinModulesArrayLit, stdlibGlobalNameOf } from "./surfaces.js";
+import { BUILTIN_MODULE_CONSTS, BUILTIN_MODULE_FNS, OBJECT_CALLABLE_VALUES, builtinConstLit, builtinModuleConstOf, builtinModulesArrayLit, stdlibGlobalNameOf, } from "./surfaces.js";
 const PROTOTYPE_METHODS = {
     Date: ["getTime", "valueOf", "toISOString", "toJSON"],
     Map: ["get", "set", "has", "delete", "clear", "keys", "values", "entries", "forEach"],
     Set: ["add", "has", "delete", "clear", "keys", "values", "entries", "forEach"],
     WeakMap: ["get", "set", "has", "delete"],
     WeakSet: ["add", "has", "delete"],
-    String: ["split", "startsWith", "endsWith", "substring", "slice", "toLowerCase", "toUpperCase", "padStart", "charCodeAt", "normalize", "replace", "toString", "valueOf"],
+    String: [
+        "split",
+        "startsWith",
+        "endsWith",
+        "substring",
+        "slice",
+        "toLowerCase",
+        "toUpperCase",
+        "padStart",
+        "charCodeAt",
+        "normalize",
+        "replace",
+        "toString",
+        "valueOf",
+    ],
     Number: ["toString", "valueOf"],
     Object: ["hasOwnProperty", "propertyIsEnumerable", "toString", "valueOf"],
 };
@@ -27,11 +42,15 @@ export function isNativeBuiltinValueInitializer(lowerer, expr, seen = new Set())
         return false;
     while (ts.isParenthesizedExpression(expr))
         expr = expr.expression;
-    const builtin = ts.isIdentifier(expr) ? lowerer.builtinImportOf(expr)
-        : ts.isPropertyAccessExpression(expr) ? lowerer.builtinMemberOf(expr) : null;
+    const builtin = ts.isIdentifier(expr)
+        ? lowerer.builtinImportOf(expr)
+        : ts.isPropertyAccessExpression(expr)
+            ? lowerer.builtinMemberOf(expr)
+            : null;
     if (builtin?.module === "util/types")
         return true;
-    if (builtin?.module === "util" && ["stripVTControlCharacters", "toUSVString", "isDeepStrictEqual", "styleText"].includes(builtin.member))
+    if (builtin?.module === "util" &&
+        ["stripVTControlCharacters", "toUSVString", "isDeepStrictEqual", "styleText"].includes(builtin.member))
         return true;
     // JS global snapshots may use an opaque builtin identity rather than
     // the ambient constructor's callable ABI. Store that actual value in
@@ -44,16 +63,17 @@ export function isNativeBuiltinValueInitializer(lowerer, expr, seen = new Set())
     if (ts.isNewExpression(expr) && lowerer.isStdlibGlobal(expr.expression, "Date"))
         return true;
     if (ts.isConditionalExpression(expr)) {
-        return isNativeBuiltinValueInitializer(lowerer, expr.whenTrue, new Set(seen)) ||
-            isNativeBuiltinValueInitializer(lowerer, expr.whenFalse, new Set(seen));
+        return (isNativeBuiltinValueInitializer(lowerer, expr.whenTrue, new Set(seen)) ||
+            isNativeBuiltinValueInitializer(lowerer, expr.whenFalse, new Set(seen)));
     }
     if (ts.isPropertyAccessExpression(expr)) {
-        return builtinPrototypeMethod(lowerer, expr) !== null ||
+        return (builtinPrototypeMethod(lowerer, expr) !== null ||
             lowerer.stdlibGlobalMember(expr, "console") !== null ||
             lowerer.stdlibGlobalMember(expr, "globalThis") === "console" ||
             lowerer.stdlibGlobalMember(expr, "process") === "getBuiltinModule" ||
             lowerer.stdlibGlobalMember(expr, "process") === "hrtime" ||
-            (expr.name.text === "bigint" && ts.isPropertyAccessExpression(expr.expression) &&
+            (expr.name.text === "bigint" &&
+                ts.isPropertyAccessExpression(expr.expression) &&
                 lowerer.stdlibGlobalMember(expr.expression, "process") === "hrtime") ||
             lowerer.stdlibGlobalMember(expr, "Array") === "isArray" ||
             lowerer.stdlibGlobalMember(expr, "Array") === "from" ||
@@ -62,12 +82,16 @@ export function isNativeBuiltinValueInitializer(lowerer, expr, seen = new Set())
             ["parseInt", "parseFloat"].includes(lowerer.stdlibGlobalMember(expr, "Number") ?? "") ||
             lowerer.stdlibGlobalMember(expr, "Buffer") === "isBuffer" ||
             lowerer.stdlibGlobalMember(expr, "Array") === "prototype" ||
-            (ts.isPropertyAccessExpression(expr.expression) && lowerer.stdlibGlobalMember(expr.expression, "Array") === "prototype") ||
+            (ts.isPropertyAccessExpression(expr.expression) &&
+                lowerer.stdlibGlobalMember(expr.expression, "Array") === "prototype") ||
             lowerer.stdlibGlobalMember(expr, "Object") === "assign" ||
             lowerer.stdlibGlobalMember(expr, "Object") === "create" ||
-            (expr.name.text === "apply" && ts.isPropertyAccessExpression(expr.expression) && lowerer.stdlibGlobalMember(expr.expression, "Function") === "prototype") ||
+            (expr.name.text === "apply" &&
+                ts.isPropertyAccessExpression(expr.expression) &&
+                lowerer.stdlibGlobalMember(expr.expression, "Function") === "prototype") ||
             lowerer.stdlibGlobalMember(expr, "JSON") === "stringify" ||
-            (lowerer.isStdlibGlobal(expr.expression, "Object") && Object.hasOwn(OBJECT_CALLABLE_VALUES, expr.name.text));
+            (lowerer.isStdlibGlobal(expr.expression, "Object") &&
+                Object.hasOwn(OBJECT_CALLABLE_VALUES, expr.name.text)));
     }
     if (!ts.isIdentifier(expr))
         return false;
@@ -75,7 +99,10 @@ export function isNativeBuiltinValueInitializer(lowerer, expr, seen = new Set())
     if (!symbol || seen.has(symbol))
         return false;
     seen.add(symbol);
-    return lowerer.checker.declarationsOf(symbol).some((decl) => ts.isVariableDeclaration(decl) && isNativeBuiltinValueInitializer(lowerer, decl.initializer, seen));
+    return lowerer.checker
+        .declarationsOf(symbol)
+        .some((decl) => ts.isVariableDeclaration(decl) &&
+        isNativeBuiltinValueInitializer(lowerer, decl.initializer, seen));
 }
 /** The stored Array.isArray function shares the direct call's native test. */
 export function lowerArrayIsArrayValue(lowerer, loc) {
@@ -85,70 +112,264 @@ export function lowerArrayIsArrayValue(lowerer, loc) {
         name = key;
         lowerer.builtinCallableValueFns.set(key, name);
         lowerer.liftedFns.push({
-            name, params: [{ localId: "value", name: "value", type: DYN }], returnType: BOOL,
+            name,
+            params: [{ localId: "value", name: "value", type: DYN }],
+            returnType: BOOL,
             locals: [{ id: "value", name: "value", type: DYN, mutable: false }],
-            body: [{ kind: "return", value: { kind: "dynTest", test: "array", value: varRef("value", DYN, loc), type: BOOL, loc }, loc }],
+            body: [
+                {
+                    kind: "return",
+                    value: {
+                        kind: "dynTest",
+                        test: "array",
+                        value: varRef("value", DYN, loc),
+                        type: BOOL,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
             loc,
         });
     }
-    return { kind: "closure", fnName: name, captures: [], type: { kind: "func", params: [DYN], ret: BOOL }, loc };
+    return {
+        kind: "closure",
+        fnName: name,
+        captures: [],
+        type: { kind: "func", params: [DYN], ret: BOOL },
+        loc,
+    };
 }
 export function lowerStringCodesValue(lowerer, member, loc) {
     const name = `%builtin.String.${member}`;
     if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
         const values = varRef("values", DYN, loc), index = varRef("index", F64, loc), codes = varRef("codes", arrayOf(F64), loc), code = varRef("code", F64, loc);
         const number = (value) => ({ kind: "numLit", value, type: F64, loc });
-        lowerer.liftedFns.push({ name, params: [{ localId: "first", name: "first", type: DYN }, { localId: "values", name: "values", type: DYN }], returnType: STRING,
-            locals: [{ id: "first", name: "first", type: DYN, mutable: false }, { id: "values", name: "values", type: DYN, mutable: false },
-                { id: "codes", name: "codes", type: arrayOf(F64), mutable: false }, { id: "index", name: "index", type: F64, mutable: true }, { id: "code", name: "code", type: F64, mutable: false }], loc,
+        lowerer.liftedFns.push({
+            name,
+            params: [
+                { localId: "first", name: "first", type: DYN },
+                { localId: "values", name: "values", type: DYN },
+            ],
+            returnType: STRING,
+            locals: [
+                { id: "first", name: "first", type: DYN, mutable: false },
+                { id: "values", name: "values", type: DYN, mutable: false },
+                { id: "codes", name: "codes", type: arrayOf(F64), mutable: false },
+                { id: "index", name: "index", type: F64, mutable: true },
+                { id: "code", name: "code", type: F64, mutable: false },
+            ],
+            loc,
             body: [
-                { kind: "varDecl", localId: "codes", init: { kind: "arrayLit", elems: [], type: arrayOf(F64), loc }, loc },
+                {
+                    kind: "varDecl",
+                    localId: "codes",
+                    init: { kind: "arrayLit", elems: [], type: arrayOf(F64), loc },
+                    loc,
+                },
                 { kind: "varDecl", localId: "index", init: number(0), loc },
-                { kind: "while", cond: { kind: "bin", op: "<", left: index, right: { kind: "dynCheck", value: { kind: "dynKeyGet", value: values, key: strLit("length", loc), type: DYN, loc }, type: F64, loc }, type: BOOL, loc }, loc, body: [
-                        { kind: "varDecl", localId: "code", init: { kind: "libCall", fn: "dyn.toNumberCoerce", args: [{ kind: "dynKeyGet", value: values, key: lowerer.coerceToExpected(index, DYN), type: DYN, loc }], type: F64, loc }, loc },
-                        ...(member === "fromCodePoint" ? [{ kind: "exprStmt", expr: { kind: "libCall", fn: "string.fromCodePoint",
-                                    args: [{ kind: "arrayLit", elems: [code], type: arrayOf(F64), loc }], type: STRING, loc }, loc }] : []),
-                        { kind: "exprStmt", expr: { kind: "arrIntrinsic", method: "push", receiver: codes, args: [code], type: F64, loc }, loc },
-                        { kind: "assign", localId: "index", value: { kind: "bin", op: "+", left: index, right: number(1), type: F64, loc }, loc },
-                    ] },
-                { kind: "return", value: { kind: "libCall", fn: `string.${member}`, args: [codes], type: STRING, loc }, loc },
+                {
+                    kind: "while",
+                    cond: {
+                        kind: "bin",
+                        op: "<",
+                        left: index,
+                        right: {
+                            kind: "dynCheck",
+                            value: {
+                                kind: "dynKeyGet",
+                                value: values,
+                                key: strLit("length", loc),
+                                type: DYN,
+                                loc,
+                            },
+                            type: F64,
+                            loc,
+                        },
+                        type: BOOL,
+                        loc,
+                    },
+                    loc,
+                    body: [
+                        {
+                            kind: "varDecl",
+                            localId: "code",
+                            init: {
+                                kind: "libCall",
+                                fn: "dyn.toNumberCoerce",
+                                args: [
+                                    {
+                                        kind: "dynKeyGet",
+                                        value: values,
+                                        key: lowerer.coerceToExpected(index, DYN),
+                                        type: DYN,
+                                        loc,
+                                    },
+                                ],
+                                type: F64,
+                                loc,
+                            },
+                            loc,
+                        },
+                        ...(member === "fromCodePoint"
+                            ? [
+                                {
+                                    kind: "exprStmt",
+                                    expr: {
+                                        kind: "libCall",
+                                        fn: "string.fromCodePoint",
+                                        args: [{ kind: "arrayLit", elems: [code], type: arrayOf(F64), loc }],
+                                        type: STRING,
+                                        loc,
+                                    },
+                                    loc,
+                                },
+                            ]
+                            : []),
+                        {
+                            kind: "exprStmt",
+                            expr: {
+                                kind: "arrIntrinsic",
+                                method: "push",
+                                receiver: codes,
+                                args: [code],
+                                type: F64,
+                                loc,
+                            },
+                            loc,
+                        },
+                        {
+                            kind: "assign",
+                            localId: "index",
+                            value: { kind: "bin", op: "+", left: index, right: number(1), type: F64, loc },
+                            loc,
+                        },
+                    ],
+                },
+                {
+                    kind: "return",
+                    value: { kind: "libCall", fn: `string.${member}`, args: [codes], type: STRING, loc },
+                    loc,
+                },
             ],
         });
     }
-    return { kind: "dynFrom", value: { kind: "closure", fnName: name, captures: [], type: { kind: "func", params: [DYN], ret: STRING, rest: true, argumentsAll: true }, loc }, fnName: member, type: DYN, loc };
+    return {
+        kind: "dynFrom",
+        value: {
+            kind: "closure",
+            fnName: name,
+            captures: [],
+            type: { kind: "func", params: [DYN], ret: STRING, rest: true, argumentsAll: true },
+            loc,
+        },
+        fnName: member,
+        type: DYN,
+        loc,
+    };
 }
 export function lowerCheckedPredicateValue(lowerer, display, test, loc, predicate) {
     const name = `%builtin.${display}`;
     if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
         const value = varRef("value", DYN, loc);
         const matches = { kind: "dynTest", test, value, type: BOOL, loc };
-        const result = predicate ? { kind: "ternary", cond: matches,
-            then: { kind: "libCall", fn: predicate, args: [{ kind: "dynCheck", value, type: F64, loc }], type: BOOL, loc },
-            else_: { kind: "boolLit", value: false, type: BOOL, loc }, type: BOOL, loc } : matches;
-        lowerer.liftedFns.push({ name, params: [{ localId: "value", name: "value", type: DYN }], returnType: BOOL,
-            locals: [{ id: "value", name: "value", type: DYN, mutable: false }], body: [{ kind: "return", value: result, loc }], loc });
+        const result = predicate
+            ? {
+                kind: "ternary",
+                cond: matches,
+                then: {
+                    kind: "libCall",
+                    fn: predicate,
+                    args: [{ kind: "dynCheck", value, type: F64, loc }],
+                    type: BOOL,
+                    loc,
+                },
+                else_: { kind: "boolLit", value: false, type: BOOL, loc },
+                type: BOOL,
+                loc,
+            }
+            : matches;
+        lowerer.liftedFns.push({
+            name,
+            params: [{ localId: "value", name: "value", type: DYN }],
+            returnType: BOOL,
+            locals: [{ id: "value", name: "value", type: DYN, mutable: false }],
+            body: [{ kind: "return", value: result, loc }],
+            loc,
+        });
     }
-    return { kind: "closure", fnName: name, captures: [], type: { kind: "func", params: [DYN], ret: BOOL }, loc };
+    return {
+        kind: "closure",
+        fnName: name,
+        captures: [],
+        type: { kind: "func", params: [DYN], ret: BOOL },
+        loc,
+    };
 }
 export function lowerNumberParserValue(lowerer, member, loc) {
     const name = `%builtin.Number.${member}`;
     const types = member === "parseInt" ? [DYN, DYN] : [DYN];
     if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
         const params = types.map((type, index) => ({ localId: `p.${index}`, name: `p${index}`, type }));
-        const text = { kind: "libCall", fn: "dyn.toStringCoerce", args: [varRef("p.0", DYN, loc)], type: STRING, loc };
-        const radix = { kind: "libCall", fn: "dyn.toNumberCoerce", args: [varRef("p.1", DYN, loc)], type: F64, loc };
-        lowerer.liftedFns.push({ name, params, returnType: F64, locals: params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false })),
-            body: [{ kind: "return", value: { kind: "libCall", fn: `num.${member}`, args: member === "parseInt" ? [text, radix] : [text], type: F64, loc }, loc }], loc });
+        const text = {
+            kind: "libCall",
+            fn: "dyn.toStringCoerce",
+            args: [varRef("p.0", DYN, loc)],
+            type: STRING,
+            loc,
+        };
+        const radix = {
+            kind: "libCall",
+            fn: "dyn.toNumberCoerce",
+            args: [varRef("p.1", DYN, loc)],
+            type: F64,
+            loc,
+        };
+        lowerer.liftedFns.push({
+            name,
+            params,
+            returnType: F64,
+            locals: params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false })),
+            body: [
+                {
+                    kind: "return",
+                    value: {
+                        kind: "libCall",
+                        fn: `num.${member}`,
+                        args: member === "parseInt" ? [text, radix] : [text],
+                        type: F64,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            loc,
+        });
     }
-    return { kind: "dynFrom", value: { kind: "closure", fnName: name, captures: [], type: { kind: "func", params: types, ret: F64 }, loc }, fnName: member, type: DYN, loc };
+    return {
+        kind: "dynFrom",
+        value: {
+            kind: "closure",
+            fnName: name,
+            captures: [],
+            type: { kind: "func", params: types, ret: F64 },
+            loc,
+        },
+        fnName: member,
+        type: DYN,
+        loc,
+    };
 }
-// These module values expose existing native callable lowerings and main-thread
-// metadata. Other exports keep an explicit runtime refusal, including Worker.
+// These module values expose native callable lowerings and current-thread
+// metadata. Stored Worker constructors remain refused: native worker roots
+// must be resolved from the source at compilation time.
 const MODULES = ["path/posix", "path/win32", "os", "worker_threads", "util/types"];
 const box = (value) => value.type.kind === "dyn" ? value : { kind: "dynFrom", value, type: DYN, loc: value.loc };
 export function pathModuleValue(lowerer, module, loc) {
     const fields = [];
-    const add = (member, value) => { fields.push({ key: strLit(member, loc), value: box(value) }); };
+    const add = (member, value) => {
+        fields.push({ key: strLit(member, loc), value: box(value) });
+    };
     for (const member of Object.keys(BUILTIN_MODULE_FNS[module] ?? {})) {
         const value = lowerer.lowerBuiltinCallableValue({ module, member }, loc);
         if (value)
@@ -170,13 +391,41 @@ export function lowerUtilTypeValue(lowerer, member, loc) {
     const name = `%builtin.util/types.${member}`;
     if (!lowerer.builtinCallableValueFns.has(name)) {
         lowerer.builtinCallableValueFns.set(name, name);
-        lowerer.liftedFns.push({ name, params: [{ localId: "value", name: "value", type: DYN }], returnType: BOOL,
-            locals: [{ id: "value", name: "value", type: DYN, mutable: false }], loc,
-            body: [{ kind: "return", value: { kind: "libCall", fn: "util.typeIs", args: [varRef("value", DYN, loc), strLit(member, loc)], type: BOOL, loc }, loc }],
+        lowerer.liftedFns.push({
+            name,
+            params: [{ localId: "value", name: "value", type: DYN }],
+            returnType: BOOL,
+            locals: [{ id: "value", name: "value", type: DYN, mutable: false }],
+            loc,
+            body: [
+                {
+                    kind: "return",
+                    value: {
+                        kind: "libCall",
+                        fn: "util.typeIs",
+                        args: [varRef("value", DYN, loc), strLit(member, loc)],
+                        type: BOOL,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
         });
     }
-    const value = { kind: "closure", fnName: name, captures: [], type: { kind: "func", params: [DYN], ret: BOOL }, loc };
-    return { kind: "libCall", fn: "util.typeValue", args: [box(value), strLit(member, loc)], type: DYN, loc };
+    const value = {
+        kind: "closure",
+        fnName: name,
+        captures: [],
+        type: { kind: "func", params: [DYN], ret: BOOL },
+        loc,
+    };
+    return {
+        kind: "libCall",
+        fn: "util.typeValue",
+        args: [box(value), strLit(member, loc)],
+        type: DYN,
+        loc,
+    };
 }
 function moduleValue(lowerer, module, loc) {
     const cacheKey = `%builtin.module.get.${module}`;
@@ -188,8 +437,18 @@ function moduleValue(lowerer, module, loc) {
         const body = [];
         const add = (member, value) => {
             body.push({
-                kind: "if", cond: { kind: "strEq", negated: false, left: key, right: strLit(member, loc), type: BOOL, loc },
-                then: [{ kind: "return", value: box(value), loc }], else_: null, loc,
+                kind: "if",
+                cond: {
+                    kind: "strEq",
+                    negated: false,
+                    left: key,
+                    right: strLit(member, loc),
+                    type: BOOL,
+                    loc,
+                },
+                then: [{ kind: "return", value: box(value), loc }],
+                else_: null,
+                loc,
             });
         };
         for (const member of Object.keys(BUILTIN_MODULE_FNS[module] ?? {})) {
@@ -198,8 +457,11 @@ function moduleValue(lowerer, module, loc) {
                 add(member, callable);
         }
         for (const member of Object.keys(BUILTIN_MODULE_CONSTS[module] ?? {})) {
+            const worker = module === "worker_threads" ? lowerWorkerMetadata(member, loc) : null;
             const value = builtinModuleConstOf(lowerer, module, member);
-            if (value !== undefined)
+            if (worker)
+                add(member, worker);
+            else if (value !== undefined)
                 add(member, builtinConstLit(value, loc));
         }
         if (module.startsWith("path/")) {
@@ -207,20 +469,43 @@ function moduleValue(lowerer, module, loc) {
             add("win32", moduleValue(lowerer, "path/win32", loc));
         }
         if (module === "worker_threads") {
-            add("isInternalThread", { kind: "boolLit", value: false, type: BOOL, loc });
-            add("parentPort", { kind: "unitLit", unit: "null", type: NULL_T, loc });
-            add("workerData", { kind: "unitLit", unit: "null", type: NULL_T, loc });
+            for (const member of ["isInternalThread", "parentPort", "workerData"])
+                add(member, lowerWorkerMetadata(member, loc));
         }
-        body.push({ kind: "return", value: {
-                kind: "libCall", fn: "process.builtinUnsupported", args: [strLit(module, loc), key], type: DYN, loc,
-            }, loc });
+        body.push({
+            kind: "return",
+            value: {
+                kind: "libCall",
+                fn: "process.builtinUnsupported",
+                args: [strLit(module, loc), key],
+                type: DYN,
+                loc,
+            },
+            loc,
+        });
         lowerer.liftedFns.push({
-            name, params: [{ localId: "key", name: "key", type: STRING }], returnType: DYN,
-            locals: [{ id: "key", name: "key", type: STRING, mutable: false }], body, loc,
+            name,
+            params: [{ localId: "key", name: "key", type: STRING }],
+            returnType: DYN,
+            locals: [{ id: "key", name: "key", type: STRING, mutable: false }],
+            body,
+            loc,
         });
     }
-    const getter = { kind: "closure", fnName: name, captures: [], type: { kind: "func", params: [STRING], ret: DYN }, loc };
-    return { kind: "libCall", fn: "process.builtinModule", args: [strLit(module, loc), box(getter)], type: DYN, loc };
+    const getter = {
+        kind: "closure",
+        fnName: name,
+        captures: [],
+        type: { kind: "func", params: [STRING], ret: DYN },
+        loc,
+    };
+    return {
+        kind: "libCall",
+        fn: "process.builtinModule",
+        args: [strLit(module, loc), box(getter)],
+        type: DYN,
+        loc,
+    };
 }
 /** A first-class loader uses the same native functions as direct imports.
  * Module handles cache values and preserve aliases without a JS engine. */
@@ -228,12 +513,38 @@ export function lowerObjectAssignValue(lowerer, loc) {
     const name = "%builtin.Object.assign";
     if (!lowerer.liftedFns.some((fn) => fn.name === name))
         lowerer.liftedFns.push({
-            name, params: [{ localId: "target", name: "target", type: DYN }, { localId: "sources", name: "sources", type: DYN }],
+            name,
+            params: [
+                { localId: "target", name: "target", type: DYN },
+                { localId: "sources", name: "sources", type: DYN },
+            ],
             returnType: DYN,
-            locals: [{ id: "target", name: "target", type: DYN, mutable: false }, { id: "sources", name: "sources", type: DYN, mutable: false }],
-            body: [{ kind: "return", value: { kind: "libCall", fn: "dyn.assignAll", args: [varRef("target", DYN, loc), varRef("sources", DYN, loc)], type: DYN, loc }, loc }], loc,
+            locals: [
+                { id: "target", name: "target", type: DYN, mutable: false },
+                { id: "sources", name: "sources", type: DYN, mutable: false },
+            ],
+            body: [
+                {
+                    kind: "return",
+                    value: {
+                        kind: "libCall",
+                        fn: "dyn.assignAll",
+                        args: [varRef("target", DYN, loc), varRef("sources", DYN, loc)],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            loc,
         });
-    return { kind: "closure", fnName: name, captures: [], type: { kind: "func", params: [DYN], ret: DYN, rest: true }, loc };
+    return {
+        kind: "closure",
+        fnName: name,
+        captures: [],
+        type: { kind: "func", params: [DYN], ret: DYN, rest: true },
+        loc,
+    };
 }
 export function lowerBuiltinLoaderValue(lowerer, loc) {
     const cacheKey = "%builtin.process.getBuiltinModule";
@@ -242,13 +553,34 @@ export function lowerBuiltinLoaderValue(lowerer, loc) {
         name = cacheKey;
         lowerer.builtinCallableValueFns.set(cacheKey, name);
         const id = varRef("id", STRING, loc);
-        const body = [{ kind: "varDecl", localId: "id", init: {
-                    kind: "libCall", fn: "process.builtinId", args: [varRef("input", DYN, loc), builtinModulesArrayLit(loc)], type: STRING, loc,
-                }, loc }];
+        const body = [
+            {
+                kind: "varDecl",
+                localId: "id",
+                init: {
+                    kind: "libCall",
+                    fn: "process.builtinId",
+                    args: [varRef("input", DYN, loc), builtinModulesArrayLit(loc)],
+                    type: STRING,
+                    loc,
+                },
+                loc,
+            },
+        ];
         const add = (specifier, value) => {
             body.push({
-                kind: "if", cond: { kind: "strEq", negated: false, left: id, right: strLit(specifier, loc), type: BOOL, loc },
-                then: [{ kind: "return", value, loc }], else_: null, loc,
+                kind: "if",
+                cond: {
+                    kind: "strEq",
+                    negated: false,
+                    left: id,
+                    right: strLit(specifier, loc),
+                    type: BOOL,
+                    loc,
+                },
+                then: [{ kind: "return", value, loc }],
+                else_: null,
+                loc,
             });
         };
         add("", box({ kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }));
@@ -257,14 +589,35 @@ export function lowerBuiltinLoaderValue(lowerer, loc) {
         add("path", moduleValue(lowerer, pathModule, loc));
         for (const module of MODULES)
             add(module, moduleValue(lowerer, module, loc));
-        body.push({ kind: "return", value: {
-                kind: "libCall", fn: "process.builtinUnsupported", args: [id, strLit("", loc)], type: DYN, loc,
-            }, loc });
+        body.push({
+            kind: "return",
+            value: {
+                kind: "libCall",
+                fn: "process.builtinUnsupported",
+                args: [id, strLit("", loc)],
+                type: DYN,
+                loc,
+            },
+            loc,
+        });
         lowerer.liftedFns.push({
-            name, params: [{ localId: "input", name: "id", type: DYN }], returnType: DYN,
-            locals: [{ id: "input", name: "id", type: DYN, mutable: false }, { id: "id", name: "module", type: STRING, mutable: false }], body, loc,
+            name,
+            params: [{ localId: "input", name: "id", type: DYN }],
+            returnType: DYN,
+            locals: [
+                { id: "input", name: "id", type: DYN, mutable: false },
+                { id: "id", name: "module", type: STRING, mutable: false },
+            ],
+            body,
+            loc,
         });
     }
-    return { kind: "closure", fnName: name, captures: [], type: { kind: "func", params: [DYN], ret: DYN }, loc };
+    return {
+        kind: "closure",
+        fnName: name,
+        captures: [],
+        type: { kind: "func", params: [DYN], ret: DYN },
+        loc,
+    };
 }
 //# sourceMappingURL=lower-builtin-values.js.map