@scriptc/compiler 0.0.10 → 0.0.12

package/dist/frontend/lowering/lowerer.js

@@ -19,14 +19,15 @@ import { arrayOf, BOOL, canAdaptDynFuncTo, canConvertToDyn, canCrossIslandBounda
 import { provenanceActive } from "../provenance-registry.js";
 import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, overridesDtsPath, npmStaticDepSf7, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
 import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, formatIrType, ISLAND_AMBIENT_TYPES, isUnitOnlyTsType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../types.js";
-import { boundaryIntoIslandMsg, boundaryOutOfIslandMsg, builtinConstLit, builtinModuleConstOf, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalMember, nodeTypesOnlySymbol } from "./surfaces.js";
+import { boundaryIntoIslandMsg, boundaryOutOfIslandMsg, builtinConstLit, builtinModuleConstOf, builtinModulesArrayLit, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalMember, nodeTypesOnlySymbol } from "./surfaces.js";
 import { splitFiles, collectProgram, collectNpmImports, collectJsonImports, moduleArtifacts, collectGlobals, declSymbolOf, defaultExportSymbolOf, lowerFileInit, lowerDefaultExport, buildMain, appendDynamicImportModules } from "./lower-modules.js";
 import { registerBuiltinErrorClasses, registerBuiltinEmitterClass, registerBuiltinStreamClasses, builtinErrorInfoOf, builtinEmitterInfoOf, builtinStreamInfoOf, analyzeClassDecoration, classIteratorDrainCall, classIteratorNextCall, classIteratorOf, classIteratorOpenCall, classIteratorRestDrainCall, classMemberNameOf, classValueRef, collectClassShape, exactClassOfReceiver, collectClassShapeInner, ctorAbiEquals, findMethodOn, findStaticOn, findGenericMethodOn, findGenericStaticOn, genericClassInstanceType, isSubclassOf, inHierarchy, overrideBelow, staticShadowBelow, upcastTo, lowerClassMembers, lowerClassCtor, lowerClassExpression, lowerClassExpressionInfo, lowerClassMethodMember, lowerClassValueProperty, lowerStaticMethod, throwingSetterFn, fieldInitStmts, lowerStaticFieldInits, lowerStaticFieldRead, lowerDerivedCtorBody, superCallStmt, lowerSuperMethodCall, superThisRef, lowerSuperAccessorRead, lowerSuperAccessorWrite, inheritsBuiltinErrorCtor, inheritsBuiltinEmitterCtor, errorMessageArg, lowerNew, accessorCall } from "./lower-classes.js";
 import { mixinCallClassInfoOf, mixinIntersectionInstanceType } from "./lower-mixins.js";
 import { bindingNeverReassigned, bodyReadsArguments, isThisParameter, paramShape, paramShapes, checkDefaultParamBodyType, completeArgs, wrappedUndefined, undefinedArgFor, requireExactArityValue, bodyReturnType, declaredReturnType, collectSignature, collectSignatureInner, collectGenericSignature, genericFnOf, lowerGenericCall, lowerGenericFnValue, inferTypeParamBindings, lowerGenericInstance, lowerCall, lowerTimersMemberCall, lowerPromiseMethodCall, lowerFilterNarrowCall, isTopLevelFnSymbol, lowerNestedFunctionDecl, lambdaSignature, lowerLambda, lowerFunction } from "./lower-calls.js";
 import { lowerArrayMethodCall, lowerBufferStaticCall, lowerBytesMethodCall, lowerBytesNew, lowerMapMethodCall, lowerMapForEachCall, buildMapForEachFn, lowerRecordOvfCaptureHelper, lowerEnvToPairsHelper, lowerSetMethodCall, lowerSetForEachCall, buildSetForEachFn, lowerRegexMethodCall, lowerStringMethodCall } from "./lower-containers.js";
 import { lowerStreamModuleCall } from "./lower-stream.js";
-import { builtinImportOf, lowerBuiltinModuleCall, lowerFsToUnixTimestampCall, lowerFsLadderCall, lowerChildArgsArg, lowerSpawnSyncCall, lowerSpawnCall, lowerExecSyncCall, recordToEnvPairs, lowerJsonMethodCall, fencedBuiltinImportOf, lowerCryptoComposedCall, lowerUrlMethodCall, lowerSearchParamsMethodCall, lowerStatsMethodCall, lowerChildMethodCall, lowerAtomicsCall, lowerBuiltinExtraProperty, promisifiedExecFileDecl, lowerExecFileAsyncCall, execFileAsyncHelper, lowerStringDecoderMethodCall, strdecHelper, lowerReadlineMethodCall, lowerDcChannelMethodCall, lowerDcChannelProperty, lowerAlsMethodCall, lowerDcTracingChannelMethodCall, lowerDcTracingChannelProperty, lowerJsonProperty, lowerErrorCodeProperty, lowerProcessProperty, isProcessEnv, envValueType, lowerProcessEnvGet, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerTimeoutMethodCall, envSnapshotHelper, isConsoleLog, consoleCallMember, lowerNumberStaticCall, lowerNumberStaticProperty, lowerDateCall, lowerTextCodecCall, lowerFsConstantsProperty, lowerHttp2ConstantsProperty, http2ConstantBindingOf, http2ConstantsDestructureDecl, lowerProcessStreamProperty, lowerStringStaticCall, lowerStringLastIndexOfCall, lowerPromiseStaticCall } from "./lower-builtins.js";
+import { lowerEmitOverrideSpec } from "./lower-emitter.js";
+import { builtinImportOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireSpecOf, stripTypeCasts, lowerBuiltinModuleCall, lowerFsToUnixTimestampCall, lowerFsLadderCall, lowerChildArgsArg, lowerSpawnSyncCall, lowerSpawnCall, lowerExecSyncCall, recordToEnvPairs, lowerJsonMethodCall, fencedBuiltinImportOf, lowerCryptoComposedCall, lowerUrlMethodCall, lowerSearchParamsMethodCall, lowerStatsMethodCall, lowerChildMethodCall, lowerAtomicsCall, lowerBuiltinExtraProperty, promisifiedExecFileDecl, lowerExecFileAsyncCall, execFileAsyncHelper, lowerStringDecoderMethodCall, strdecHelper, lowerReadlineMethodCall, lowerDcChannelMethodCall, lowerDcChannelProperty, lowerAlsMethodCall, lowerDcTracingChannelMethodCall, lowerDcTracingChannelProperty, lowerJsonProperty, lowerErrorCodeProperty, lowerProcessProperty, isProcessEnv, envValueType, lowerProcessEnvGet, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerTimeoutMethodCall, envSnapshotHelper, isConsoleLog, consoleCallMember, lowerNumberStaticCall, lowerNumberStaticProperty, lowerDateCall, lowerTextCodecCall, lowerFsConstantsProperty, lowerHttp2ConstantsProperty, http2ConstantBindingOf, http2ConstantsDestructureDecl, lowerProcessStreamProperty, lowerStringStaticCall, lowerStringLastIndexOfCall, lowerPromiseStaticCall } from "./lower-builtins.js";
 import { isIslandExpr, islandFuncValueFence, islandRegexpOf, jsvalIn, requireDynamicApi, islandGlobalFnOf, lowerDynamicImportCall, lowerFetchCall, lowerIslandMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol } from "./lower-island.js";
 import { lowerHttpHeadersElement, lowerNetModuleCall, lowerServerMethodCall, lowerServerProperty } from "./lower-server.js";
 import { lowerDgramDnsModuleCall, lowerDgramMethodCall } from "./lower-dgram.js";
@@ -148,8 +149,24 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     const dynamic = options.dynamic ?? false;
     const targetPlatform = options.targetPlatform ?? process.platform;
     const startupCrash = options.startupCrash ?? null;
+    // --dynamic: modules reachable only through dynamic import() of the
+    // program's own files join the compiled graph here, ONCE, before any
+    // pass constructs (nothing calls their %init at startup — the import()
+    // site's namespace builder does, on the engine microtask, Node's
+    // evaluation point for them). Inadmissible static cycles inside the
+    // added subgraph are minted here and handed to the EMIT pass: the
+    // discovery pass's diagnostics are discarded by design, and after this
+    // extension of the shared array no later pass re-walks the subgraph.
+    const dynamicCycleDiags = [];
+    if (dynamic) {
+        appendDynamicImportModules(program, moduleOrder, (cycle, reason) => {
+            dynamicCycleDiags.push(unsupportedDiag("SC1016", { file: entry.fileName, start: 0, end: 0 }, `circular imports (${cycle}; ${reason})`));
+        });
+    }
     const reachable = new Lowerer(program, entry, moduleOrder, dynamic, { targetPlatform }).discover(options.libRoots);
     const emit = new Lowerer(program, entry, moduleOrder, dynamic, { reachable, targetPlatform, startupCrash });
+    for (const d of dynamicCycleDiags)
+        emit.pushDiag(d);
     const result = emit.run();
     if (options.coverage !== true)
         return result;
@@ -265,7 +282,7 @@ export function neverTaintedJsType(L, node, t) {
     };
     return walk(t, 4);
 }
-/** The DOM undefined value — what an uninitialized checked-dynamic
+/** The dyn undefined value — what an uninitialized checked-dynamic
  * binding holds (JS: declared bindings read `undefined` before any
  * assignment). A NULL dyn slot is a trap, never a value, so every dyn
  * binding that is READABLE before its first assignment must start here:
@@ -332,10 +349,10 @@ export function ladderFenceExpr(L, surface, node, hint) {
  * only unmappable pieces are `any` (`(value: any) => value is string` —
  * the arrow the binding holds lowers those params to dyn, so the binding
  * keeps its func-ness with the same per-piece fallback). The honest
- * static subset of `any` is a binding whose VALUES are DOM-representable:
+ * static subset of `any` is a binding whose VALUES are dyn-representable:
  * the binding is 'unknown' storage with the boundary conversions
  * coerceToExpected already applies (dynFrom into the slot, validated
- * dynCheck out) and per-site SC2011 fences for the operations the DOM
+ * dynCheck out) and per-site SC2011 fences for the operations the checked-dynamic tree
  * cannot carry JS-exactly (the island still lifts those). Every OTHER
  * unmappable TS type keeps its own diagnostic — annotations exist there,
  * and the fence names the real blocker. `--dynamic` builds never reach
@@ -359,8 +376,8 @@ export function dynFallbackType(L, node, t) {
             ((elem.flags & ts.TypeFlags.Never) !== 0 || neverTaintedJsType(L, node, elem));
         const mappedElem = elem !== undefined && !elemTainted ? L.mapTypeOf(elem) : null;
         // A mappable element keeps the static array; an unmappable one makes
-        // the WHOLE value dyn (the DOM has real arrays — length/index/push
-        // read through the keyed-DOM paths; dyn-element STATIC arrays have no
+        // the WHOLE value dyn (the checked-dynamic tree has real arrays — length/index/push
+        // read through the keyed-dyn paths; dyn-element STATIC arrays have no
         // backend representation).
         if (mappedElem)
             return { kind: "array", elem: mappedElem };
@@ -583,6 +600,13 @@ export class Lowerer {
     /** Synthetic array-HOF loop functions (map/filter/forEach desugar),
      * interned per method + element/callback-result type: key → fn name. */
     arrHofHelpers = new Map();
+    /** Emit-override specializations (`%C.emit:<event>` — lower-emitter.ts's
+     * emit-overrides block): interned names, the drive-loop queue, and the
+     * currently-lowering specialization's context (the super-forward
+     * interception reads it). */
+    emitSpecDone = new Set();
+    emitSpecQueue = [];
+    emitSpecCtx = null;
     /** Width-coercion helpers (%rec.width.N / %arr.width.N), interned per
      * (from, to) shape pair — see widthCoerce. */
     widthHelpers = new Map();
@@ -704,6 +728,12 @@ export class Lowerer {
      * `fileName\u0000specifier` (collectDynamicImports fills it during npm
      * collection; lowerDynamicImportCall reads it per site). */
     dynImports = new Map();
+    /** createRequire-require resolutions of BARE npm specifiers, keyed
+     * `fileName\u0000specifier` (collectCreateRequires fills it during npm
+     * collection under --dynamic — the require-condition entry key plus its
+     * embedded format; lowerCreateRequireCall reads it per site; "" marks a
+     * failed resolution already reported at collection). */
+    createRequireImports = new Map();
     /** Module → the name of its synthesized namespace-BUILDER function
      * (lowerOwnModuleImport): every `import()` of the same program module
      * shares one builder. */
@@ -892,16 +922,12 @@ export class Lowerer {
             // lowering, long after the constructor completes.
             isProgramFile: (sf) => this.fileTag.has(sf),
         };
-        // --dynamic: modules reachable only through dynamic import() of the
-        // program's own files join the compiled graph (nothing calls their
-        // %init at startup — the import() site's namespace builder does, on
-        // the engine microtask, which is Node's evaluation point for them).
-        // Mutates the SHARED moduleOrder array; idempotent across passes.
-        if (dynamic) {
-            appendDynamicImportModules(program, this.moduleOrder, (cycle) => {
-                this.pushDiag(unsupportedDiag("SC1016", { file: entry.fileName, start: 0, end: 0 }, `circular imports (${cycle})`));
-            });
-        }
+        // --dynamic: modules reachable only through dynamic import() joined
+        // moduleOrder BEFORE any pass constructed — lowerToIr runs
+        // appendDynamicImportModules once on the shared array (a per-pass run
+        // here minted cycle refusals into the DISCOVERY pass, whose
+        // diagnostics are discarded by design, and the extended order left
+        // nothing for the emit pass to re-detect).
         this.moduleOrder.forEach((sf, i) => {
             this.fileTag.set(sf, sf === entry ? "" : `%m${i}.`);
         });
@@ -1410,9 +1436,11 @@ export class Lowerer {
             let ec = 0;
             let gc = 0;
             let gi = 0;
+            let es = 0;
             while (ec < this.exprClasses.length ||
                 gc < this.genericClassInstances.length ||
-                gi < this.instantiationQueue.length) {
+                gi < this.instantiationQueue.length ||
+                es < this.emitSpecQueue.length) {
                 while (ec < this.exprClasses.length) {
                     functions.push(...this.lowerClassMembers(this.exprClasses[ec++]));
                 }
@@ -1433,6 +1461,20 @@ export class Lowerer {
                             throw e;
                     }
                 }
+                // Emit-override specializations queued by the emit sites above (a
+                // body can queue more — the super-forward chain — and generic
+                // instances of its own; the joint fixpoint covers both).
+                while (es < this.emitSpecQueue.length) {
+                    try {
+                        const fn = lowerEmitOverrideSpec(this, this.emitSpecQueue[es++]);
+                        if (fn)
+                            functions.push(fn);
+                    }
+                    catch (e) {
+                        if (!(e instanceof PoisonError))
+                            throw e;
+                    }
+                }
             }
         }
         // Lambdas lifted while lowering any of the above (plus synthetic
@@ -1750,9 +1792,11 @@ export class Lowerer {
         // the joint fixpoint).
         let instLowered = 0;
         let clsInstLowered = 0;
+        let specLowered = 0;
         const drainInstances = () => {
             while (instLowered < this.instantiationQueue.length ||
-                clsInstLowered < this.genericClassInstances.length) {
+                clsInstLowered < this.genericClassInstances.length ||
+                specLowered < this.emitSpecQueue.length) {
                 while (instLowered < this.instantiationQueue.length) {
                     const { info, inst } = this.instantiationQueue[instLowered++];
                     // Body-level poisons skip the instance here too (the emit pass
@@ -1769,6 +1813,18 @@ export class Lowerer {
                 while (clsInstLowered < this.genericClassInstances.length) {
                     this.lowerClassMembers(this.genericClassInstances[clsInstLowered++]);
                 }
+                // Emit-override specialization bodies fire edges of their own
+                // (the super-forward chain, closures, generic calls) — lower them
+                // for discovery exactly like generic instances.
+                while (specLowered < this.emitSpecQueue.length) {
+                    try {
+                        lowerEmitOverrideSpec(this, this.emitSpecQueue[specLowered++]);
+                    }
+                    catch (e) {
+                        if (!(e instanceof PoisonError))
+                            throw e;
+                    }
+                }
             }
         };
         parts.forEach((fp) => {
@@ -2261,7 +2317,7 @@ export class Lowerer {
         // The reverse — a TYPED value flowing into an 'unknown' slot
         // (`const u: unknown = 5`, an unknown-typed param/return) — IS tsc-clean
         // and rejected here: a typed value has no dynamic representation
-        // (constructing a DOM from static values is deliberately out this
+        // (constructing a dyn from static values is deliberately out this
         // round; only JSON.parse results are dyn).
         if (actual.kind === "dyn") {
             this.unsupported("SC1100", node, `passing 'unknown' values where '${this.fmt(expected)}' is expected`);
@@ -2370,8 +2426,8 @@ export class Lowerer {
             }
             // A CHECKED-DYNAMIC (dyn/'unknown') value entering the island (the
             // `isJson ? JSON.parse(text) : islandParser(text)` config ternary):
-            // the DOM tree deep-copies into engine values — data kinds only; a
-            // DOM carrying a boxed function/handle/promise throws the catchable
+            // the dyn tree deep-copies into engine values — data kinds only; a
+            // dyn carrying a boxed function/handle/promise throws the catchable
             // TypeError at runtime (trust-but-verify, like every boundary).
             if (expr.type.kind === "dyn") {
                 return { kind: "jsMarshal", value: expr, type: JSVAL, loc: expr.loc };
@@ -2404,21 +2460,35 @@ export class Lowerer {
             return expr;
         }
         if (expr.type.kind === "jsval" && expected.kind !== "jsval") {
-            // The jsval→DOM crossing (the world unification's engine-handle
+            // The jsval→dyn crossing (the world unification's engine-handle
             // kind): an 'any'-typed engine value flowing into an 'unknown'/
-            // 'object'/JS-residue slot wraps BY REFERENCE as the DOM's island
-            // kind — engine scalars normalize to native DOM kinds at wrap time,
-            // typeof/truthiness/String()/=== route to the engine, un-armed DOM
+            // 'object'/JS-residue slot wraps BY REFERENCE as the checked-dynamic tree's island
+            // kind — engine scalars normalize to native dyn kinds at wrap time,
+            // typeof/truthiness/String()/=== route to the engine, un-armed dyn
             // walks fence loudly, and the value unwraps back identity-preserved
             // (scr_jsval_from_dyn). Monotone under evolution/widening: a value
             // wraps once at its first dyn edge and stays valid through every
             // subsequent dyn slot; narrowing never changes representation.
             // This wrap RETIRES the silent-wrong-answer fence-closure box for
-            // jsval members of DOM object literals (lowerDynObjectLiteral's
+            // jsval members of dyn object literals (lowerDynObjectLiteral's
             // coercion lands here first).
             if (expected.kind === "dyn") {
                 return { kind: "dynFromJsval", value: expr, type: DYN, loc: expr.loc };
             }
+            // An island value flowing into a PROMISE-typed slot (the inferred
+            // `loadPlugins` return — `Promise.all(...)` lowered engine-side
+            // against a Promise<any[]> inference): the island→static promise
+            // bridge — the engine promise settles a fresh static promise (void
+            // fulfillments drop, `any[]`-declared fulfillments exit
+            // Array.isArray-gated by reference at the settle, 'any' parks as an
+            // island handle). Only inner shapes the bridge can deliver take the
+            // arm; the rest keep the exit fence with the type named.
+            if (expected.kind === "promise" &&
+                (expected.inner.kind === "void" ||
+                    expected.inner.kind === "jsval" ||
+                    (expected.inner.kind === "array" && expected.inner.elem.kind === "jsval"))) {
+                return { kind: "jsBridgePromise", value: expr, type: expected, loc: expr.loc };
+            }
             // The exit set: everything round-trippable, plus bare undefined-armed
             // unions of JSON-safe data arms (the engine's undefined takes the
             // undefined arm before the JSON detour) — canExitIslandToType.
@@ -2429,10 +2499,10 @@ export class Lowerer {
         }
         // A TYPED value flowing into an 'unknown' slot (`const u: unknown = 5`,
         // an unknown-typed param/return, a dyn-valued index slot): the
-        // static→DOM conversion — dynFrom, a DEEP COPY (the jsMarshal aliasing
+        // static→dyn conversion — dynFrom, a DEEP COPY (the jsMarshal aliasing
         // stance intoIndexValueSlot documents; SEMANTICS.md). Bare
-        // undefined/null literals store the DOM unit values. Types outside the
-        // DOM's domain (bytes, classes, Maps, ...) fall through to
+        // undefined/null literals store the dyn unit values. Types outside the
+        // dyn's domain (bytes, classes, Maps, ...) fall through to
         // requireExactShape's SC1101 fence.
         // A promise flowing into a VOID-promise slot (an inferred
         // Promise<never> return holding a `return Promise.reject(value)` the
@@ -2520,7 +2590,7 @@ export class Lowerer {
         // JS func-into-func mismatches ride the checked-dynamic function
         // boundary: box the value (dynFrom), adapt to the slot (dynCheck) —
         // the thunk delivers JS arity exactly (extras ignored, missing args
-        // the undefined DOM value), so `return _return` fits _mustCallInner's
+        // the undefined dyn value), so `return _return` fits _mustCallInner's
         // inferred (unknown) => unknown slot even though the wrapper declares
         // (). JS files only: TypeScript signatures keep the exact-shape
         // fences (a mismatch there is a compile-time story, not a boundary).
@@ -2828,7 +2898,7 @@ export class Lowerer {
      *   arr       — array into array whose element pair lifts (per-element
      *               copy loop, arrayWidthHelper)
      *   dynIn     — a typed value into an 'unknown' (dyn) slot — the same
-     *               static→DOM deep copy coerceToExpected applies top-level
+     *               static→dyn deep copy coerceToExpected applies top-level
      *   upcast    — a derived class instance into a base-typed slot (the
      *               prefix-layout pointer reinterpret, no copy)
      *   funcAdapt — a function into a slot whose signature differs only by
@@ -2838,7 +2908,7 @@ export class Lowerer {
     widthLiftPlan(src, dst) {
         if (typeEquals(src, dst))
             return { how: "copy" };
-        // An 'unknown' (dyn) DESTINATION slot: the static→DOM conversion —
+        // An 'unknown' (dyn) DESTINATION slot: the static→dyn conversion —
         // dynFrom, a DEEP COPY (`{ v: 5 }` into `{ v: unknown }`, `number[]`
         // into `unknown[]` — tsc's top type over the width family's copies).
         if (dst.kind === "dyn" && src.kind !== "dyn" && this.dynConvertible(src)) {
@@ -3100,7 +3170,7 @@ export class Lowerer {
                     // A target field MISSING on the source: legal exactly when it is
                     // optional-flavored (an undefined-armed union) — the unset field
                     // IS the undefined arm, the same rule literal completion applies
-                    // — or 'unknown' (a dyn slot holds the DOM undefined, exactly
+                    // — or 'unknown' (a dyn slot holds the dyn undefined, exactly
                     // the absent-property read: the options-record call shape
                     // against `{ plugins: unknown, ... }`). Never for tuples: a
                     // completed position would change .length and JSON where Node
@@ -3256,7 +3326,7 @@ export class Lowerer {
                         fields: to.fields.map((f) => {
                             const lift = plan.get(f.name);
                             if ("absentDyn" in lift) {
-                                // The unset 'unknown' field: the DOM undefined — exactly
+                                // The unset 'unknown' field: the dyn undefined — exactly
                                 // the absent-property read's answer.
                                 return { name: f.name, value: dynUndefinedExpr(loc) };
                             }
@@ -3841,7 +3911,7 @@ export class Lowerer {
         if (typeEquals(src, dst))
             return true;
         // The island boundary joins the mechanical set: values that MARSHAL
-        // in (units, the checked-dynamic DOM copy, JSON-safe data, liftable
+        // in (units, the checked-dynamic deep copy, JSON-safe data, liftable
         // composites, marshalable closures — coerceToExpected's jsval-IN
         // block) and island handles whose exits VALIDATE (boundaryExitSafe) —
         // the `defaultFallback(cfg) { return { login, id, scopes } }` shape,
@@ -3926,7 +3996,7 @@ export class Lowerer {
         //   never-called mismatched callback is exact; divergence 38's stance
         //   extended to calls).
         // - voidRet "dyn"/"jsval": calling yields JS's undefined — the exact
-        //   undefined DOM/engine value after the call's effects.
+        //   undefined dyn/engine value after the call's effects.
         // - voidRet "strand": a void result where the slot promises a typed
         //   value — the call runs (a `never` thrower never comes back, so the
         //   trap is unreachable there), then the stranded TypeError.
@@ -4711,7 +4781,7 @@ export class Lowerer {
             return { kind: "call", callee: helper, args: [e], type: JSVAL, loc };
         }
         // Checked-dynamic values and marshalable closures ride jsMarshal
-        // directly (the DOM deep copy / the host-function wrap).
+        // directly (the checked-dynamic tree deep copy / the host-function wrap).
         if (e.type.kind === "dyn" || e.type.kind === "func") {
             return { kind: "jsMarshal", value: e, type: JSVAL, loc };
         }
@@ -5152,9 +5222,9 @@ export class Lowerer {
         }
         // An OBJECT LITERAL against a checked-dynamic slot in a JS file (the
         // getSupportInfo options argument — a dyn-ABI param): the value's
-        // world IS the DOM — build the DOM literal directly, before the
+        // world IS the checked-dynamic tree — build the dyn literal directly, before the
         // island gate could claim the checker's `any` context (an island
-        // build could never land in the slot: no engine→DOM crossing).
+        // build could never land in the slot: no engine→dyn crossing).
         if (expected?.kind === "dyn") {
             let x = node;
             while (ts.isParenthesizedExpression(x))
@@ -5204,7 +5274,7 @@ export class Lowerer {
     }
     /** A value flowing into an index-signature VALUE slot (an overflow
      * literal entry, a dynamic-keyed record write). dyn slots (`unknown`
-     * signatures — ModelPricing's) take a DOM conversion: dyn values pass
+     * signatures — ModelPricing's) take a dyn conversion: dyn values pass
      * through, JSON-safe static values convert with dynFrom (a deep copy —
      * the jsMarshal aliasing stance), everything else keeps the dyn-boundary
      * fence. Typed slots ride the ordinary coercion path (union slots wrap
@@ -5214,12 +5284,12 @@ export class Lowerer {
             return this.coerceInto(node, value, indexValue);
         if (value.type.kind === "dyn")
             return value;
-        // Bare `undefined`/`null` literals store the DOM unit values (JS keeps
+        // Bare `undefined`/`null` literals store the dyn unit values (JS keeps
         // the key; JSON.stringify drops an undefined-valued one, like Node).
         if (value.kind === "unitLit") {
             return { kind: "dynFrom", value, type: DYN, loc: value.loc };
         }
-        // An ISLAND ('any') value: the by-reference jsval→DOM wrap — the same
+        // An ISLAND ('any') value: the by-reference jsval→dyn wrap — the same
         // edge coerceToExpected converts (dyn slots accept engine values).
         if (value.type.kind === "jsval") {
             return { kind: "dynFromJsval", value, type: DYN, loc: value.loc };
@@ -5235,13 +5305,13 @@ export class Lowerer {
     withUndefinedArmOf(t) {
         return withUndefinedArmCanonical(t, this.unions);
     }
-    /** True when a static type converts to a dyn DOM value (the dynFrom
-     * walker's domain): JSON-safe, bytes<u8> (Uint8Array/Buffer — the DOM's
+    /** True when a static type converts to a dyn value (the dynFrom
+     * walker's domain): JSON-safe, bytes<u8> (Uint8Array/Buffer — the checked-dynamic tree's
      * bytes kind, payload copied; stdin chunks into unknown-typed helpers),
      * an undefined-armed union whose other arms are JSON-safe — the
-     * undefined arm becomes the undefined DOM singleton — or a BOXABLE
+     * undefined arm becomes the undefined dyn singleton — or a BOXABLE
      * function type (the checked-dynamic function boundary: the closure
-     * crosses as the DOM's callable kind, identity preserved). */
+     * crosses as the checked-dynamic tree's callable kind, identity preserved). */
     dynConvertible(t) {
         return canConvertToDyn(t, (id) => this.shapes.get(id), (id) => this.unions.get(id));
     }
@@ -5744,7 +5814,7 @@ export class Lowerer {
                     if (abi.kind === "dyn" || abi.kind === "jsval") {
                         // A DYNAMIC-TIER pattern source (`function f({} = a)` with
                         // `a: any` — jsval for island values, dyn for the checked-
-                        // dynamic DOM): the slot holds its tier's undefined directly,
+                        // dynamic dyn): the slot holds its tier's undefined directly,
                         // so the default test is the runtime undefined test — then
                         // the pattern destructures the picked value.
                         const dflt = this.lowerExprExpecting(decl.initializer, abi);
@@ -5812,7 +5882,7 @@ export class Lowerer {
                 if (abi.kind === "dyn" || abi.kind === "jsval") {
                     // A DYNAMIC-TIER defaulted param (`function f(x = a)` with
                     // `a: any` — jsval for island values, dyn for the checked-
-                    // dynamic DOM): the slot holds its tier's undefined directly —
+                    // dynamic dyn): the slot holds its tier's undefined directly —
                     // the body local picks the default on the runtime test.
                     const loc = locOf(decl);
                     const slot = this.declareHiddenLocal(name, abi);
@@ -5997,7 +6067,7 @@ export class Lowerer {
                 continue;
             // dyn captures ride an UNTRACED obj-box (scr_dyn_retain_v/release_v
             // — boxNewC): the mustCall wrapper closing over its implicit-any
-            // `fn` param. A DOM tree is pure data except the function kind,
+            // `fn` param. A dyn tree is pure data except the function kind,
             // whose closure edge the collector never sees — cycles through a
             // captured dyn are uncollectable (leak, never dangle: trial
             // deletion treats untraced edges as external roots). SEMANTICS.md.
@@ -6311,7 +6381,12 @@ export class Lowerer {
             // out-of-block read would split the variable in two) — vars take the
             // standard path and its own fences.
             (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.BlockScoped) !== 0 &&
-            islandCandidate(decl.initializer)) {
+            islandCandidate(decl.initializer) &&
+            // createRequire's plumbing decls are COMPILE-TIME erasures (the
+            // require binding and its builtin-namespace bindings) — never
+            // island values; the standard path's skips own them.
+            !createRequireBindingDecl(this, decl.name, decl.initializer) &&
+            !createRequireNamespaceDecl(this, decl.name, decl.initializer)) {
             const mapped = this.mapTypeOf(this.typeOf(decl.name));
             const handleOnly = mapped === null ||
                 (mapped.kind !== "jsval" &&
@@ -6327,7 +6402,7 @@ export class Lowerer {
                 // The CHECKED-DYNAMIC twin of the handle rescue (the runtime-world
                 // local rule): an unmappable declared type over a dyn initializer
                 // (`const first = plugins[0]` — the checker spells 'string |
-                // object' while the read is a DOM keyed read) keeps the binding
+                // object' while the read is a dyn keyed read) keeps the binding
                 // dyn; typed use sites ride validated extractions and the routed
                 // engine ops, exactly the JSON.parse-binding story.
                 if (mapped === null && init.type.kind === "dyn") {
@@ -6702,10 +6777,21 @@ export class Lowerer {
             if (!decl)
                 return null;
             // The CommonJS twin: `const fs = require("fs")` binds the same
-            // namespace surface as `import * as fs from "node:fs"`.
+            // namespace surface as `import * as fs from "node:fs"` — and the
+            // createRequire spelling (`const fs = require("node:fs")` through a
+            // createRequire binding, the fallback-typed cast idiom stripped)
+            // binds it too.
             if (ts.isVariableDeclaration(decl) && ts.isIdentifier(decl.name) && decl.initializer) {
                 const spec = requireSpecOf(decl.initializer);
-                return spec !== null ? canonicalBuiltinModule(spec) : null;
+                if (spec !== null)
+                    return canonicalBuiltinModule(spec);
+                const init = stripTypeCasts(decl.initializer);
+                if (ts.isCallExpression(init)) {
+                    const cr = createRequireSpecOf(this, init);
+                    if (cr !== null && cr.spec !== null)
+                        return canonicalBuiltinModule(cr.spec);
+                }
+                return null;
             }
             // A DESTRUCTURED sub-namespace binding — `const { promises } =
             // fs` / `= require('fs')`: the member is itself a supported module
@@ -6738,6 +6824,17 @@ export class Lowerer {
             if (spec !== null)
                 return canonicalBuiltinModule(spec);
         }
+        // The createRequire spelling of the same inline form:
+        // `require("node:path").join(...)` through a createRequire binding
+        // (the fallback-typed cast idiom strips: `(require("x") as T).m`).
+        {
+            const inner = stripTypeCasts(expr);
+            if (ts.isCallExpression(inner)) {
+                const cr = createRequireSpecOf(this, inner);
+                if (cr !== null && cr.spec !== null)
+                    return canonicalBuiltinModule(cr.spec);
+            }
+        }
         if (ts.isIdentifier(expr)) {
             const symbol = this.checker.getSymbolAtLocation(expr);
             const decl = symbol ? this.checker.declarationsOf(symbol)[0] : undefined;
@@ -6884,6 +6981,11 @@ export class Lowerer {
         const c = builtinModuleConstOf(this, bi.module, bi.member);
         if (c !== undefined)
             return builtinConstLit(c, loc);
+        // module.builtinModules through a namespace binding — the baked
+        // Node v24 list, a fresh string[] per read.
+        if (bi.module === "module" && bi.member === "builtinModules") {
+            return builtinModulesArrayLit(loc);
+        }
         if (bi.member === "constants" && bi.module === "fs") {
             // A bare `fs.constants` read (not one of the baked bits above).
             this.noLowering(`fs.constants`, expr, "F_OK, R_OK, W_OK, and X_OK are the lowered constants");