@scriptc/compiler 0.0.9 → 0.0.11

package/dist/frontend/lowering/lowerer.d.ts

@@ -10,6 +10,7 @@ import { FileParts } from "./lower-modules.js";
 import { ClassInfo, ClassIteratorInfo, GenericClassInfo, findStaticOn } from "./lower-classes.js";
 import { MixinFnShape } from "./lower-mixins.js";
 import { ParamShape, FnSig, GenericFnInfo, GenericInstance } from "./lower-calls.js";
+import { type EmitSpecCtx, type EmitSpecRequest } from "./lower-emitter.js";
 import { FieldTarget } from "./lower-exprs.js";
 import type { ExpandoMember } from "./lower-expando.js";
 /** Entry function name. '%' cannot appear in a TS identifier, so a user
@@ -301,6 +302,14 @@ export declare function dynUndefinedExpr(loc: SrcLoc): IrExpr;
  * an empty code means no code slot. `type` is the replaced expression's
  * own (never materialized — the global.undefRead pattern). */
 export declare function nodeThrowExpr(kind: 0 | 1 | 2, code: string, message: string, type: IrType, loc: SrcLoc): IrExpr;
+/** The post-validation fence STRING a validation-ladder Chk libCall
+ * throws after its Node-order checks pass: the same SC2020 text the
+ * per-statement runtime fence would have thrown (message + "[code at
+ * file:line]"), rendered eagerly so the runtime can throw it verbatim
+ * (scr_throw_lowering_fence). The diagnostic joins the runtime-fence
+ * ledger exactly like a deferred statement fence — nothing silently
+ * drops off the coverage report. */
+export declare function ladderFenceExpr(L: Lowerer, surface: string, node: ts.Node, hint?: string): IrExpr;
 /** The checked-dynamic declaration fallback for unmappable binding types
  * (see irTypeOf), two gates over one story:
  *
@@ -357,6 +366,29 @@ export declare class Lowerer {
     /** Per-symbol result of the never-reassigned file scan
      * (bindingNeverReassigned — object-literal generic-method receivers). */
     readonly neverReassignedCache: Map<ts.Symbol, boolean>;
+    /** TRAP bindings: declarations whose initializer provably throws before
+     * producing a value (its chain roots at an ambient-undefined name —
+     * ambientUndefVarRootOf). Module init unwinds at the declaration, so no
+     * reference to the binding can ever execute; the statement lowers to the
+     * root's throw, no storage exists, and references lower to the same
+     * trap shape (never reached — sound whatever the type). */
+    readonly trapBindings: Set<ts.Symbol>;
+    /** NULLISH bindings of unmappable (generic-signature) types: `const i:
+     * I<A & B> = null as any` — the binding provably holds null/undefined
+     * forever (every write's RHS is nullish too), so no storage exists and
+     * each READ knows the value. Member reads and method calls through one
+     * lower to Node's exact TypeError ("Cannot read properties of null
+     * (reading 'fn')"); nullish-to-nullish flows lower to nothing. The map
+     * answers which unit the binding holds (the TypeError names it). Null
+     * entries cache probed non-qualifiers. */
+    readonly nullishBindings: Map<ts.Symbol, "undefined" | "null" | null>;
+    /** DEAD bindings of unmappable types: never READ anywhere in the
+     * program, declared with no initializer or a value-only one (a function
+     * literal), every write's RHS side-effect-free. Node materializes the
+     * value and drops it — zero observable effect — so the declaration and
+     * its writes lower to nothing, and no type fence fires for a value the
+     * program never consumes. */
+    readonly deadBindings: Set<ts.Symbol>;
     /** IMPLICIT-ANY function-value bindings (npm-static JS — `const knownBy
      * = (cmd) => ...`), by their VariableDeclaration: the registered info,
      * or null for probed non-qualifiers (implicitLocalFnNodeOf). */
@@ -409,6 +441,13 @@ export declare class Lowerer {
     /** Synthetic array-HOF loop functions (map/filter/forEach desugar),
      * interned per method + element/callback-result type: key → fn name. */
     readonly arrHofHelpers: Map<string, string>;
+    /** 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). */
+    readonly emitSpecDone: Set<string>;
+    readonly emitSpecQueue: EmitSpecRequest[];
+    emitSpecCtx: EmitSpecCtx | null;
     /** Width-coercion helpers (%rec.width.N / %arr.width.N), interned per
      * (from, to) shape pair — see widthCoerce. */
     readonly widthHelpers: Map<string, string>;
@@ -541,6 +580,15 @@ export declare class Lowerer {
      * `fileName\u0000specifier` (collectDynamicImports fills it during npm
      * collection; lowerDynamicImportCall reads it per site). */
     readonly dynImports: Map<string, DynamicImportResolution>;
+    /** 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). */
+    readonly createRequireImports: Map<string, "" | {
+        entryKey: string;
+        format: "esm" | "cjs" | "json";
+    }>;
     /** Module → the name of its synthesized namespace-BUILDER function
      * (lowerOwnModuleImport): every `import()` of the same program module
      * shares one builder. */
@@ -1631,7 +1679,7 @@ export declare class Lowerer {
         stmts: IrStmt[];
         value: IrExpr;
     };
-    lowerBindingPattern(pattern: ts.ArrayBindingPattern | ts.ObjectBindingPattern, srcRef: () => IrExpr, srcType: IrType, isLet: boolean, out: IrStmt[]): void;
+    lowerBindingPattern(pattern: ts.ArrayBindingPattern | ts.ObjectBindingPattern, srcRef: () => IrExpr, srcType: IrType, isLet: boolean, out: IrStmt[], dynSpell?: string): void;
     checkBindingElement(el: ts.BindingElement, allowDefault?: boolean): void;
     bindPatternTarget(name: ts.BindingName, value: IrExpr, isLet: boolean, out: IrStmt[]): void;
     lowerVarDeclList(list: ts.VariableDeclarationList): IrStmt | null;
@@ -1799,6 +1847,10 @@ export declare class Lowerer {
         module: string;
         member: string;
     }, loc: SrcLoc): IrExpr | null;
+    lowerFsLadderCall(expr: ts.CallExpression, bi: {
+        module: string;
+        member: string;
+    }, loc: SrcLoc): IrExpr | null;
     lowerChildArgsArg(node: ts.Expression | undefined, loc: SrcLoc): IrExpr;
     lowerSpawnSyncCall(expr: ts.CallExpression, loc: SrcLoc): IrExpr;
     lowerSpawnCall(expr: ts.CallExpression, loc: SrcLoc): IrExpr;

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, 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;
@@ -299,6 +316,26 @@ export function nodeThrowExpr(kind, code, message, type, loc) {
         loc,
     };
 }
+/** The post-validation fence STRING a validation-ladder Chk libCall
+ * throws after its Node-order checks pass: the same SC2020 text the
+ * per-statement runtime fence would have thrown (message + "[code at
+ * file:line]"), rendered eagerly so the runtime can throw it verbatim
+ * (scr_throw_lowering_fence). The diagnostic joins the runtime-fence
+ * ledger exactly like a deferred statement fence — nothing silently
+ * drops off the coverage report. */
+export function ladderFenceExpr(L, surface, node, hint) {
+    const loc = locOf(node);
+    const d = noLoweringDiag(surface, loc, hint);
+    L.runtimeFences.push(d);
+    const sf = node.getSourceFile();
+    const pos = ts.getLineAndCharacterOfPosition(sf, loc.start);
+    return {
+        kind: "strLit",
+        value: `${d.message} [${d.code} at ${loc.file}:${pos.line + 1}]`,
+        type: STRING,
+        loc,
+    };
+}
 /** The checked-dynamic declaration fallback for unmappable binding types
  * (see irTypeOf), two gates over one story:
  *
@@ -477,6 +514,29 @@ export class Lowerer {
     /** Per-symbol result of the never-reassigned file scan
      * (bindingNeverReassigned — object-literal generic-method receivers). */
     neverReassignedCache = new Map();
+    /** TRAP bindings: declarations whose initializer provably throws before
+     * producing a value (its chain roots at an ambient-undefined name —
+     * ambientUndefVarRootOf). Module init unwinds at the declaration, so no
+     * reference to the binding can ever execute; the statement lowers to the
+     * root's throw, no storage exists, and references lower to the same
+     * trap shape (never reached — sound whatever the type). */
+    trapBindings = new Set();
+    /** NULLISH bindings of unmappable (generic-signature) types: `const i:
+     * I<A & B> = null as any` — the binding provably holds null/undefined
+     * forever (every write's RHS is nullish too), so no storage exists and
+     * each READ knows the value. Member reads and method calls through one
+     * lower to Node's exact TypeError ("Cannot read properties of null
+     * (reading 'fn')"); nullish-to-nullish flows lower to nothing. The map
+     * answers which unit the binding holds (the TypeError names it). Null
+     * entries cache probed non-qualifiers. */
+    nullishBindings = new Map();
+    /** DEAD bindings of unmappable types: never READ anywhere in the
+     * program, declared with no initializer or a value-only one (a function
+     * literal), every write's RHS side-effect-free. Node materializes the
+     * value and drops it — zero observable effect — so the declaration and
+     * its writes lower to nothing, and no type fence fires for a value the
+     * program never consumes. */
+    deadBindings = new Set();
     /** IMPLICIT-ANY function-value bindings (npm-static JS — `const knownBy
      * = (cmd) => ...`), by their VariableDeclaration: the registered info,
      * or null for probed non-qualifiers (implicitLocalFnNodeOf). */
@@ -540,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();
@@ -661,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. */
@@ -849,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}.`);
         });
@@ -1367,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++]));
                 }
@@ -1390,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
@@ -1707,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
@@ -1726,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) => {
@@ -2361,6 +2460,21 @@ export class Lowerer {
             return expr;
         }
         if (expr.type.kind === "jsval" && expected.kind !== "jsval") {
+            // The jsval→DOM 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
+            // 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
+            // coercion lands here first).
+            if (expected.kind === "dyn") {
+                return { kind: "dynFromJsval", value: expr, type: DYN, 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.
@@ -5161,6 +5275,11 @@ export class Lowerer {
         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
+        // edge coerceToExpected converts (dyn slots accept engine values).
+        if (value.type.kind === "jsval") {
+            return { kind: "dynFromJsval", value, type: DYN, loc: value.loc };
+        }
         if (!this.dynConvertible(value.type)) {
             this.unsupported("SC1100", node, `storing '${this.fmt(value.type)}' values under an 'unknown'-valued index signature (only numbers, strings, booleans, and JSON-safe records/arrays/unions convert)`);
         }
@@ -6116,7 +6235,7 @@ export class Lowerer {
     lowerDestructuringAssignParts(target, rhs, loc) {
         return lowerDestructuringAssignParts(this, target, rhs, loc);
     }
-    lowerBindingPattern(pattern, srcRef, srcType, isLet, out) {
+    lowerBindingPattern(pattern, srcRef, srcType, isLet, out, dynSpell) {
         // An ISLAND source (`const { readFileSync } = await import("fs")` —
         // a namespace handle, or any 'any'-typed object): each bound name is
         // an engine property read, mirroring the island property-read rule —
@@ -6180,7 +6299,7 @@ export class Lowerer {
             }
             return;
         }
-        return lowerBindingPattern(this, pattern, srcRef, srcType, isLet, out);
+        return lowerBindingPattern(this, pattern, srcRef, srcType, isLet, out, dynSpell);
     }
     checkBindingElement(el, allowDefault = false) {
         return checkBindingElement(this, el, allowDefault);
@@ -6248,7 +6367,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" &&
@@ -6261,6 +6385,16 @@ export class Lowerer {
                     const local = this.declareLocal(decl.name, decl.name.text, JSVAL, isLet);
                     return { kind: "varDecl", localId: local.id, init, loc: locOf(decl) };
                 }
+                // 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
+                // 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") {
+                    const local = this.declareLocal(decl.name, decl.name.text, DYN, isLet);
+                    return { kind: "varDecl", localId: local.id, init, loc: locOf(decl) };
+                }
                 if (mapped === null)
                     this.badType(decl.name, this.typeOf(decl.name));
                 // A mappable declared type with a non-island initializer: the
@@ -6629,10 +6763,42 @@ 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
+            // ("fs/promises"), so the binding carries that module's namespace
+            // surface. canonicalBuiltinModule gates the composition (an
+            // ordinary destructured FUNCTION binding composes to an unknown
+            // name and answers null — builtinImportOf owns those).
+            if (ts.isBindingElement(decl) && ts.isObjectBindingPattern(decl.parent) &&
+                ts.isVariableDeclaration(decl.parent.parent) && decl.parent.parent.initializer !== undefined &&
+                decl.propertyName === undefined && decl.initializer === undefined) {
+                const name = decl.name;
+                if (name === undefined || !ts.isIdentifier(name))
+                    return null;
+                const init = decl.parent.parent.initializer;
+                const spec = requireSpecOf(init);
+                const outer = spec !== null
+                    ? canonicalBuiltinModule(spec)
+                    : ts.isIdentifier(init) ? this.builtinNamespaceModuleOf(init) : null;
+                if (outer !== null)
+                    return canonicalBuiltinModule(`${outer}/${name.text}`);
+                return null;
             }
         }
         // The INLINE CommonJS spelling: `require("cluster").isPrimary` — the
@@ -6644,6 +6810,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;
@@ -6746,6 +6923,12 @@ export class Lowerer {
         const fsTs = this.lowerFsToUnixTimestampCall(call, bi, locOf(access));
         if (fsTs)
             return fsTs;
+        // The fs validation-ladder spoke (checked-dynamic lane): misuse of
+        // implemented-namespace members throws Node's typed errors instead
+        // of meeting the table fence.
+        const fsLadder = this.lowerFsLadderCall(call, bi, locOf(access));
+        if (fsLadder)
+            return fsLadder;
         const builtinFn = builtinModuleFnOf(this, bi.module, bi.member);
         if (!builtinFn) {
             this.noLowering(`${bi.module}.${bi.member}`, call, builtinFenceHintOf(bi.module, bi.member), this.checker.getSymbolAtLocation(access.name));
@@ -6784,6 +6967,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");
@@ -6799,6 +6987,9 @@ export class Lowerer {
     lowerFsToUnixTimestampCall(expr, bi, loc) {
         return lowerFsToUnixTimestampCall(this, expr, bi, loc);
     }
+    lowerFsLadderCall(expr, bi, loc) {
+        return lowerFsLadderCall(this, expr, bi, loc);
+    }
     lowerChildArgsArg(node, loc) {
         return lowerChildArgsArg(this, node, loc);
     }