@scriptc/compiler 0.2.0 → 0.2.2

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

@@ -1,3 +1,4 @@
+import { everyStmtList, everyTypeChild } from "../../ir/traverse.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Module-graph lowering: splitting each source file into its parts, the
  * program-collection pass (signatures, classes, globals — reachability
@@ -16,16 +17,16 @@ import { BOOL, DYN, F64, JSVAL, RUNTIME_ERROR_CLASSES, STRING, VOID, arrayOf, ca
 import { ENTRY_NAME, PoisonError, boundIdentifiersOf, dynFallbackType, dynUndefinedExpr, importCallHandleType, newFnCtx, staticImportNamespaceType, uncheckedOverloadHandleCall } from "./lowerer.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 { hasJsTypeAnnotation, isVarDeclared, numericIteratorSourceOf, provenanceElidedConstDecl } from "./lower-stmts.js";
-import { objectFactorySignature } from "./object-factory-new.js";
+import { jsBindingHasOpenWrites, hasJsTypeAnnotation, isVarDeclared, numericIteratorSourceOf, provenanceElidedConstDecl } from "./lower-stmts.js";
+import { objectFactoryGlobalType } from "./object-factory-new.js";
 import { streamClassAliasDecl } from "./lower-stream.js";
 import { stdlibGlobalAliasDecl, stdlibGlobalAliasNameOf, stdlibGlobalNameOf } from "./surfaces.js";
 import { isNativeBuiltinValueInitializer } from "./lower-builtin-values.js";
-import { collectNamespaceStmt, nsPathPrefix, trapDeclRootOf } from "./lower-namespaces.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 { collectVirtualJsMethods, decoratorNodesOf, genericIfaceBindingKeepsClass, guaranteedDecorationThrow } from "./lower-classes.js";
+import { collectInheritedJsFieldWrites, 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";
@@ -228,12 +229,42 @@ 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));
+        collectInheritedJsFieldWrites(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);
@@ -263,6 +294,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
@@ -640,49 +725,172 @@ export function collectJsonImports(lowerer, parts) {
 /** The classes, records, and unions the emitted module carries: exactly
    * what the lowered functions and globals reference, closed transitively
    * over record fields, union arms, class field types, base chains, and
-   * WHOLE hierarchies (hierarchy membership decides object layout:
-   * dropping an unused subclass must not turn its base into a standalone
-   * class at emit time). Registry entries interned while collecting
+   * constructible descendants and their base chains. Registry entries interned while collecting
    * signatures nothing reaches stay out — an unreached type leaves no
    * trace. A referenced class with no registration had its collection
    * deferred: the reference flushes those diagnostics. Methods whose
    * bodies were not lowered leave the def's method list, so vtable slots
    * exist exactly for emitted overrides. */
 export function moduleArtifacts(lowerer, functions) {
+    const valueInstanceOfRoots = new Set();
     const classNames = new Set();
     const shapeIds = new Set();
     const unionIds = new Set();
     const pendingClasses = [];
     const pendingShapes = [];
     const pendingUnions = [];
-    const visit = (node) => {
-        if (Array.isArray(node)) {
-            for (const item of node)
-                visit(item);
-            return;
+    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;
         }
-        if (node === null || typeof node !== "object")
+    };
+    const visitClass = (name) => {
+        if (classNames.has(name))
             return;
-        const rec = node;
-        if (typeof rec["className"] === "string" && !classNames.has(rec["className"])) {
-            classNames.add(rec["className"]);
-            pendingClasses.push(rec["className"]);
-        }
-        if (typeof rec["shapeId"] === "string" && !shapeIds.has(rec["shapeId"])) {
-            shapeIds.add(rec["shapeId"]);
-            pendingShapes.push(rec["shapeId"]);
-        }
-        if (typeof rec["unionId"] === "string" && !unionIds.has(rec["unionId"])) {
-            unionIds.add(rec["unionId"]);
-            pendingUnions.push(rec["unionId"]);
-        }
-        for (const key of Object.keys(rec)) {
-            if (key !== "loc")
-                visit(rec[key]);
+        classNames.add(name);
+        pendingClasses.push(name);
+    };
+    const visitShape = (id) => {
+        if (shapeIds.has(id))
+            return;
+        shapeIds.add(id);
+        pendingShapes.push(id);
+    };
+    const visitUnion = (id) => {
+        if (unionIds.has(id))
+            return;
+        unionIds.add(id);
+        pendingUnions.push(id);
+    };
+    const visitType = (type) => {
+        switch (type.kind) {
+            case "object":
+            case "classval":
+                visitClass(type.className);
+                break;
+            case "record":
+                visitShape(type.shapeId);
+                break;
+            case "union":
+                visitUnion(type.unionId);
+                break;
         }
+        return everyTypeChild(type, visitType);
+    };
+    const visitor = {
+        expr: (node) => {
+            visitType(node.type);
+            switch (node.kind) {
+                case "fieldIncDec":
+                case "new":
+                case "classRef":
+                case "instanceOf":
+                case "virtualCall":
+                case "fieldGet":
+                case "caughtCheck":
+                    visitClass(node.className);
+                    break;
+                case "caughtTest":
+                    if (node.className !== undefined)
+                        visitClass(node.className);
+                    break;
+                case "recordGet":
+                case "recordKeyGet":
+                case "recordOvfKeys":
+                case "recordOvfHas":
+                    visitShape(node.shapeId);
+                    break;
+                case "unionWrap":
+                case "unionFuncEq":
+                case "unionNarrow":
+                case "unionDisc":
+                case "unionKeyGet":
+                case "unionIsTag":
+                case "unionEq":
+                    visitUnion(node.unionId);
+                    break;
+                case "yieldExpr":
+                    if (node.captureCompletion !== undefined)
+                        visitType(node.captureCompletion.returnType);
+                    break;
+                case "instanceOfValue":
+                    for (const type of [node.value.type, node.classValue.type]) {
+                        if (type.kind !== "object" && type.kind !== "classval")
+                            continue;
+                        let root = lowerer.classes.get(type.className);
+                        if (!root)
+                            continue;
+                        while (root.base)
+                            root = root.base;
+                        valueInstanceOfRoots.add(root.def.name);
+                    }
+                    break;
+                case "dynFrom":
+                    if (boxedChild(node.value.type)) {
+                        // A generic child can expose native stdio without importing stream.
+                        visitClass("%Readable");
+                        visitClass("%Writable");
+                    }
+                    break;
+                default:
+                    // A new node with a named artifact reference must join this switch.
+                    node;
+            }
+            return true;
+        },
+        stmt: (node) => {
+            switch (node.kind) {
+                case "fieldSet":
+                    visitClass(node.className);
+                    break;
+                case "recordSet":
+                case "recordKeySet":
+                case "recordKeyDelete":
+                    visitShape(node.shapeId);
+                    break;
+                default:
+                    node;
+            }
+            return true;
+        },
     };
-    visit(functions);
-    visit(lowerer.globalsList);
+    // Visit compiler-owned typed storage and executable trees directly, without
+    // creating dynamic snapshots of every node's properties and metadata.
+    for (const fn of functions) {
+        for (const param of fn.params)
+            visitType(param.type);
+        visitType(fn.returnType);
+        for (const local of fn.locals)
+            visitType(local.type);
+        for (const capture of fn.captures ?? [])
+            visitType(capture.type);
+        for (const capture of fn.classCaptures ?? [])
+            visitType(capture.type);
+        if (fn.generator !== undefined) {
+            visitType(fn.generator.yieldT);
+            visitType(fn.generator.nextT);
+            visitType(fn.generator.resultType);
+        }
+        everyStmtList(fn.body, visitor);
+    }
+    for (const global of lowerer.globalsList)
+        visitType(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
@@ -703,12 +911,19 @@ export function moduleArtifacts(lowerer, functions) {
             // overflow-valued shape (`{ [key: string]: {script?: string} }`)
             // references its value shape through indexValue alone.
             const shape = lowerer.shapes.get(pendingShapes.pop());
-            visit(shape?.fields);
-            if (shape?.indexValue)
-                visit(shape.indexValue);
+            if (shape !== undefined) {
+                for (const field of shape.fields)
+                    visitType(field.type);
+                if (shape.indexValue !== undefined)
+                    visitType(shape.indexValue);
+            }
+        }
+        while (pendingUnions.length > 0) {
+            const union = lowerer.unions.get(pendingUnions.pop());
+            if (union !== undefined)
+                for (const arm of union.arms)
+                    visitType(arm);
         }
-        while (pendingUnions.length > 0)
-            visit(lowerer.unions.get(pendingUnions.pop())?.arms);
         while (pendingClasses.length > 0) {
             const name = pendingClasses.pop();
             const info = lowerer.classes.get(name);
@@ -718,15 +933,17 @@ export function moduleArtifacts(lowerer, functions) {
                 lowerer.flushDeferredClass(name);
                 continue;
             }
-            visit(info.def.fields);
+            for (const field of info.def.fields)
+                visitType(field.type);
             if (info.base)
-                visit([{ className: info.base.def.name }]);
+                visitClass(info.base.def.name);
             if (lowerer.inHierarchy(info)) {
                 let root = info;
                 while (root.base)
                     root = root.base;
                 const wholeTree = (c) => {
-                    visit([{ className: c.def.name }]);
+                    if (valueInstanceOfRoots.has(root.def.name) || lowerer.classCanBeConstructed(c))
+                        visitClass(c.def.name);
                     for (const s of c.subclasses)
                         wholeTree(s);
                 };
@@ -803,7 +1020,7 @@ 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). */
@@ -827,6 +1044,16 @@ function jsDynHoldableInitializer(lowerer, init) {
         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.
@@ -834,6 +1061,8 @@ function jsDynHoldableInitializer(lowerer, init) {
         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;
@@ -851,6 +1080,11 @@ function jsDynHoldableInitializer(lowerer, init) {
     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.
@@ -862,6 +1096,8 @@ function jsDynHoldableInitializer(lowerer, init) {
         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")
@@ -976,6 +1212,10 @@ export function collectGlobals(lowerer, sf, topStmts) {
                 let type = lowerer.mapTypeOf(tsType) ?? dynFallbackType(lowerer, stmt.expression, tsType);
                 if (type === null)
                     lowerer.badType(stmt.expression, tsType);
+                // Inferred JavaScript factory exports keep their original value,
+                // including callable objects decorated with Object.assign.
+                if (isJsSourceFile(sf) && ts.isCallExpression(stmt.expression) && type.kind === "record" && lowerer.dynConvertible(type))
+                    type = DYN;
                 // `export default undefined` — the unit-only union, like any
                 // unit-only binding (`export default null` maps via mapType).
                 if (type.kind === "void" && isUnitOnlyTsType(tsType)) {
@@ -1024,16 +1264,9 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     const t = lowerer.mapTypeOf(strict) ?? dynFallbackType(lowerer, nameNode, strict);
                     if (!t || t.kind === "void")
                         lowerer.badType(typeNode, strict);
-                    // `module.exports.Strings = Strings` naming a dyn-HOLDING
-                    // const (the JS file-scope object-literal identity story): the
-                    // export ALIASES the const's own dyn global — one storage, one
-                    // owner, identity by construction (a record-typed second slot
-                    // would either copy or mismatch the dyn value — that mismatch
-                    // was an ICE; a second same-named global double-released at
-                    // teardown). The statement's assign degenerates to a harmless
-                    // self-assign. Mutable (`let`) sources keep the registration
-                    // below: Node copies the VALUE at this statement, and separate
-                    // storage is exactly that copy.
+                    // An immutable export source shares its live storage and native
+                    // callable ABI. Mutable sources need a separate snapshot slot:
+                    // later writes to the binding do not change the exported value.
                     {
                         let rhs = typeNode;
                         while (ts.isParenthesizedExpression(rhs))
@@ -1041,19 +1274,14 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         if (ts.isIdentifier(rhs)) {
                             const vSym = lowerer.checker.getSymbolAtLocation(rhs);
                             const vG = vSym && lowerer.globalsBySymbol.get(vSym);
-                            if (vG?.type.kind === "dyn") {
+                            if (vG) {
                                 if (!vG.mutable) {
                                     lowerer.globalsBySymbol.set(symbol, vG);
                                     for (const d of lowerer.checker.declarationsOf(symbol))
                                         lowerer.globalsByDeclNode.set(d, vG);
                                     return;
                                 }
-                                // A mutable (`let`) dyn source: separate DYN storage IS
-                                // Node's copy-of-the-reference at this statement (later
-                                // reassignments of the let stay invisible through the
-                                // export). The id must not collide with the let's own
-                                // `%g.<tag><name>` global.
-                                const g = { id: `%g.${tag}%export.${name}`, name, type: DYN, mutable: false };
+                                const g = { id: `%g.${tag}%export.${name}`, name, type: vG.type, mutable: false };
                                 lowerer.globalsBySymbol.set(symbol, g);
                                 for (const d of lowerer.checker.declarationsOf(symbol))
                                     lowerer.globalsByDeclNode.set(d, g);
@@ -1062,7 +1290,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                             }
                         }
                     }
-                    const g = { id: `%g.${tag}${name}`, name, type: t, mutable: false };
+                    const g = { id: `%g.${tag}%export.${name}`, name, type: t, mutable: false };
                     lowerer.globalsBySymbol.set(symbol, g);
                     // Importer aliases resolve to a DISTINCT late-bound symbol with
                     // the same declaration — key the node too (globalOf's fallback).
@@ -1123,8 +1351,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);
@@ -1493,6 +1725,23 @@ export function collectGlobals(lowerer, sf, topStmts) {
             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.
@@ -1543,7 +1792,8 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     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.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) };
@@ -1649,9 +1899,16 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     if (isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)) &&
                         ts.isIdentifier(decl.name) && nameNode === decl.name && decl.initializer &&
                         jsDynHoldableInitializer(lowerer, decl.initializer)) {
-                        const fallback = dynFallbackType(lowerer, nameNode, lowerer.typeOf(nameNode));
+                        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 === "func" || fallback.kind === "union") && lowerer.dynConvertible(fallback)) {
+                        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,
@@ -1675,9 +1932,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // their own per-site runtime fences.
                     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;
+                        ? objectFactoryGlobalType(lowerer, decl.initializer) ?? undefined : undefined;
                     // `var p1 = import("./m")` at file scope: the global holds the
                     // island promise/handle — the import expression's only
                     // production — whatever the checker's namespace type mapped to
@@ -1691,12 +1946,53 @@ export function collectGlobals(lowerer, sf, topStmts) {
                                 // exactly the local rule (uncheckedOverloadHandleCall).
                                 (uncheckedOverloadHandleCall(lowerer, decl.initializer) ? JSVAL : null) : null)
                         : null;
-                    let type = handleT ?? factoryType ?? lowerer.irTypeOf(nameNode);
+                    // JavaScript factory results with unmappable annotations still
+                    // need shared storage. Unannotated callable unions also use a
+                    // checked slot; mappable authored annotations keep their layout.
+                    const unannotatedCall = !decl.type && !hasJsTypeAnnotation(decl);
+                    const callSignature = (isJsSourceFile(sf) || unannotatedCall) && decl.initializer && ts.isCallExpression(decl.initializer)
+                        ? lowerer.checker.getResolvedSignature(decl.initializer) : undefined;
+                    const callDeclaration = callSignature && lowerer.checker.signatureDeclaration(callSignature);
+                    const callType = callDeclaration && isJsSourceFile(callDeclaration.getSourceFile())
+                        ? lowerer.mapTypeOf(lowerer.typeOf(nameNode)) : null;
+                    const inferredJsCall = callDeclaration && isJsSourceFile(callDeclaration.getSourceFile()) &&
+                        (!callType || unannotatedCall && callType.kind === "union" && lowerer.unions.get(callType.unionId)?.arms.some((arm) => arm.kind === "func"));
+                    if (!factoryType && !inferredJsCall && isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)))
+                        continue;
+                    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;
+                    }
+                    // Namespace aliases of inferred helpers carry the helper's
+                    // settled callable, whose return can differ from checker inference.
+                    // Keep a shared checked slot before any consumer specializes it.
+                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && type.kind === "func" &&
+                        decl.initializer && ts.isPropertyAccessExpression(decl.initializer)) {
+                        const member = nsMemberIdentOf(lowerer, decl.initializer);
+                        if (member && lowerer.genericFnOf(member)?.implicitParams)
+                            type = DYN;
+                        else if (member) {
+                            const source = lowerer.globalOf(member);
+                            if (source?.type.kind === "func")
+                                type = source.type;
+                        }
+                    }
+                    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") {
+                        decl.initializer && ts.isCallExpression(decl.initializer) && lowerer.dynConvertible(type)) {
                         type = DYN;
                     }
                     if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && type.kind === "record" &&
@@ -1711,11 +2007,18 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // 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;
+                    if (!lowerer.dynamic && isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) &&
+                        decl.initializer && ts.isNewExpression(decl.initializer) && lowerer.isStdlibGlobal(decl.initializer.expression, "Array") &&
+                        (type.kind !== "array" || type.elem.kind === "dyn"))
+                        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) &&
@@ -1793,8 +2096,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // adapter would re-copy at the assignment.
                     if (isJsSourceFile(sf) &&
                         type.kind === "func" &&
-                        type.ret.kind === "record" &&
-                        lowerer.dynConvertible(type.ret) &&
+                        (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 &&
@@ -1811,6 +2113,10 @@ export function collectGlobals(lowerer, sf, topStmts) {
                             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;
@@ -2214,7 +2520,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.callableBase !== undefined || c.staticFields.length > 0 || (c.staticBlocks?.length ?? 0) > 0 || c.classDecorators !== undefined))
+            (c.callableBase !== undefined || c.def.baseValueGlobal !== undefined || c.runtimeStatics !== 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
@@ -2240,7 +2546,8 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
                 body.push(...lowerer.lowerStaticFieldInits(statics[at].info));
                 at++;
             }
-            const stmtIr = lowerer.lowerStmts([stmt]);
+            const deferred = lowerer.deferredModuleInitializers?.defer(lowerer, stmt);
+            const stmtIr = deferred ? [deferred] : lowerer.lowerStmts([stmt]);
             // Class EXPRESSIONS inside this statement queued their static
             // inits while it lowered: they land immediately before it — JS's
             // order for the supported whole-initializer positions.