@scriptc/compiler 0.1.7 → 0.2.1

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

@@ -1,3 +1,4 @@
+import { InternalCompilerError } from "../../errors.js";
 /* Module-graph lowering: splitting each source file into its parts, the
  * program-collection pass (signatures, classes, globals — reachability
  * seeds), npm/JSON import collection, per-file %init functions, %main, and
@@ -11,20 +12,24 @@ import { isJsSourceFileName } from "../tsc-codes.js";
 import { isRelativeSpecifier } from "../workspace-registry.js";
 import { canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, entryPackageFilePredicate, isCjsJsFile, isJsSourceFile, isRequireStatement, locOf, makeCycleAdmission, orderedImportsOf, resolveImport, resolveNpmImport } from "../program.js";
 import { invalidJsonModuleDiag, npmEmbedFailedDiag, requiresDynamicImportDiag } from "../../diagnostics/diagnostic.js";
-import { BOOL, DYN, F64, JSVAL, RUNTIME_ERROR_CLASSES, STRING, VOID, arrayOf, canConvertToDyn, isUnitType } from "../../ir/ir.js";
+import { BOOL, DYN, F64, JSVAL, RUNTIME_ERROR_CLASSES, STRING, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, isUnitType } from "../../ir/ir.js";
 import { ENTRY_NAME, PoisonError, boundIdentifiersOf, dynFallbackType, dynUndefinedExpr, importCallHandleType, newFnCtx, staticImportNamespaceType, uncheckedOverloadHandleCall } from "./lowerer.js";
-import { builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireSpecOf, isPromisifyCall, registerBuiltinCallableAlias, textCodecBindingDecl } from "./lower-builtins.js";
-import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, bindingNeverReassigned, deadUnmappableBinding, implicitLocalFnInfoOf, implicitLocalFnNodeOf, nullishGenericBindingUnitOf, registerOverloadedCallableAlias } from "./lower-calls.js";
-import { isVarDeclared, numericIteratorSourceOf, provenanceElidedConstDecl } from "./lower-stmts.js";
+import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireSpecOf, isPromisifyCall, registerBuiltinCallableAlias, stripTypeCasts } from "./lower-builtins.js";
+import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, bindingNeverReassigned, deadUnmappableBinding, funcTypeFromParamShapes, implicitLocalFnInfoOf, implicitLocalFnNodeOf, nullishGenericBindingUnitOf, registerOverloadedCallableAlias } from "./lower-calls.js";
+import { jsBindingHasOpenWrites, hasJsTypeAnnotation, isVarDeclared, numericIteratorSourceOf, provenanceElidedConstDecl } from "./lower-stmts.js";
+import { objectFactorySignature } from "./object-factory-new.js";
 import { streamClassAliasDecl } from "./lower-stream.js";
-import { stdlibGlobalAliasDecl, stdlibGlobalAliasNameOf } from "./surfaces.js";
-import { collectNamespaceStmt, nsPathPrefix, trapDeclRootOf } from "./lower-namespaces.js";
+import { stdlibGlobalAliasDecl, stdlibGlobalAliasNameOf, stdlibGlobalNameOf } from "./surfaces.js";
+import { isNativeBuiltinValueInitializer } from "./lower-builtin-values.js";
+import { collectNamespaceStmt, nsMemberIdentOf, nsPathPrefix, trapDeclRootOf } from "./lower-namespaces.js";
 import { collectExpandoMembers } from "./lower-expando.js";
+import { recordTextCodecClass } from "../../ir/ir.js";
 import { isUnitOnlyTsType, unitOnlyUnion } from "../type-mapper.js";
-import { decoratorNodesOf, genericIfaceBindingKeepsClass, guaranteedDecorationThrow } from "./lower-classes.js";
+import { collectVirtualJsMethods, decoratorNodesOf, genericIfaceBindingKeepsClass, guaranteedDecorationThrow, storedClassValueType } from "./lower-classes.js";
 import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
 import { cjsModuleRef, cjsModuleRegistryPrelude } from "./lower-node-module.js";
 import { forkTargetPaths } from "../fork-target.js";
+import { isNativeProxyInitializer } from "./expressions/native-proxy.js";
 /** Program modules selected by statically resolved child_process.fork()
  * calls join the compiled graph without becoming startup dependencies of
  * the parent entry. Their guarded init functions are selected by %main only
@@ -127,7 +132,7 @@ function dynamicImportProgramTargetOf(program, sf, spec) {
         return null;
     if (dep.fileName.endsWith(".json") || dep.fileName.endsWith(".cts"))
         return null;
-    if (isCjsJsFile(dep))
+    if (isCjsJsFile(dep, program))
         return null;
     return dep;
 }
@@ -223,11 +228,41 @@ export function appendDynamicImportModules(program, order, onCycle) {
    * signatures are cheap and calls resolve against them; only BODY lowering
    * is reachability-gated. */
 export function collectProgram(lowerer, parts) {
+    const computed = new Set();
+    for (const fp of parts)
+        for (const decl of fp.classDecls) {
+            const heritage = decl.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0]?.expression;
+            if (heritage && ts.isCallExpression(heritage))
+                computed.add(decl);
+        }
+    // Descendants need the computed ancestor's completed layout before
+    // their own fields and inherited methods can be collected.
+    const computedSymbols = new Set([...computed].map((decl) => declSymbolOf(lowerer, decl)).filter((symbol) => symbol !== undefined));
+    let expanded = true;
+    while (expanded) {
+        expanded = false;
+        for (const fp of parts)
+            for (const decl of fp.classDecls) {
+                if (computed.has(decl))
+                    continue;
+                const heritage = decl.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0]?.expression;
+                const base = heritage && ts.isIdentifier(heritage) ? lowerer.resolveValueSymbol(heritage) : undefined;
+                if (!base || !computedSymbols.has(base))
+                    continue;
+                computed.add(decl);
+                const symbol = declSymbolOf(lowerer, decl);
+                if (symbol)
+                    computedSymbols.add(symbol);
+                expanded = true;
+            }
+    }
     lowerer.collecting = true;
     try {
+        collectVirtualJsMethods(lowerer, parts.map((part) => part.sf));
         for (const fp of parts)
             for (const decl of fp.classDecls)
-                lowerer.collectClassShape(decl);
+                if (!computed.has(decl))
+                    lowerer.collectClassShape(decl);
         for (const fp of parts)
             for (const decl of fp.fnDecls)
                 lowerer.collectSignature(decl);
@@ -257,6 +292,60 @@ export function collectProgram(lowerer, parts) {
         lowerer.collectNpmImports(parts);
         lowerer.collectJsonImports(parts);
     }
+    for (const decl of computed) {
+        const symbol = declSymbolOf(lowerer, decl);
+        const wasCollecting = lowerer.collecting;
+        lowerer.collecting = true;
+        const previousSink = lowerer.diagSink;
+        const deferred = [];
+        lowerer.diagSink = deferred;
+        const expression = decl.heritageClauses.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword).types[0].expression;
+        const context = newFnCtx(false, null, null, DYN);
+        lowerer.fnStack.push(context);
+        try {
+            let value = lowerer.lowerExpr(expression);
+            const known = value.type.kind === "dyn" ? storedClassValueType(lowerer, expression) : null;
+            if (known?.kind === "classval")
+                value = lowerer.coerceToExpected(value, known);
+            if (value.type.kind === "dyn" || value.type.kind === "func") {
+                const name = `%class.base.${lowerer.classNamer(decl)}`;
+                const loc = locOf(expression);
+                lowerer.liftedFns.push({ name, params: [], returnType: value.type, locals: context.locals,
+                    body: [{ kind: "return", value, loc }], loc });
+                lowerer.computedCallableBases.set(decl, { kind: "call", callee: name, args: [], type: value.type, loc });
+            }
+            if (value.type.kind === "classval") {
+                const classInfo = lowerer.classes.get(value.type.className);
+                if (classInfo) {
+                    const name = `%class.base.${lowerer.classNamer(decl)}`;
+                    const loc = locOf(expression);
+                    lowerer.liftedFns.push({ name, params: [], returnType: value.type, locals: context.locals,
+                        body: [{ kind: "return", value, loc }], loc });
+                    lowerer.computedClassBases.set(lowerer.classNamer(decl), { value: { kind: "call", callee: name, args: [], type: value.type, loc }, classInfo });
+                }
+            }
+        }
+        catch (error) {
+            if (!(error instanceof PoisonError))
+                throw error;
+        }
+        finally {
+            lowerer.fnStack.pop();
+            lowerer.diagSink = previousSink;
+        }
+        lowerer.diagSink = deferred;
+        try {
+            lowerer.collectClassShape(decl);
+        }
+        finally {
+            lowerer.diagSink = previousSink;
+        }
+        if (symbol && deferred.length) {
+            lowerer.deferredDiags.set(symbol, [...(lowerer.deferredDiags.get(symbol) ?? []), ...deferred]);
+            lowerer.deferredClassByName.set(lowerer.classNamer(decl), symbol);
+        }
+        lowerer.collecting = wasCollecting;
+    }
 }
 /** The npm-import chokepoint, run once per pass during collection (so
    * bodies lowered in ANY pass resolve the bindings). In a static build
@@ -272,7 +361,10 @@ export function collectProgram(lowerer, parts) {
    * site. Type-only imports are free either way: the .d.ts is a type
    * surface, not code. */
 export function collectNpmImports(lowerer, parts) {
-    const builder = lowerer.dynamic ? new NpmGraphBuilder() : null;
+    const services = lowerer.frontendServices;
+    if (lowerer.dynamic && services === undefined)
+        throw new Error("dynamic lowering requires frontend services");
+    const builder = lowerer.dynamic && services !== undefined ? new NpmGraphBuilder(services) : null;
     const entryPackageFile = entryPackageFilePredicate(lowerer.entry.fileName);
     for (const fp of parts) {
         for (const stmt of fp.sf.statements) {
@@ -646,15 +738,41 @@ export function moduleArtifacts(lowerer, functions) {
     const pendingClasses = [];
     const pendingShapes = [];
     const pendingUnions = [];
+    const boxedChild = (type, seen = new Set()) => {
+        switch (type.kind) {
+            case "child": return true;
+            case "array":
+            case "set": return boxedChild(type.elem, seen);
+            case "promise": return boxedChild(type.inner, seen);
+            case "map": return boxedChild(type.key, seen) || boxedChild(type.value, seen);
+            case "func": return boxedChild(type.ret, seen);
+            case "record":
+                if (seen.has(type.shapeId))
+                    return false;
+                seen.add(type.shapeId);
+                return lowerer.shapes.get(type.shapeId)?.fields.some((field) => boxedChild(field.type, seen)) ?? false;
+            case "union":
+                if (seen.has(type.unionId))
+                    return false;
+                seen.add(type.unionId);
+                return lowerer.unions.get(type.unionId)?.arms.some((arm) => boxedChild(arm, seen)) ?? false;
+            default: return false;
+        }
+    };
     const visit = (node) => {
         if (Array.isArray(node)) {
-            for (const item of node)
-                visit(item);
+            // This walk only reads compiler-owned arrays. A callback traversal
+            // reuses one checked view instead of refreshing it at each step.
+            node.forEach(visit);
             return;
         }
         if (node === null || typeof node !== "object")
             return;
         const rec = node;
+        if (rec["kind"] === "dynFrom" && boxedChild(rec["value"].type)) {
+            // A generic child can expose native stdio without importing stream.
+            visit([{ className: "%Readable" }, { className: "%Writable" }]);
+        }
         if (typeof rec["className"] === "string" && !classNames.has(rec["className"])) {
             classNames.add(rec["className"]);
             pendingClasses.push(rec["className"]);
@@ -672,15 +790,32 @@ export function moduleArtifacts(lowerer, functions) {
                 visit(rec[key]);
         }
     };
-    visit(functions);
-    visit(lowerer.globalsList);
+    // Keep function lists and their typed slots in native storage. Reflective
+    // array iteration refreshes a complete view at each step; only executable
+    // nodes and individual types need the general dependency walk.
+    for (const fn of functions) {
+        for (const param of fn.params)
+            visit(param.type);
+        visit(fn.returnType);
+        for (const local of fn.locals)
+            visit(local.type);
+        for (const capture of fn.captures ?? [])
+            visit(capture.type);
+        for (const capture of fn.classCaptures ?? [])
+            visit(capture.type);
+        visit(fn.generator);
+        for (const stmt of fn.body)
+            visit(stmt);
+    }
+    for (const global of lowerer.globalsList)
+        visit(global.type);
     // The builtin error classes ride EVERY module: the runtime's own throws
     // (JSON/dynCheck/regex failures) mint instances of them whether or not
     // user code mentions Error, and the uncaught printer tells Error
     // payloads apart by their preorder interval — which must therefore be
     // part of this program's numbering (backends stamp it into the
     // runtime's vtables at main).
-    for (const name of RUNTIME_ERROR_CLASSES.keys()) {
+    for (const name of [...RUNTIME_ERROR_CLASSES.keys()]) {
         if (!classNames.has(name)) {
             classNames.add(name);
             pendingClasses.push(name);
@@ -731,6 +866,8 @@ export function moduleArtifacts(lowerer, functions) {
             .map((c) => c.def)
             .filter((def) => classNames.has(def.name))
             .map((def) => {
+            if (!def)
+                throw new InternalCompilerError("missing reachable class definition");
             // Generic-class instantiations bypass the reachability gate
             // (demand-driven — every member of a demanded instantiation
             // lowers; see lowerClassMembers), so their defs keep every
@@ -738,18 +875,21 @@ export function moduleArtifacts(lowerer, functions) {
             // the same rule (noteVirtualEdge marks the abstract declarer, so
             // a dispatched slot keeps its declaration; an unreferenced one
             // drops and the root-most CONCRETE declaration owns the slot).
+            const className = def.name;
             const methods = reachable === null || def.genericOf !== undefined
                 ? (def.methods ?? [])
-                : (def.methods?.filter((m) => reachable.has(`%${def.name}.${m}`)) ?? []);
+                : (def.methods?.filter((m) => reachable.has(`%${className}.${m}`)) ?? []);
             const abstractMethods = def.abstractMethods?.filter((m) => methods.includes(m)) ?? [];
             const rest = { ...def };
-            delete rest.methods;
-            delete rest.abstractMethods;
-            return {
-                ...rest,
-                ...(methods.length > 0 ? { methods } : {}),
-                ...(abstractMethods.length > 0 ? { abstractMethods } : {}),
-            };
+            if (methods.length > 0)
+                rest.methods = methods;
+            else
+                delete rest.methods;
+            if (abstractMethods.length > 0)
+                rest.abstractMethods = abstractMethods;
+            else
+                delete rest.abstractMethods;
+            return rest;
         }),
         records: lowerer.shapes.shapes.filter((r) => shapeIds.has(r.id)),
         unions: lowerer.unions.unions.filter((u) => unionIds.has(u.id)),
@@ -789,20 +929,96 @@ function cjsScalarLiteral(e) {
  * a checked-dynamic (or unit) value, so a DYN module global can hold it:
  * no initializer, a unit literal, or a checker-`any` call/member/
  * identifier read (any-typed operations lower through the checked-dynamic tree in JS).
- * `new` expressions stay OUT even when checker-any (`new Anon.Sub()` over
+ * User-class `new` expressions stay OUT even when checker-any (`new Anon.Sub()` over
  * an expando class member constructs a TYPED instance — corpus 2032), as
  * does everything else (object/array literals have their own rules;
  * typed-but-unmappable initializers keep the %init-local adoption). */
+function checkedGlobalReference(lowerer, expression) {
+    if (ts.isIdentifier(expression))
+        return lowerer.globalOf(expression)?.type.kind === "dyn";
+    if (!ts.isPropertyAccessExpression(expression) || !ts.isIdentifier(expression.name) || !ts.isIdentifier(expression.expression))
+        return false;
+    const root = lowerer.checker.getSymbolAtLocation(expression.expression);
+    const namespace = root && lowerer.checker.declarationsOf(root).some(ts.isNamespaceImport);
+    return (namespace || lowerer.cjsLocalModuleBindingOf(expression.expression)) &&
+        lowerer.globalOf(expression.name)?.type.kind === "dyn";
+}
 function jsDynHoldableInitializer(lowerer, init) {
     if (init === undefined)
         return true;
+    if (isNativeProxyInitializer(lowerer, init))
+        return true;
     let e = init;
     while (ts.isParenthesizedExpression(e))
         e = e.expression;
+    if (checkedGlobalReference(lowerer, e))
+        return true;
+    if (ts.isCallExpression(e) && ts.isPropertyAccessExpression(e.expression) &&
+        ["freeze", "seal", "preventExtensions"].includes(e.expression.name.text) &&
+        lowerer.stdlibGlobalMember(e.expression, "Object") !== null && e.arguments[0] &&
+        ts.isArrayLiteralExpression(e.arguments[0]))
+        return true;
+    // The built-in Array constructor can create an evolving array whose
+    // inferred element type has no native mapping. Its checked reference
+    // must remain shared with separately declared functions and aliases.
+    if ((ts.isCallExpression(e) || ts.isNewExpression(e)) && lowerer.isStdlibGlobal(e.expression, "Array"))
+        return true;
+    // JavaScript process streams lower to native checked handles even when
+    // their declared method overloads prevent a structural type mapping.
+    // Register the shared slot before separately declared functions lower.
+    if (ts.isPropertyAccessExpression(e)) {
+        const member = lowerer.stdlibGlobalMember(e, "process");
+        if (member === "stdin" || member === "stdout" || member === "stderr")
+            return true;
+        if (e.name.text === "constructor" && lowerer.checker.getCallSignatures(lowerer.typeOf(e.expression)).length > 0)
+            return true;
+    }
     if (e.kind === ts.SyntaxKind.NullKeyword)
         return true;
     if (ts.isIdentifier(e) && e.text === "undefined")
         return true;
+    if (ts.isConditionalExpression(e)) {
+        return jsDynHoldableInitializer(lowerer, e.whenTrue) && jsDynHoldableInitializer(lowerer, e.whenFalse);
+    }
+    if (ts.isBinaryExpression(e) && (e.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken ||
+        e.operatorToken.kind === ts.SyntaxKind.BarBarToken || e.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken)) {
+        return jsDynHoldableInitializer(lowerer, e.left) && jsDynHoldableInitializer(lowerer, e.right);
+    }
+    // A member of a checked module value is itself checked, including a
+    // callable whose inferred overloads cannot describe one native ABI.
+    if ((ts.isPropertyAccessExpression(e) || ts.isElementAccessExpression(e)) &&
+        ts.isIdentifier(e.expression) && lowerer.globalOf(e.expression)?.type.kind === "dyn")
+        return true;
+    if (ts.isPropertyAccessExpression(e)) {
+        const member = nsMemberIdentOf(lowerer, e);
+        if (member && (lowerer.globalOf(member)?.type.kind === "dyn" || lowerer.genericFnOf(member)?.implicitParams))
+            return true;
+    }
+    // Optional callable reads (for example descriptor?.get) can be held in
+    // the same checked slot as a callable. Their nullish arm must remain
+    // observable by functions declared outside the module initializer.
+    if (ts.isPropertyAccessExpression(e) || ts.isElementAccessExpression(e) || ts.isCallExpression(e)) {
+        const fallback = lowerer.mapTypeOf(lowerer.typeOf(e)) ?? dynFallbackType(lowerer, e, lowerer.typeOf(e));
+        if (fallback?.kind === "func" && canBoxFuncIntoDyn(fallback, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))
+            return true;
+        const arms = fallback?.kind === "union" ? lowerer.unions.get(fallback.unionId)?.arms : undefined;
+        if (arms?.some(arm => arm.kind === "func") && arms.every(arm => isUnitType(arm) || (arm.kind === "func" && canBoxFuncIntoDyn(arm, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))))
+            return true;
+    }
+    if ((ts.isFunctionExpression(e) || ts.isArrowFunction(e)) && !e.typeParameters?.length && isJsSourceFile(e.getSourceFile()))
+        return true;
+    if (ts.isIdentifier(e) || ts.isArrowFunction(e) || ts.isFunctionExpression(e)) {
+        if (ts.isIdentifier(e)) {
+            if (lowerer.globalOf(e)?.type.kind === "dyn")
+                return true;
+            const signature = lowerer.isTopLevelFnSymbol(e) ? lowerer.fnSigOf(e) : null;
+            if (signature && canBoxFuncIntoDyn(funcTypeFromParamShapes(signature.params, signature.returnType), (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))
+                return true;
+        }
+        const type = lowerer.mapTypeOf(lowerer.typeOf(e)) ?? dynFallbackType(lowerer, e, lowerer.typeOf(e));
+        if (type?.kind === "func" && canBoxFuncIntoDyn(type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))
+            return true;
+    }
     if ((ts.isCallExpression(e) || ts.isPropertyAccessExpression(e) || ts.isIdentifier(e)) &&
         (lowerer.typeOf(e).flags & ts.TypeFlags.Any) !== 0) {
         return true;
@@ -902,7 +1118,9 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     if (!(symType.flags & ts.TypeFlags.Any))
                         tsType = symType;
                 }
-                let type = lowerer.mapTypeOf(tsType) ?? dynFallbackType(lowerer, stmt.expression, tsType) ?? lowerer.badType(stmt.expression, tsType);
+                let type = lowerer.mapTypeOf(tsType) ?? dynFallbackType(lowerer, stmt.expression, tsType);
+                if (type === null)
+                    lowerer.badType(stmt.expression, tsType);
                 // `export default undefined` — the unit-only union, like any
                 // unit-only binding (`export default null` maps via mapType).
                 if (type.kind === "void" && isUnitOnlyTsType(tsType)) {
@@ -1050,8 +1268,12 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     const diagsBefore = lowerer.diags.length;
                     try {
                         const strict = lowerer.typeOf(rhs);
-                        const t = lowerer.mapTypeOf(strict) ??
+                        let t = lowerer.mapTypeOf(strict) ??
                             (fnValued || factoryValued ? dynFallbackType(lowerer, rhs, strict) : null);
+                        // A returned object remains the live CommonJS root; later
+                        // exports.member writes must update that same open object.
+                        if (factoryValued && t?.kind === "record" && lowerer.dynConvertible(t))
+                            t = DYN;
                         if (t && t.kind !== "void") {
                             const g = { id: `%g.${tag}exports`, name: "exports", type: t, mutable: false };
                             lowerer.globalsByDeclNode.set(cjs.expr, g);
@@ -1145,7 +1367,8 @@ export function collectGlobals(lowerer, sf, topStmts) {
         // require('node:process')` aliases the global process
         // (stdlibGlobalAliasDecl's require form) so reads through the
         // binding lower via the process surface.
-        if (isRequireStatement(stmt)) {
+        if (isRequireStatement(stmt) && !(ts.isVariableStatement(stmt) &&
+            stmt.declarationList.declarations.some(decl => isNativeFfiRequire(lowerer, decl.initializer)))) {
             if (ts.isVariableStatement(stmt) &&
                 (stmt.declarationList.flags & ts.NodeFlags.Const) !== 0) {
                 for (const decl of stmt.declarationList.declarations) {
@@ -1370,7 +1593,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
             // `const require = createRequire(import.meta.url)` at file scope:
             // compile-time plumbing — no global storage; the statement
             // lowering skips it by the same test.
-            if (isConst && createRequireBindingDecl(lowerer, decl.name, decl.initializer))
+            if (createRequireBindingDecl(lowerer, decl.name, decl.initializer))
                 continue;
             // `const fs = require("node:fs")` through that binding at file
             // scope — a namespace import in const clothing, same story.
@@ -1413,17 +1636,52 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     })());
             if (stableStdlibAlias && stdlibGlobalAliasDecl(lowerer, decl.name, decl.initializer))
                 continue;
-            // Stored default TextEncoder/TextDecoder instances are the same
-            // compile-time alias plumbing as their statement lowering: calls
-            // trace this const initializer, so no module global exists.
-            if (isConst && textCodecBindingDecl(lowerer, decl.name, decl.initializer))
-                continue;
             // Destructuring declarations register EVERY bound identifier (the
             // desugar in the init function assigns the pre-registered globals,
             // exactly like plain declarations).
             for (const nameNode of boundIdentifiersOf(decl.name)) {
                 const diagsBefore = lowerer.diags.length;
                 try {
+                    // Checked JavaScript factories can expose inferred callables by
+                    // destructuring. Keep each exported binding in module storage so
+                    // separately lowered functions see the initialized value.
+                    if (isJsSourceFile(sf) && !ts.isIdentifier(decl.name) && decl.initializer &&
+                        !decl.type && !hasJsTypeAnnotation(decl) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode))) {
+                        const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
+                        if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
+                            const g = { id: `%g.${tag}${nsPrefix}${nameNode.text}`, name: nameNode.text,
+                                type: DYN, mutable: isLet, source: bindingSource(nameNode),
+                                ...(!isVarDeclared(decl) ? { tdz: true } : {}) };
+                            lowerer.globalsBySymbol.set(symbol, g);
+                            lowerer.globalsList.push(g);
+                            if (isVarDeclared(decl))
+                                noteVarGlobalEntryInit(lowerer, sf, g);
+                        }
+                        continue;
+                    }
+                    // Builtin declarations do not always describe the concrete native
+                    // callable ABI. Preserve checked-native values in shared storage;
+                    // adapting the loader to (string) would replace its validation.
+                    const initializer = decl.initializer ? stripTypeCasts(decl.initializer) : undefined;
+                    if (isJsSourceFile(sf) && nameNode === decl.name && initializer &&
+                        (isNativeBuiltinValueInitializer(lowerer, initializer) ||
+                            (!decl.type && !hasJsTypeAnnotation(decl) && lowerer.mapTypeOf(lowerer.typeOf(nameNode))?.kind === "date") ||
+                            (!decl.type && !hasJsTypeAnnotation(decl) && checkedGlobalReference(lowerer, initializer)) ||
+                            (!lowerer.dynamic && stdlibGlobalNameOf(lowerer, initializer) === "globalThis"))) {
+                        const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
+                        if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
+                            const g = {
+                                id: `%g.${tag}${nsPrefix}${nameNode.text}`, name: nameNode.text,
+                                type: DYN, mutable: isLet, source: bindingSource(nameNode),
+                                ...(!isVarDeclared(decl) ? { tdz: true } : {}),
+                            };
+                            lowerer.globalsBySymbol.set(symbol, g);
+                            lowerer.globalsList.push(g);
+                            if (isVarDeclared(decl))
+                                noteVarGlobalEntryInit(lowerer, sf, g);
+                        }
+                        continue;
+                    }
                     // A JS file-scope evolving ARRAY (`const mustCallChecks = [];`
                     // — test/common's exit-accounting ledger): the strict type
                     // (any[]) has no mapping, but the VALUE is the dyn array the
@@ -1445,6 +1703,25 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         continue;
                     }
                     // A JS file-scope OBJECT LITERAL (`const input = { foo: 'bar' }`
+                    // Methods and computed properties require live checked storage:
+                    // symbol identity and a method's receiver cannot be reconstructed
+                    // from a copied, inferred record shape.
+                    if (isJsSourceFile(sf) && ts.isIdentifier(decl.name) && nameNode === decl.name &&
+                        decl.initializer && ts.isObjectLiteralExpression(decl.initializer) &&
+                        decl.initializer.properties.some((p) => !ts.isSpreadAssignment(p) &&
+                            (ts.isMethodDeclaration(p) || ts.isAccessor(p) || ts.isComputedPropertyName(p.name) ||
+                                ts.isShorthandPropertyAssignment(p) && lowerer.checker.getCallSignatures(lowerer.typeOf(p.name)).length > 0))) {
+                        const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
+                        if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
+                            const g = { id: `%g.${tag}${nsPrefix}${nameNode.text}`, name: nameNode.text, type: DYN, mutable: isLet, source: bindingSource(nameNode) };
+                            lowerer.globalsBySymbol.set(symbol, g);
+                            lowerer.globalsList.push(g);
+                            if (isVarDeclared(decl))
+                                noteVarGlobalEntryInit(lowerer, sf, g);
+                        }
+                        continue;
+                    }
+                    // A JS file-scope OBJECT LITERAL (`const input = { foo: 'bar' }`
                     // — the Node-suite trace-context idiom): JS object identity is
                     // the literal's contract — the SAME object flows into untyped
                     // callees, gets stamped by them, and is compared back against
@@ -1456,12 +1733,17 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // dyn-representable (unmappable member types are the checked-dynamic tree
                     // fallback's own case) — so shorthand aggregates (test/common's
                     // export object: alias plumbing importers resolve THROUGH),
-                    // spreads, accessors, and literals holding unconvertible typed
+                    // accessors, and literals holding unconvertible typed
                     // values (a Map member) keep their static/alias stories.
+                    // Spreads from an existing checked dictionary stay checked too;
+                    // copying its entries must not extract nested callable records.
                     if (isJsSourceFile(sf) &&
                         ts.isIdentifier(decl.name) && nameNode === decl.name &&
                         decl.initializer !== undefined && ts.isObjectLiteralExpression(decl.initializer) &&
                         decl.initializer.properties.every((p) => {
+                            if (ts.isSpreadAssignment(p)) {
+                                return ts.isIdentifier(p.expression) && lowerer.globalOf(p.expression)?.type.kind === "dyn";
+                            }
                             if (!ts.isPropertyAssignment(p) || ts.isComputedPropertyName(p.name))
                                 return false;
                             const mt = lowerer.mapTypeOf(lowerer.typeOf(p.initializer));
@@ -1526,6 +1808,38 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         }
                         continue;
                     }
+                    // A function initializer can have a native calling convention
+                    // even when its inferred return/parameter pieces need DYN. Keep
+                    // that closure in a checked-value global so class methods and
+                    // other module functions see its declaration-position assignment.
+                    // A var starts undefined; lexical bindings retain the TDZ guard.
+                    if (isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)) &&
+                        ts.isIdentifier(decl.name) && nameNode === decl.name && decl.initializer &&
+                        jsDynHoldableInitializer(lowerer, decl.initializer)) {
+                        const initializer = decl.initializer;
+                        const member = ts.isPropertyAccessExpression(initializer) ? nsMemberIdentOf(lowerer, initializer) : null;
+                        const generic = member && lowerer.genericFnOf(member);
+                        const fallback = (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) && !initializer.typeParameters?.length
+                            ? lowerer.lambdaSignature(initializer).funcType
+                            : member && lowerer.globalOf(member)?.type.kind === "dyn" ? DYN
+                                : member && generic?.implicitParams ? lowerer.lowerGenericFnValue(member, generic).type
+                                    : dynFallbackType(lowerer, nameNode, lowerer.typeOf(nameNode));
+                        const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
+                        if (symbol && fallback && (fallback.kind === "dyn" || fallback.kind === "func" || fallback.kind === "union") && lowerer.dynConvertible(fallback)) {
+                            if (!lowerer.globalsBySymbol.has(symbol)) {
+                                const g = {
+                                    id: `%g.${tag}${nsPrefix}${nameNode.text}`, name: nameNode.text,
+                                    type: DYN, mutable: isLet, source: bindingSource(nameNode),
+                                    ...(!isVarDeclared(decl) ? { tdz: true } : {}),
+                                };
+                                lowerer.globalsBySymbol.set(symbol, g);
+                                lowerer.globalsList.push(g);
+                                if (isVarDeclared(decl))
+                                    noteVarGlobalEntryInit(lowerer, sf, g);
+                            }
+                            continue;
+                        }
+                    }
                     // JS declarations whose STRICT type has no mapping register no
                     // global at all: the declaration lowers as an %init-body LOCAL
                     // whose type adopts the initializer's (lowerVarDecl's JS
@@ -1533,7 +1847,10 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // and closures created in the init body capture it normally.
                     // References from separately-declared functions cascade to
                     // their own per-site runtime fences.
-                    if (isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)))
+                    const factoryType = !isLet && isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) &&
+                        ts.isIdentifier(decl.name) && nameNode === decl.name && decl.initializer && ts.isNewExpression(decl.initializer)
+                        ? objectFactorySignature(lowerer, decl.initializer)?.returnType : undefined;
+                    if (!factoryType && isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)))
                         continue;
                     // `var p1 = import("./m")` at file scope: the global holds the
                     // island promise/handle — the import expression's only
@@ -1541,13 +1858,81 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // (lowerVarDecl's rule at module scope; the init body assigns
                     // it).
                     const handleT = ts.isIdentifier(decl.name) && nameNode === decl.name
-                        ? (lowerer.dynamic ? importCallHandleType(decl.initializer) : staticImportNamespaceType(lowerer, decl.initializer)) ??
+                        ? (isNativeProxyInitializer(lowerer, decl.initializer) ? DYN : null) ??
+                            (lowerer.dynamic ? importCallHandleType(decl.initializer) : staticImportNamespaceType(lowerer, decl.initializer)) ??
                             (lowerer.dynamic ?
                                 // An unchecked-overload call result stores the handle,
                                 // exactly the local rule (uncheckedOverloadHandleCall).
                                 (uncheckedOverloadHandleCall(lowerer, decl.initializer) ? JSVAL : null) : null)
                         : null;
-                    let type = handleT ?? lowerer.irTypeOf(nameNode);
+                    // Unannotated results of JavaScript calls can carry callable
+                    // objects or heterogeneous unions absent from the native type
+                    // map. Their compiled initializer still validates every crossing.
+                    const callSignature = !decl.type && !hasJsTypeAnnotation(decl) && decl.initializer && ts.isCallExpression(decl.initializer)
+                        ? lowerer.checker.getResolvedSignature(decl.initializer) : undefined;
+                    const callDeclaration = callSignature && lowerer.checker.signatureDeclaration(callSignature);
+                    const inferredJsCall = callDeclaration && isJsSourceFile(callDeclaration.getSourceFile()) &&
+                        !lowerer.mapTypeOf(lowerer.typeOf(nameNode));
+                    let type = handleT ?? factoryType ?? (inferredJsCall ? DYN : lowerer.irTypeOf(nameNode));
+                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && decl.initializer &&
+                        (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) &&
+                        !decl.initializer.typeParameters?.length) {
+                        type = lowerer.lambdaSignature(decl.initializer).funcType;
+                    }
+                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) &&
+                        decl.initializer && ts.isCallExpression(decl.initializer) && type.kind === "union") {
+                        const arms = lowerer.unions.get(type.unionId)?.arms;
+                        if (arms?.some((arm) => arm.kind === "record") && arms.every((arm) => isUnitType(arm) || arm.kind === "record"))
+                            type = DYN;
+                    }
+                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && decl.initializer &&
+                        ts.isNewExpression(decl.initializer) && lowerer.mapTypeOf(lowerer.typeOf(decl.initializer.expression))?.kind === "dyn" &&
+                        !(ts.isIdentifier(decl.initializer.expression) && lowerer.isStdlibSymbol(lowerer.checker.getSymbolAtLocation(decl.initializer.expression))))
+                        type = DYN;
+                    // Calls through checked function values retain their object
+                    // identity, including symbol keys absent from inferred records.
+                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && type.kind === "record" &&
+                        decl.initializer && ts.isCallExpression(decl.initializer) &&
+                        ts.isIdentifier(decl.initializer.expression) && lowerer.globalOf(decl.initializer.expression)?.type.kind === "dyn") {
+                        type = DYN;
+                    }
+                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && type.kind === "record" &&
+                        decl.initializer && ts.isCallExpression(decl.initializer) &&
+                        ts.isPropertyAccessExpression(decl.initializer.expression) &&
+                        lowerer.stdlibGlobalMember(decl.initializer.expression, "Object") === "assign" &&
+                        decl.initializer.arguments.some((arg) => ts.isIdentifier(arg) && lowerer.globalOf(arg)?.type.kind === "dyn")) {
+                        type = DYN;
+                    }
+                    // Runtime-arity JavaScript callables can be returned by a
+                    // checked factory. Keep that callable boxed instead of asking
+                    // a fixed-signature adapter to reconstruct its hidden rest ABI.
+                    if (!decl.type && !hasJsTypeAnnotation(decl) && type.kind === "func" && type.rest === true && type.restAbi === undefined)
+                        type = DYN;
+                    if (isJsSourceFile(sf) && isLet && !decl.type && !hasJsTypeAnnotation(decl) &&
+                        (type.kind === "object" || jsBindingHasOpenWrites(lowerer, decl)))
+                        type = DYN;
+                    // JavaScript call results may retain a checked array supplied by
+                    // the caller. A typed global here would copy it on extraction.
+                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && type.kind === "array" &&
+                        decl.initializer && ts.isCallExpression(decl.initializer))
+                        type = DYN;
+                    // Unannotated JavaScript aliases retain an existing native
+                    // checked object instead of copying it into an inferred record.
+                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) &&
+                        decl.initializer && ts.isIdentifier(decl.initializer) &&
+                        (type.kind === "record" || type.kind === "func")) {
+                        const source = lowerer.globalOf(decl.initializer);
+                        if (source?.type.kind === "dyn")
+                            type = DYN;
+                    }
+                    // JavaScript bind inference can leave an artificial tuple-rest
+                    // signature. Keep the returned callable's runtime arity intact.
+                    if (isJsSourceFile(sf) && type.kind === "func" && decl.initializer &&
+                        ts.isCallExpression(decl.initializer) && ts.isPropertyAccessExpression(decl.initializer.expression) &&
+                        decl.initializer.expression.name.text === "bind" && lowerer.isStdlibMember(decl.initializer.expression) &&
+                        decl.type === undefined && !hasJsTypeAnnotation(decl)) {
+                        type = DYN;
+                    }
                     // An evolving-`any` array's DERIVED file-scope binding under
                     // --dynamic (`const kept = fns.filter(...)` where `fns`
                     // registered array<jsval> at its `any[]` declaration): the
@@ -1608,7 +1993,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // adapter would re-copy at the assignment.
                     if (isJsSourceFile(sf) &&
                         type.kind === "func" &&
-                        type.ret.kind === "record" &&
+                        (type.ret.kind === "date" || type.ret.kind === "record" && lowerer.dynConvertible(type.ret)) &&
                         decl.initializer !== undefined &&
                         (ts.isFunctionExpression(decl.initializer) || ts.isArrowFunction(decl.initializer)) &&
                         decl.initializer.type === undefined &&
@@ -1624,6 +2009,20 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         if (shape && shape.fields.length === 0 && !shape.indexValue && !shape.tuple)
                             type = DYN;
                     }
+                    // Module vars hold real undefined until their declaration runs.
+                    // Unannotated JS function values need that state too: callers
+                    // before the initializer must see undefined and a TypeError.
+                    if (isJsSourceFile(sf) && isVarDeclared(decl) && type.kind === "func" && lowerer.dynConvertible(type))
+                        type = DYN;
+                    // Codec records keep that state in the ordinary optional union;
+                    // lexical codec declarations retain their separate TDZ guard.
+                    const codec = type.kind === "record" && recordTextCodecClass(lowerer.shapes.get(type.shapeId)) !== null;
+                    if (codec && isVarDeclared(decl)) {
+                        type = { kind: "union", unionId: lowerer.unions.intern([type, { kind: "undefinedT" }]) };
+                    }
+                    else if (codec && !decl.initializer) {
+                        lowerer.noLowering("uninitialized lexical codec bindings", decl, "initialize let or const TextEncoder/TextDecoder bindings at their declaration");
+                    }
                     const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                     // Merged `var` redeclarations (`var y = 1; ...; var y = 2;` —
                     // one symbol) register exactly one global; later declarations
@@ -1636,6 +2035,10 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         type,
                         mutable: isLet,
                         source: bindingSource(nameNode),
+                        // A function pointer must not be dereferenced before a lexical
+                        // declaration assigns it. The shared pointer TDZ guard handles
+                        // these bindings like stored codec records.
+                        ...(((codec || type.kind === "func") && !isVarDeclared(decl)) ? { tdz: true } : {}),
                     };
                     lowerer.globalsBySymbol.set(symbol, g);
                     lowerer.globalsList.push(g);
@@ -1757,6 +2160,9 @@ function collectNestedVarGlobals(lowerer, sf, stmt, tag) {
                         if (shape && shape.fields.length === 0 && !shape.indexValue && !shape.tuple)
                             type = DYN;
                     }
+                    if (type.kind === "record" && recordTextCodecClass(lowerer.shapes.get(type.shapeId)) !== null) {
+                        type = { kind: "union", unionId: lowerer.unions.intern([type, { kind: "undefinedT" }]) };
+                    }
                     const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                     if (!symbol || lowerer.globalsBySymbol.has(symbol))
                         continue;
@@ -2011,7 +2417,7 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
         // SITE's position instead (below) — their inner class node may
         // even live in another file.
         c.decl && ts.isClassDeclaration(c.decl) && !c.mixinInstance && c.decl.getSourceFile() === sf &&
-            (c.staticFields.length > 0 || (c.staticBlocks?.length ?? 0) > 0 || c.classDecorators !== undefined))
+            (c.callableBase !== undefined || c.def.baseValueGlobal !== undefined || c.staticFields.length > 0 || (c.staticBlocks?.length ?? 0) > 0 || c.classDecorators !== undefined))
             .map((c) => ({ pos: c.decl.getStart(), info: c }));
         // Statics-bearing MIXIN instantiations whose call evaluates in THIS
         // file: their declaration-time code runs when the call does — the