@scriptc/compiler 0.3.1 → 0.3.2

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

@@ -30,6 +30,7 @@ import { type GenericFnInfo, type GenericInstance } from "./generic-functions.js
 import type { InstantiationPath } from "./instantiation-path.js";
 import { type ArrayHofInfo } from "./containers/array-pipelines.js";
 import { type ComputedEventPattern, type EmitSpecCtx, type EmitSpecRequest, type EventSig } from "./lower-event-emitter.js";
+import { type ConsoleMethodMember, type ConsoleOutputMember } from "./builtins/console.js";
 import { type FieldTarget } from "./lower-exprs.js";
 import type { ExpandoMembers } from "./lower-expando.js";
 /** Entry function name. '%' cannot appear in a TS identifier, so a user
@@ -427,6 +428,9 @@ export declare class Lowerer {
     /** All storage slots widened for runtime absence, including slots whose
      * current control-flow branch has temporarily narrowed the value. */
     readonly runtimeOptionalStorageLocals: Set<IrLocal>;
+    /** `var` bindings code can read before their first store
+     * (var-hoisting.ts): their storage holds undefined until then. */
+    readonly earlyReadVars: Set<ts.Symbol>;
     /** Globals whose checker-bare type was widened because an indexed read can
      * carry undefined at runtime. Identifier reads keep the union tag so
      * typeof and later boundaries observe the real value. */
@@ -440,6 +444,9 @@ export declare class Lowerer {
      * prepass. This includes explicit annotations: unchecked TS annotations do
      * not prove that an array property read produced a value. */
     readonly runtimeOptionalBindingTypes: Map<ts.Symbol, IrType>;
+    /** Set when a match result lowers to execGroups/matchGroups, the inputs
+     * of regex span folding. */
+    regexGroupResults: boolean;
     /** Bindings that receive an unchecked indexed read (or a value derived
      * from one) through an initializer or assignment. The checker narrows a
      * declared optional binding to that read's bare type, so presence tests
@@ -745,6 +752,12 @@ export declare class Lowerer {
     readonly workerTargets: readonly ts.SourceFile[];
     readonly workerTargetIdByPath: Map<string, number>;
     usesWorkers: boolean;
+    /** The program constructs a LifetimeRegion (lifetime-regions.ts). */
+    usesLifetimeRegions: boolean;
+    /** Per-directory answers of experimental-import.ts's declaration-file test. */
+    readonly experimentalFiles: Map<string, boolean>;
+    /** Interned LifetimeRegion.run helpers, by callback type key. */
+    readonly regionRunHelpers: Map<string, string>;
     readonly forkTargetIdByPath: Map<string, number>;
     /** Namespace ModuleBlocks this program lowers, filled by splitFiles:
      * "flattened" — an instantiated namespace whose body joined the file's
@@ -851,6 +864,9 @@ export declare class Lowerer {
     /** Import-cycle bindings with an initialization flag, by global id, and
      * the top-level statements declaring them (cycle-initialization.ts). */
     readonly cycleInitFlags: Map<string, CycleInitFlag>;
+    /** Initialization flags of classes reachable before their statement ran,
+     * by class name (cycle-initialization.ts). */
+    readonly classInitFlags: Map<string, CycleInitFlag>;
     readonly cycleInitDeclarations: Map<ts.StatementBase, CycleInitFlag[]>;
     get ctx(): FnCtx;
     get scopes(): Map<ts.Symbol, IrLocal>[];
@@ -867,6 +883,9 @@ export declare class Lowerer {
     /** Set while a subclass constructor's super() call notes its base
      * constructor edge: that edge does not instantiate the base exactly. */
     private superConstructorEdge;
+    /** Set when the async generator `return` being lowered awaited its
+     * promise operand (returnedPromiseAwait). */
+    private returnAwaitedPromise;
     private readonly virtualEdges;
     classCanBeConstructed(info: ClassInfo): boolean;
     /** Coverage remainder mode: the reachability gate inverts (see wantBody)
@@ -1453,6 +1472,7 @@ export declare class Lowerer {
      * caller never sees a value, so the return goes out bare. Async
      * void-inner returns still resolve a returned promise first. */
     lowerReturnStmt(node: ts.Expression, loc: SrcLoc): IrStmt;
+    private lowerReturnOf;
     maybeNarrow(expr: IrExpr, node: ts.Node): IrExpr;
     lowerUnitComparison(left: IrExpr, right: IrExpr, negated: boolean, loc: SrcLoc): IrExpr | null;
     lowerNullishCoalesce(expr: ts.BinaryExpression, loc: SrcLoc): IrExpr;
@@ -1856,7 +1876,8 @@ export declare class Lowerer {
     rejectComptimeCaptures(cb: ts.ArrowFunction | ts.FunctionExpression): void;
     comptimeValueToIr(value: unknown, expected: IrType, path: string, blame: ts.Node): IrExpr;
     isConsoleLog(call: ts.CallExpression): boolean;
-    consoleCallMember(call: ts.CallExpression): "log" | "info" | "debug" | "error" | "warn" | null;
+    consoleCallMember(call: ts.CallExpression): ConsoleOutputMember | null;
+    consoleMethodMember(call: ts.CallExpression): ConsoleMethodMember | null;
     builtinImportOf(ident: ts.Identifier): {
         module: string;
         member: string;

package/dist/frontend/lowering/lowerer.js

@@ -1,9 +1,12 @@
+import { lifetimeRegionType, lowerLifetimeRegionCall, lowerLifetimeRegionNew, } from "./lifetime-regions.js";
+import { isExperimentalDeclarationFile } from "../experimental-import.js";
 import { checkCycleBindingAccesses, refuseUncheckedCycleReads, } from "./cycle-initialization.js";
 import { identityPreservingWidening } from "./coercions/identity.js";
 import { scanDivergences } from "./divergences.js";
 import { checkedClassAssertion } from "./class-assertions.js";
 import { narrowStoredClassValue, narrowGenericClassValue } from "./class-unions.js";
 import { isOptionalProcessStreamProperty } from "./builtins/process.js";
+import { isSettledIteratorValueRead } from "./lower-generators.js";
 import { concreteCollectionNarrow } from "./collection-narrowing.js";
 import { lowerWorkerMetadata } from "./builtins/workers.js";
 import { dynUndefinedExpr, nodeThrowExpr, numLit, varRef } from "../../ir/build.js";
@@ -16,6 +19,7 @@ import { funcReturnWidthAdapter, coercibleValue, cleanFuncAdaptable, funcCoerceA
 import { unionRetagMappable, narrowedRetagHelper, strandedUnitTrap, strandedCoercionTrap, recordUnionWrapHelper, unionRetagHelper, narrowedArmHelper, checkedNarrowCall, checkedNarrowOperand, deferredReadHelper, } from "./coercions/unions.js";
 import { lowerUtilTypeValue, pathModuleValue, utilTypesModuleValue, } from "./lower-builtin-values.js";
 import { devirtualizeVirtualCalls } from "./devirtualize.js";
+import { foldRegexSpanReads } from "./regex-span-reads.js";
 import { RuntimeOptionalProvenance } from "./runtime-optional-provenance.js";
 import { presentAtUse, reassignedBindings } from "./runtime-optional-guards.js";
 import { NarrowingStability } from "./narrowing-stability.js";
@@ -33,6 +37,8 @@ import { InternalCompilerError } from "../../errors.js";
 import { defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "./optional-arguments.js";
 import { ClassDynamicDispatch, trackClassFieldCreation } from "./class-dynamic-dispatch.js";
 import { ClassProtocols } from "./class-protocols.js";
+import { earlyReadVarSymbols } from "./var-hoisting.js";
+import { recordTextCodecClass } from "../../ir/ir.js";
 import { DeferredModuleInitializers } from "./deferred-module-initializers.js";
 import { finalizeClassMethodValues } from "./class-method-values.js";
 export { newFnCtx } from "./function-context.js";
@@ -60,7 +66,7 @@ import { unsupportedAnyOperationDiag, blockedBindingUseDiag, checkerPanicDiag, c
 import { arrayOf, BOOL, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, DYN, DYN_HANDLE_KINDS, F64, isDynTypedRefType, isJsonSafeType, isJsonStringifySafeType, isPrimitiveCollectionKey, isSupportedMapKey, isSupportedMapValue, isUndefinedArmedUnion, isUnitType, NULL_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID, } from "../../ir/ir.js";
 import { provenanceActive } from "../provenance-registry.js";
 import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, orderedImportsOf, overridesDtsPath, npmStaticDepSf7, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
-import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, formatIrType, FETCH_AMBIENT_TYPES, isUnitOnlyTsType, isWorkerHandleType, jsOpenObjectType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../type-mapper.js";
+import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, formatIrType, FETCH_AMBIENT_TYPES, isOsConstantsSymbol, isUnitOnlyTsType, isWorkerHandleType, jsOpenObjectType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../type-mapper.js";
 import { builtinConstLit, builtinModuleConstOf, builtinModulesArrayLit, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalNameOf, stdlibGlobalMember, nodeTypesOnlySymbol, } from "./surfaces.js";
 import { splitFiles, collectProgram, collectNpmImports, collectJsonImports, moduleArtifacts, collectGlobals, declSymbolOf, defaultExportSymbolOf, lowerFileInit, lowerDefaultExport, buildMain, appendDynamicImportModules, appendForkModules, appendWorkerModules, } from "./lower-modules.js";
 import { prepareCjsModuleGraph } from "./lower-node-module.js";
@@ -104,14 +110,14 @@ import { lowerReadlineMethodCall } from "./builtins/readline.js";
 import { lowerDiagnosticsChannelMethodCall, lowerDiagnosticsChannelProperty, lowerAsyncLocalStorageMethodCall, lowerTracingChannelMethodCall, lowerTracingChannelProperty, } from "./builtins/async-context.js";
 import { lowerErrorCodeProperty } from "./builtins/errors.js";
 import { lowerProcessProperty, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerProcessStreamProperty, } from "./builtins/process.js";
-import { isConsoleLog, consoleCallMember } from "./builtins/console.js";
+import { consoleCallMember, consoleMethodMember, isConsoleLog, } from "./builtins/console.js";
 import { lowerConsoleNew } from "./lower-console.js";
 import { lowerNumberStaticCall, lowerNumberStaticProperty } from "./builtins/numbers.js";
 import { lowerDateCall } from "./builtins/dates.js";
 import { lowerFsConstantsProperty, lowerBuiltinConstantsProperty, builtinConstantBindingOf, builtinConstantsDestructureDecl, } from "./builtins/constants.js";
 import { lowerStringStaticCall, lowerStringLastIndexOfCall } from "./builtins/strings.js";
 import { lowerPromiseStaticCall } from "./builtins/promises.js";
-import { fenceFetchObjectAssignment, fenceFetchObjectBinding, fenceStaticAbortControllerMemberRead, fenceStaticHeadersIteration, fenceStaticHeadersMember, fenceStaticReadableStreamMember, fenceStaticResponseMember, fenceUnsupportedFetchConstructorMember, refuseUnsupportedApi, stdlibGlobalFnOf, lowerAbortControllerNew, lowerDynamicImportCall, lowerFetchCall, lowerFetchElementMethodCall, lowerResponseNew, lowerFetchWebNew, lowerStaticFetchCompanionCall, lowerStaticAbortControllerCall, lowerStaticAbortSignalListenerCall, lowerStaticReadableStreamCancelCall, lowerStaticReadableStreamControllerCall, lowerStaticReadableStreamNew, lowerStaticReadableStreamReaderCall, lowerStaticResponseCall, lowerStdlibMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol, } from "./lower-stdlib.js";
+import { fenceFetchObjectAssignment, fenceFetchObjectBinding, fenceStaticAbortControllerMemberRead, fenceStaticHeadersIteration, fenceStaticHeadersMember, fenceStaticReadableStreamMember, fenceStaticResponseMember, fenceUnsupportedFetchConstructorMember, refuseUnsupportedApi, stdlibGlobalFnOf, lowerAbortControllerNew, lowerEventTargetNew, lowerDynamicImportCall, lowerFetchCall, lowerFetchElementMethodCall, lowerResponseNew, lowerFetchWebNew, lowerStaticFetchCompanionCall, lowerStaticAbortControllerCall, lowerStaticAbortSignalListenerCall, lowerStaticReadableStreamCancelCall, lowerStaticReadableStreamControllerCall, lowerStaticReadableStreamNew, lowerStaticReadableStreamReaderCall, lowerStaticResponseCall, lowerStdlibMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol, } from "./lower-stdlib.js";
 import { lowerHttpHeadersElement, lowerNetModuleCall, lowerServerMethodCall, lowerServerProperty, lowerTlsRootCertificates, } from "./lower-server.js";
 import { lowerDgramDnsModuleCall, lowerDgramMethodCall } from "./lower-dgram.js";
 import { lowerNodeTestModuleCall, lowerTestDirectCall, lowerTestMethodCall, lowerTestCtxProperty, } from "./lower-test.js";
@@ -1116,6 +1122,9 @@ export class Lowerer {
     /** All storage slots widened for runtime absence, including slots whose
      * current control-flow branch has temporarily narrowed the value. */
     runtimeOptionalStorageLocals = new Set();
+    /** `var` bindings code can read before their first store
+     * (var-hoisting.ts): their storage holds undefined until then. */
+    earlyReadVars = new Set();
     /** Globals whose checker-bare type was widened because an indexed read can
      * carry undefined at runtime. Identifier reads keep the union tag so
      * typeof and later boundaries observe the real value. */
@@ -1129,6 +1138,9 @@ export class Lowerer {
      * prepass. This includes explicit annotations: unchecked TS annotations do
      * not prove that an array property read produced a value. */
     runtimeOptionalBindingTypes = new Map();
+    /** Set when a match result lowers to execGroups/matchGroups, the inputs
+     * of regex span folding. */
+    regexGroupResults = false;
     /** Bindings that receive an unchecked indexed read (or a value derived
      * from one) through an initializer or assignment. The checker narrows a
      * declared optional binding to that read's bare type, so presence tests
@@ -1655,6 +1667,12 @@ export class Lowerer {
     workerTargets;
     workerTargetIdByPath = new Map();
     usesWorkers = false;
+    /** The program constructs a LifetimeRegion (lifetime-regions.ts). */
+    usesLifetimeRegions = false;
+    /** Per-directory answers of experimental-import.ts's declaration-file test. */
+    experimentalFiles = new Map();
+    /** Interned LifetimeRegion.run helpers, by callback type key. */
+    regionRunHelpers = new Map();
     forkTargetIdByPath = new Map();
     /** Namespace ModuleBlocks this program lowers, filled by splitFiles:
      * "flattened" — an instantiated namespace whose body joined the file's
@@ -1761,6 +1779,9 @@ export class Lowerer {
     /** Import-cycle bindings with an initialization flag, by global id, and
      * the top-level statements declaring them (cycle-initialization.ts). */
     cycleInitFlags = new Map();
+    /** Initialization flags of classes reachable before their statement ran,
+     * by class name (cycle-initialization.ts). */
+    classInitFlags = new Map();
     cycleInitDeclarations = new Map();
     get ctx() {
         const top = this.fnStack[this.fnStack.length - 1];
@@ -1784,6 +1805,9 @@ export class Lowerer {
     /** Set while a subclass constructor's super() call notes its base
      * constructor edge: that edge does not instantiate the base exactly. */
     superConstructorEdge = false;
+    /** Set when the async generator `return` being lowered awaited its
+     * promise operand (returnedPromiseAwait). */
+    returnAwaitedPromise = false;
     virtualEdges = new Map();
     classCanBeConstructed(info) {
         return (this.constructedClasses === null ||
@@ -1963,6 +1987,9 @@ export class Lowerer {
             // fileTag is filled just below; the hook is only ever CALLED during
             // lowering, long after the constructor completes.
             isProgramFile: (sf) => this.fileTag.has(sf),
+            lifetimeRegionClass: (decl) => isExperimentalDeclarationFile(decl.getSourceFile(), this.experimentalFiles)
+                ? lifetimeRegionType(this)
+                : null,
             moduleNamespaceId: (type) => this.moduleNamespaceIdOfType(type),
         };
         // Modules reachable only through literal import() joined
@@ -3009,6 +3036,17 @@ export class Lowerer {
                     familyBySymbol.set(symbol, family);
                 }
             }
+            // Static methods never share a dispatch slot: each is its own family.
+            if (info.staticMethods) {
+                for (const sig of info.staticMethods.values()) {
+                    const name = sig.member.name;
+                    if (!(ts.isIdentifier(name) || ts.isStringLiteral(name)))
+                        continue;
+                    const symbol = symbolOf(name);
+                    if (symbol && !signatureBySymbol.has(symbol))
+                        signatureBySymbol.set(symbol, { params: sig.params, returnType: sig.ret, method: sig });
+                }
+            }
         }
         const mappedOrNull = (node) => panicSafe(() => this.mapTypeOf(this.typeOf(node)), null);
         const nanCoded = new NanCodedReads({
@@ -3228,6 +3266,10 @@ export class Lowerer {
                 return true;
             if (ts.isPropertyAccessExpression(e) && isOptionalProcessStreamProperty(this, e))
                 return true;
+            if (ts.isPropertyAccessExpression(e) && isSettledIteratorValueRead(this, e))
+                return true;
+            if (ts.isPropertyAccessExpression(e) && isOsConstantsSymbol(symbolOf(e.expression), this))
+                return true;
             if (ts.isCallExpression(e) && this.runtimeOptionalReduceTypes.has(e))
                 return true;
             if (ts.isCallExpression(e) &&
@@ -3520,6 +3562,19 @@ export class Lowerer {
                     found = true;
             return found;
         };
+        /** A return of a var that code can read before its first store. */
+        const returnsEarlyVar = (fn) => {
+            const early = (e) => {
+                const read = peel(e);
+                if (!ts.isIdentifier(read))
+                    return false;
+                const symbol = symbolOf(read);
+                return symbol !== null && this.earlyReadVars.has(symbol);
+            };
+            if (fn.body && !ts.isBlock(fn.body))
+                return early(fn.body);
+            return returnsOf(fn).some(early);
+        };
         const jsLambdas = [];
         // TypeScript lambdas keep the checker's inferred return type, which
         // spells a missing read as its bare element type and `read ?? "text"`
@@ -4529,6 +4584,19 @@ export class Lowerer {
             }
             return changed;
         };
+        // A `var` that code can read before its first store holds undefined
+        // there, whatever its declared type.
+        for (const symbol of earlyReadVarSymbols(this, sourceFiles)) {
+            // Text codec bindings keep their own presence-checked storage.
+            const declaration = this.checker.valueDeclarationOf(symbol);
+            const mapped = declaration && ts.isVariableDeclaration(declaration)
+                ? mappedOrNull(declaration.name)
+                : null;
+            if (mapped?.kind === "record" && recordTextCodecClass(this.shapes.get(mapped.shapeId)))
+                continue;
+            optionalSymbols.add(symbol);
+            this.earlyReadVars.add(symbol);
+        }
         let changed = true;
         while (changed) {
             changed = false;
@@ -4546,8 +4614,10 @@ export class Lowerer {
                 if (scanReturns(symbol, decl))
                     changed = true;
             for (const fn of tsLambdas) {
-                // An annotated return is the author's contract, as for parameters.
-                if (fn.type)
+                // An annotated return is the author's contract, as for parameters,
+                // except that a var read before its first store is undefined
+                // whatever the annotation says.
+                if (fn.type && !returnsEarlyVar(fn))
                     continue;
                 const mapped = this.mapTypeOf(this.typeOf(fn));
                 if (mapped?.kind !== "func")
@@ -5107,6 +5177,7 @@ export class Lowerer {
                 globals: this.globalsList,
                 entry: ENTRY_NAME,
                 ...(this.usesWorkers ? { workers: true } : {}),
+                ...(this.usesLifetimeRegions ? { lifetimeRegions: true } : {}),
                 ...(isNodeEsmFile(this.entry, this.program) ? {} : { commonJsEntry: true }),
                 ...(this.ffiImports.length > 0 ? { ffiImports: [...this.ffiImports] } : {}),
             };
@@ -5291,6 +5362,8 @@ export class Lowerer {
         for (const info of this.classes.values()) {
             if (info.builtinError)
                 continue; // runtime-provided; nothing lowers
+            if (info.lifetimeRegion)
+                continue; // synthesized with the class
             // Generic-class INSTANTIATIONS (and mixin instantiations) are
             // demand-driven, not units: their members lower unconditionally in
             // the instance drain below — the generic-fn instance rule.
@@ -5606,6 +5679,9 @@ export class Lowerer {
             ...this.liftedFns,
             ...this.implicitFns,
         ];
+        if (this.regexGroupResults)
+            for (const fn of functions)
+                foldRegexSpanReads(this, fn);
         // The worklist can leave a virtual site with a single implementation.
         // Devirtualize after construction/override reachability has settled.
         devirtualizeVirtualCalls(this, functions, {
@@ -7496,8 +7572,10 @@ export class Lowerer {
     returnedPromiseAwait(e) {
         if (e.type.kind !== "promise")
             throw new InternalCompilerError("returned-promise await of a non-promise");
-        if (!this.adoptsReturnedPromise())
+        if (!this.adoptsReturnedPromise()) {
+            this.returnAwaitedPromise = true;
             return { kind: "awaitExpr", value: e, type: e.type.inner, loc: e.loc };
+        }
         return { kind: "awaitExpr", value: e, type: e.type.inner, adopt: true, loc: e.loc };
     }
     /** `return <expr>` lowered as a STATEMENT against the declared return.
@@ -7507,6 +7585,26 @@ export class Lowerer {
      * caller never sees a value, so the return goes out bare. Async
      * void-inner returns still resolve a returned promise first. */
     lowerReturnStmt(node, loc) {
+        if (!(this.ctx.isAsync === true && this.ctx.generator))
+            return this.lowerReturnOf(node, loc);
+        // An async generator's `return x` awaits x; for a promise that await
+        // is the returned-promise await, and the return needs no other turn.
+        const saved = this.returnAwaitedPromise;
+        this.returnAwaitedPromise = false;
+        const s = this.lowerReturnOf(node, loc);
+        const awaited = this.returnAwaitedPromise;
+        this.returnAwaitedPromise = saved;
+        if (!awaited)
+            return s;
+        if (s.kind === "return")
+            return { ...s, awaited: true };
+        if (s.kind === "block" && s.body.at(-1)?.kind === "return") {
+            const last = s.body.at(-1);
+            return { ...s, body: [...s.body.slice(0, -1), { ...last, awaited: true }] };
+        }
+        return s;
+    }
+    lowerReturnOf(node, loc) {
         const expected = this.ctx.returnType;
         if (expected.kind === "void") {
             let e = this.lowerExpr(node);
@@ -8945,7 +9043,8 @@ export class Lowerer {
         // dispatch. The general identifier-call paths have no lowering for a
         // promise-returning ambient global, and `import` is a keyword callee no
         // identifier path matches.
-        return (lowerFfiCall(this, expr) ??
+        return (lowerLifetimeRegionCall(this, expr) ??
+            lowerFfiCall(this, expr) ??
             lowerFetchCall(this, expr) ??
             lowerStaticFetchCompanionCall(this, expr) ??
             lowerStaticAbortControllerCall(this, expr) ??
@@ -9080,7 +9179,9 @@ export class Lowerer {
         return inheritsBuiltinEmitterCtor(this, info);
     }
     lowerNew(expr) {
-        const builtin = lowerAbortControllerNew(this, expr) ??
+        const builtin = lowerLifetimeRegionNew(this, expr) ??
+            lowerAbortControllerNew(this, expr) ??
+            lowerEventTargetNew(this, expr) ??
             lowerFetchWebNew(this, expr) ??
             lowerResponseNew(this, expr) ??
             lowerStaticReadableStreamNew(this, expr) ??
@@ -9135,6 +9236,9 @@ export class Lowerer {
     consoleCallMember(call) {
         return consoleCallMember(this, call);
     }
+    consoleMethodMember(call) {
+        return consoleMethodMember(this, call);
+    }
     /* ── standard library (process + node:fs) ─────────────────────────── */
     builtinImportOf(ident) {
         return builtinImportOf(this, ident);
@@ -9361,6 +9465,10 @@ export class Lowerer {
         if (bi.module === "http" && bi.member === "STATUS_CODES") {
             return { kind: "libCall", fn: "http.statusCodes", args: [], type: DYN, loc };
         }
+        // os.constants: the runtime's null-prototype constants object.
+        if (bi.module === "os" && bi.member === "constants") {
+            return { kind: "libCall", fn: "os.constants", args: [], type: DYN, loc };
+        }
         // tls.rootCertificates through the namespace: the same runtime-valued
         // constant the named-import read lowers to.
         {