@scriptc/compiler 0.0.7 → 0.0.9

package/dist/frontend/lowering/lowerer.js

@@ -14,11 +14,11 @@
  */
 import { isRelativeSpecifier } from "../shared.js";
 import * as ts from "../ts7/adapter.js";
-import { anyOpRequiresDynamicDiag, blockedBindingUseDiag, checkerPanicDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, noLoweringDiag, recordShapeMismatchDiag, requiresDynamicApiDiag, requiresDynamicPackageDiag, requiresDynamicTypeDiag, unionMismatchDiag, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
+import { anyOpRequiresDynamicDiag, blockedBindingUseDiag, checkerPanicDiag, componentTypeDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, intersectionTypeDiag, noLoweringDiag, overloadedSignatureTypeDiag, recordShapeMismatchDiag, requiresDynamicApiDiag, requiresDynamicPackageDiag, requiresDynamicTypeDiag, unionMismatchDiag, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
 import { arrayOf, BOOL, canAdaptDynFuncTo, canConvertToDyn, canCrossIslandBoundary, canExitIslandToType, canMarshalTypedFuncIntoIsland, DYN, F64, isJsonSafeType, isUndefinedArmedUnion, isUnitType, JSVAL, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID } from "../../ir/nodes.js";
 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, formatIrType, ISLAND_AMBIENT_TYPES, isUnitOnlyTsType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../types.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 { 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";
@@ -26,8 +26,8 @@ import { mixinCallClassInfoOf, mixinIntersectionInstanceType } from "./lower-mix
 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, 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, islandRegexpOf, jsvalIn, requireDynamicApi, islandGlobalFnOf, lowerDynamicImportCall, lowerFetchCall, lowerIslandMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol } from "./lower-island.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 { 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";
 import { lowerNodeTestModuleCall, lowerTestDirectCall, lowerTestMethodCall, lowerTestCtxProperty } from "./lower-test.js";
@@ -35,7 +35,7 @@ import { lowerAssertModuleCall, lowerAssertDirectCall } from "./lower-assert.js"
 import { lowerUtilModuleCall } from "./lower-inspect.js";
 import { lowerComptime, comptimeBakeable, rejectComptimeCaptures, comptimeValueToIr } from "./lower-comptime.js";
 import { lowerStmts, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, rejectJumpCrossingFinally, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, lowerJsvalBindingPattern, checkBindingElement, bindPatternTarget, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement } from "./lower-stmts.js";
-import { lowerExpr, maybeNarrow, lowerUnitComparison, lowerNullishCoalesce, lowerOptionalChain, finishOptionalChain, lowerCondition, ensureBool, requireTruthyUnion, eqComparableUnion, lowerIntrinsicProperty, lowerArrayLiteral, lowerObjectLiteral, lowerShorthandValue, rejectThisInObjectMethod, lowerElementAccess, lowerElementWrite, lowerRecordKeyRead, ensureString, lowerTemplate, lowerAsExpression, lowerPrefixUnary, lowerBinary, lowerCaughtTypeofTest, caughtRead, caughtLocalOf, caughtToString, lowerInstanceOf, lowerRegexLiteral, lowerFieldRead, lowerUnionProperty, fieldTarget, fieldGetExpr, fieldSetStmt, lowerFieldCompound, uniqueSymbolKeyOf, foldedStringKeyOf } from "./lower-exprs.js";
+import { lowerDynObjectLiteral, lowerExpr, maybeNarrow, lowerUnitComparison, lowerNullishCoalesce, lowerOptionalChain, finishOptionalChain, lowerCondition, ensureBool, requireTruthyUnion, eqComparableUnion, lowerIntrinsicProperty, lowerArrayLiteral, lowerObjectLiteral, lowerShorthandValue, rejectThisInObjectMethod, lowerElementAccess, lowerElementWrite, lowerRecordKeyRead, ensureString, lowerTemplate, lowerAsExpression, lowerPrefixUnary, lowerBinary, lowerCaughtTypeofTest, caughtRead, caughtLocalOf, caughtToString, lowerInstanceOf, lowerRegexLiteral, lowerFieldRead, lowerUnionProperty, fieldTarget, fieldGetExpr, fieldSetStmt, lowerFieldCompound, uniqueSymbolKeyOf, foldedStringKeyOf } from "./lower-exprs.js";
 import { lowerRecordFieldCall, lowerObjectMethodCall } from "./lower-calls.js";
 import { fenceCrossBlockNsRef, nsPathPrefix } from "./lower-namespaces.js";
 /** Entry function name. '%' cannot appear in a TS identifier, so a user
@@ -280,6 +280,25 @@ export function dynUndefinedExpr(loc) {
         loc,
     };
 }
+/** An always-throwing Node-parity error expression (the error.nodeThrow
+ * libCall — the lowered form of arms Node rejects unconditionally:
+ * ERR_INVALID_THIS receivers, ERR_MISSING_ARGS arity ladders, the
+ * symbol-to-string TypeError). kind 0 Error / 1 TypeError / 2 RangeError;
+ * an empty code means no code slot. `type` is the replaced expression's
+ * own (never materialized — the global.undefRead pattern). */
+export function nodeThrowExpr(kind, code, message, type, loc) {
+    return {
+        kind: "libCall",
+        fn: "error.nodeThrow",
+        args: [
+            { kind: "numLit", value: kind, type: F64, loc },
+            { kind: "strLit", value: code, type: STRING, loc },
+            { kind: "strLit", value: message, type: STRING, loc },
+        ],
+        type,
+        loc,
+    };
+}
 /** The checked-dynamic declaration fallback for unmappable binding types
  * (see irTypeOf), two gates over one story:
  *
@@ -468,6 +487,12 @@ export class Lowerer {
     /** Non-null while an instance body lowers: type-parameter symbol →
      * concrete IR type, consulted inside mapType's recursion. */
     typeParamBindings = null;
+    /** The ts-level twin of typeParamBindings, non-null while a CALL-keyed
+     * instance body lowers: type-parameter symbol → the bound CHECKER type,
+     * consulted where the mapped IrType has already widened away information
+     * the body needs — indexed accesses (`T[K]` needs K's literal key) and
+     * keyed record reads (`o[k]` where k's type is a literal-bound K). */
+    typeParamTsBindings = null;
     /** Non-null while an IMPLICIT-ANY instance body lowers (npm-static JS —
      * lower-calls' implicit-monomorphization section): bound param symbol →
      * the call site's checker type, consulted by typeOf for identifier
@@ -811,6 +836,7 @@ export class Lowerer {
             unions: this.unions,
             classNamer: this.classNamer,
             resolveTypeParam: this.typeParamResolver,
+            resolveTypeParamTs: this.typeParamTsResolver,
             genericClassInstance: (decl, ref) => this.genericClassInstanceType(decl, ref),
             mixinClassInstance: (decl) => this.mixinTypeContext && this.mixinTypeContext.classNode === decl
                 ? { kind: "object", className: this.mixinTypeContext.className }
@@ -895,7 +921,11 @@ export class Lowerer {
                 const recvDecl = recvDecls.find(ts.isImportClause) ?? recvDecls[0];
                 if (recvDecl && ts.isVariableDeclaration(recvDecl) && recvDecl.initializer) {
                     const spec = requireSpecOf(recvDecl.initializer);
-                    const dep = spec !== null ? resolveImport(this.program, recvDecl.getSourceFile(), spec) : null;
+                    const dep = spec === null
+                        ? null
+                        : isRelativeSpecifier(spec)
+                            ? resolveImport(this.program, recvDecl.getSourceFile(), spec)
+                            : npmStaticDepSf7(this.program, recvDecl.getSourceFile(), spec);
                     if (dep)
                         symbol = this.cjsModuleExportSymbol(dep, ident.text);
                 }
@@ -1092,12 +1122,14 @@ export class Lowerer {
     }
     /** True when `expr` is an identifier bound by a top-level
      * `const x = require("./local")` of a RELATIVE module — the CommonJS
-     * namespace binding — or by a DEFAULT import of a CommonJS JS module
-     * (`import d from "./lib.cjs"`: Node binds d to module.exports, the
-     * same value require answers). Member accesses on it resolve through
-     * the export table (property symbols → resolveValueSymbol); the bare
-     * value keeps the namespace-object fence, like ESM namespace imports
-     * of builtins. */
+     * namespace binding — or of a bare specifier naming an opted-in
+     * --npm-static package (its CJS entry is a program module, so the
+     * binding is the same namespace over the same export table), or by a
+     * DEFAULT import of a CommonJS JS module (`import d from "./lib.cjs"`:
+     * Node binds d to module.exports, the same value require answers).
+     * Member accesses on it resolve through the export table (property
+     * symbols → resolveValueSymbol); the bare value keeps the
+     * namespace-object fence, like ESM namespace imports of builtins. */
     cjsLocalModuleBindingOf(expr) {
         if (!ts.isIdentifier(expr))
             return false;
@@ -1115,8 +1147,12 @@ export class Lowerer {
                 return false;
             }
             const spec = requireSpecOf(decl.initializer);
-            if (spec === null || !isRelativeSpecifier(spec))
+            if (spec === null)
                 return false;
+            if (!isRelativeSpecifier(spec) &&
+                npmStaticDepSf7(this.program, decl.getSourceFile(), spec) === null) {
+                return false;
+            }
         }
         // SINGLE-VALUE exporters (`module.exports = Countdown` / `= double` /
         // `= 42`): the requirer's binding IS the exported value, not a
@@ -1215,13 +1251,22 @@ export class Lowerer {
     /** The lowering of a CommonJS `require("./local")` occurrence: a call of
      * the required module's run-once %init at exactly this statement's
      * position — Node's inline evaluation, with the guard supplying the
-     * cache-hit behavior for every require after the first. Null when the
-     * specifier is not a relative program module (builtins load nothing;
-     * anything else kept its preflight fence). */
+     * cache-hit behavior for every require after the first. Bare specifiers
+     * naming an opted-in --npm-static package resolve to that package's
+     * program entry (the same edge preflight admitted — bundle dists require
+     * their external dependencies by name). Null for everything else
+     * (builtins load nothing; the rest kept its preflight fence). */
     requireInitStmt(spec, node) {
-        if (!isRelativeSpecifier(spec))
-            return null;
-        const dep = resolveImport(this.program, node.getSourceFile(), spec);
+        // Relative requires resolve within the program; a BARE require can be
+        // a program-module edge too when it names an opted-in --npm-static
+        // package (one package requiring another — the resolution answered
+        // its shipped JS, the file is in the module order, and the reads
+        // alias its globals). Without the guarded %init call at this position
+        // those globals stay uninitialized: the dep's module body would never
+        // run.
+        const dep = isRelativeSpecifier(spec)
+            ? resolveImport(this.program, node.getSourceFile(), spec)
+            : npmStaticDepSf7(this.program, node.getSourceFile(), spec);
         if (!dep || dep.fileName.endsWith(".json"))
             return null;
         const initName = this.initNameOf.get(dep);
@@ -1823,8 +1868,8 @@ export class Lowerer {
             throw new PoisonError();
         }
         // Would-be records with INDEX SIGNATURES (`Record<string, T>`,
-        // `{ [k: string]: T }`) get a message that points at Map<K, V> — the
-        // container that holds unbounded keys — instead of the generic
+        // `{ [k: string]: T }`) get the index-signature fence (SC2006) naming
+        // the supported key/value domain instead of the generic
         // supported-types recitation.
         if (widened.flags & (ts.TypeFlags.Object | ts.TypeFlags.Intersection) &&
             this.checker.getCallSignatures(widened).length === 0 &&
@@ -1904,6 +1949,77 @@ export class Lowerer {
             this.pushDiag(requiresDynamicTypeDiag(this.checker.typeToString(type), locOf(node)));
             throw new PoisonError();
         }
+        // STANDARD-LIBRARY nominal provenance, decided once: interface/class
+        // declarations in the lib's own files (Date, ArrayBuffer, WeakMap, the
+        // iterator/constructor interfaces). Such types report the SC2020 story
+        // below — the same one the index-signature-carrying lib types above
+        // tell — rather than an overload/record claim no user can act on.
+        const stdlibOwnSym = widened.getSymbol();
+        const stdlibNominal = stdlibOwnSym !== undefined &&
+            this.checker.declarationsOf(stdlibOwnSym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+                this.isStdlibFile(d.getSourceFile()));
+        // OVERLOADED call signatures (SC2007) — after the generic branch, so a
+        // generic overload set keeps the monomorphization story: a value of a
+        // multi-signature type has no single compiled signature to hold.
+        if (!stdlibNominal && this.checker.getCallSignatures(widened).length > 1) {
+            this.pushDiag(overloadedSignatureTypeDiag(this.checker.typeToString(type), locOf(node)));
+            throw new PoisonError();
+        }
+        // INTERSECTIONS that resolved to no lowering (SC2008). The ones that
+        // compile never get here: member intersections intern through the
+        // record path, callable hybrids map to '%call' records, and pinned
+        // mixin instantiations resolve by chain structure.
+        if (widened.isIntersectionType()) {
+            this.pushDiag(intersectionTypeDiag(this.checker.typeToString(type), locOf(node)));
+            throw new PoisonError();
+        }
+        // SUPPORTED shapes over a component outside its slot (SC2009): the
+        // Map/Set domains, array/tuple elements, union arms, function
+        // parameters/returns. The container is not the blocker — name the
+        // component instead of reciting the supported set. Checked BEFORE the
+        // lib claim so Map/Set/Promise instantiation failures keep their
+        // component story (describeComponentBlocker always answers for those
+        // heads).
+        {
+            const detail = describeComponentBlocker(widened, this.typeCtx);
+            if (detail !== null) {
+                this.pushDiag(componentTypeDiag(this.checker.typeToString(type), detail, locOf(node)));
+                throw new PoisonError();
+            }
+        }
+        // STANDARD-LIBRARY nominal types with no lowering at all: the SC2020
+        // story, naming the type — and for the families with a WHY, the same
+        // pointed reason the identifier/constructor chokepoints teach.
+        if (stdlibNominal) {
+            const intlHint = "Intl formatter values have no representation — the COMPOSED en-US forms lower: " +
+                'new Intl.NumberFormat("en-US").format(x) and x.toLocaleString("en-US") with default options; ' +
+                "the rest is ICU locale data the binary does not carry";
+            const typeHints = {
+                ArrayBuffer: "no free-standing ArrayBuffer value exists — typed arrays own their storage " +
+                    "(new Uint8Array(n) allocates; new Uint8Array(new ArrayBuffer(n)) erases the buffer into the view)",
+                SharedArrayBuffer: "no shared-memory threads exist in a compiled program — Uint8Array is the byte storage",
+                NumberFormat: intlHint,
+                DateTimeFormat: intlHint,
+                DurationFormat: intlHint,
+                PluralRules: intlHint,
+                Collator: intlHint,
+                ListFormat: intlHint,
+                RelativeTimeFormat: intlHint,
+                Segmenter: intlHint,
+                DisplayNames: intlHint,
+            };
+            this.pushDiag(noLoweringDiag(this.checker.typeToString(type), locOf(node), typeHints[stdlibOwnSym?.name ?? ""]));
+            throw new PoisonError();
+        }
+        // USER record shapes blocked by ONE member (SC2009's record arm):
+        // name the member and its type.
+        {
+            const detail = describeRecordMemberBlocker(widened, this.typeCtx);
+            if (detail !== null) {
+                this.pushDiag(componentTypeDiag(this.checker.typeToString(type), detail, locOf(node)));
+                throw new PoisonError();
+            }
+        }
         this.pushDiag(unsupportedTypeDiag(this.checker.typeToString(type), locOf(node)));
         throw new PoisonError();
     }
@@ -2051,6 +2167,17 @@ export class Lowerer {
         const sym = t.getSymbol();
         return (sym && this.typeParamBindings.get(sym)) ?? null;
     };
+    /** The ts-level twin of typeParamResolver: the bound CHECKER type of a
+     * type parameter in the current instantiation (typeParamTsBindings), for
+     * the resolutions where mapType's widening already dropped what the body
+     * needs (indexed accesses over literal-bound keys). Inert outside
+     * call-keyed generic instantiation. */
+    typeParamTsResolver = (t) => {
+        if (!this.typeParamTsBindings || !(t.flags & ts.TypeFlags.TypeParameter))
+            return null;
+        const sym = t.getSymbol();
+        return (sym && this.typeParamTsBindings.get(sym)) ?? null;
+    };
     irTypeOf(node) {
         const t = this.typeOf(node);
         // A never-tainted JS type (neverTaintedJsType) maps — never rides as
@@ -2076,8 +2203,10 @@ export class Lowerer {
     }
     /** Exact-shape enforcement (SC2002). Records are monomorphic structs, so
      * everywhere a value flows into a typed slot (call arg, initializer,
-     * assignment, field, return) the shapes must MATCH — TS's structural width
-     * subtyping (`{a, b}` where `{a}` is expected) has no runtime coercion.
+     * assignment, field, return) the shapes must MATCH — or width-coerce:
+     * coerceToExpected already ran widthCoerce (the copy-reshape family),
+     * so what reaches here is the RESIDUE its rules decline, and the
+     * diagnostic names the first blocking rule (describeRecordWidthBlocker).
      * Non-record mismatches are not reachable through tsc-clean programs; the
      * validator ICEs on them as the usual backstop. */
     requireExactShape(node, actual, expected) {
@@ -2136,7 +2265,13 @@ export class Lowerer {
             throw new PoisonError();
         }
         if (containsRecord(actual) || containsRecord(expected)) {
-            this.pushDiag(recordShapeMismatchDiag(this.fmt(expected), this.fmt(actual), locOf(node)));
+            // A record→record pair gets the pointed story: WHICH width rule
+            // declined (a field that doesn't lift, a required field with no
+            // source, an index signature that could hold the completed key).
+            const detail = actual.kind === "record" && expected.kind === "record"
+                ? (this.describeRecordWidthBlocker(actual.shapeId, expected.shapeId) ?? undefined)
+                : undefined;
+            this.pushDiag(recordShapeMismatchDiag(this.fmt(expected), this.fmt(actual), locOf(node), detail));
             throw new PoisonError();
         }
         // Everything else — a plain-kind mismatch like a string flowing into a
@@ -2634,10 +2769,23 @@ export class Lowerer {
      *               recursively — NESTED width)
      *   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
+     *   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
+     *               CLEAN mechanical conversions (cleanFuncAdaptable); the
+     *               stranded (trap-only) dispositions stay out of the plan
      * Null when the pair isn't in the relation — callers keep their fences. */
     widthLiftPlan(src, dst) {
         if (typeEquals(src, dst))
             return { how: "copy" };
+        // An 'unknown' (dyn) DESTINATION slot: the static→DOM 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)) {
+            return { how: "dynIn" };
+        }
         if (dst.kind === "union") {
             if (src.kind === "union") {
                 return this.unionRetagMappable(src.unionId, dst.unionId) ? { how: "retag" } : null;
@@ -2667,6 +2815,32 @@ export class Lowerer {
                 return null;
             return { how: "liftWrap", tag: candidates[0].tag, arm: candidates[0].arm };
         }
+        // A UNION source into a slot that is ONE of its arms (a width copy
+        // whose target field narrowed — the option-table choices shape:
+        // `value: boolean | string` copying into a `value: string` slot the
+        // checker approved): the CHECKED extraction — narrowedArmHelper,
+        // exactly `x!`'s machinery — the proven arm's payload comes out, any
+        // other arm throws the catchable TypeError (divergence 38's stance).
+        if (src.kind === "union" && !isUnitType(dst) && dst.kind !== "void" && this.armTag(src.unionId, dst) >= 0) {
+            return { how: "narrow" };
+        }
+        // A DERIVED instance into a BASE-typed slot (`{ p: Q }` copying into
+        // `{ p: P }`): the same implicit upcast coerceToExpected performs at
+        // top level — prefix layout, a pointer reinterpret, no copy.
+        if (dst.kind === "object" &&
+            src.kind === "object" &&
+            this.isSubclassOf(src.className, dst.className)) {
+            return { how: "upcast" };
+        }
+        // A FUNCTION into a slot whose signature differs only by CLEAN
+        // mechanical conversions (fewer params — JS ignores extras — and
+        // coercibleValue pieces): the general function-value adapter, plan-
+        // gated to the clean subset. The stranded (trap-only) dispositions
+        // funcCoerceAdapter also builds stay TOP-LEVEL only: a width plan
+        // never promises a bridge that can only throw.
+        if (dst.kind === "func" && src.kind === "func" && this.cleanFuncAdaptable(src, dst)) {
+            return { how: "funcAdapt" };
+        }
         if (dst.kind === "record" && src.kind === "record") {
             return this.recordWidthPlan(src.shapeId, dst.shapeId) !== null ? { how: "width" } : null;
         }
@@ -2786,6 +2960,32 @@ export class Lowerer {
                     throw new Error("lowerer bug: planned clsWidth lift failed to intern");
                 return { kind: "call", callee: helper, args: [value], type: dst, loc };
             }
+            case "narrow": {
+                if (value.type.kind !== "union")
+                    throw new Error("lowerer bug: narrow lift on a non-union");
+                const helper = this.narrowedArmHelper(value.type.unionId, dst, loc);
+                if (!helper)
+                    throw new Error("lowerer bug: planned narrow lift failed to intern");
+                return { kind: "call", callee: helper, args: [value], type: dst, loc };
+            }
+            case "dynIn": {
+                if (dst.kind !== "dyn")
+                    throw new Error("lowerer bug: dynIn lift against a non-dyn slot");
+                return { kind: "dynFrom", value, type: DYN, loc };
+            }
+            case "upcast": {
+                if (dst.kind !== "object" || value.type.kind !== "object")
+                    throw new Error("lowerer bug: upcast lift shape");
+                return this.upcastTo(value, dst.className);
+            }
+            case "funcAdapt": {
+                if (dst.kind !== "func" || value.type.kind !== "func")
+                    throw new Error("lowerer bug: funcAdapt lift shape");
+                const adapter = this.funcCoerceAdapter(value.type, dst, loc);
+                if (!adapter)
+                    throw new Error("lowerer bug: planned funcAdapt lift failed to intern");
+                return { kind: "call", callee: adapter, args: [value], type: dst, loc };
+            }
             default: {
                 const _exhaustive = lift;
                 void _exhaustive;
@@ -2803,9 +3003,11 @@ export class Lowerer {
      * optional-flavored field completes to its undefined arm (the
      * literal-completion rule). TUPLES width-coerce too, arity-exact (TS
      * permits no other tuple width): per-position lifts, never completion.
-     * Index-signature shapes keep the exactness fences here (the overflow
-     * CAPTURE helper owns their reshapes). Null when the shapes don't
-     * relate that way. */
+     * Index-signature SOURCES narrow here like any wider record — declared
+     * fields copy, the overflow drops with the width (missing target
+     * fields decline: the overflow could hold them). Index-signature
+     * TARGETS keep the overflow CAPTURE helper (widthCoerce's other arm).
+     * Null when the shapes don't relate that way. */
     /** The pure planning half of recordWidthHelper — every target field's
      * lift, or null when the pair isn't width-coercible. Callers that must
      * validate a WHOLE plan before interning anything (the retag helper's
@@ -2813,7 +3015,13 @@ export class Lowerer {
     recordWidthPlan(fromId, toId) {
         const from = this.shapes.get(fromId);
         const to = this.shapes.get(toId);
-        if (!from || !to || from.indexValue || to.indexValue)
+        // INDEX-SIGNATURE sources narrow like any wider record — the target
+        // fields copy off the declared struct slots and the overflow drops
+        // with the rest of the width (divergence 36's stance; the absent-
+        // completion rule below is the one extra fence). Index-signature
+        // TARGETS keep the overflow CAPTURE helper (widthCoerce's other arm):
+        // a fresh hybrid needs keyed writes, not a field-list literal.
+        if (!from || !to || to.indexValue)
             return null;
         // Tuple↔record pairs never relate; tuple↔tuple only arity-exact.
         if (!!from.tuple !== !!to.tuple)
@@ -2838,8 +3046,12 @@ export class Lowerer {
                     // 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
-                    // keeps the source arity.
-                    if (from.tuple)
+                    // keeps the source arity. Never for INDEX-SIGNATURE sources:
+                    // the overflow may hold this very key at runtime (tsc lets the
+                    // signature satisfy optional target members), so completing to
+                    // undefined would drop a value Node keeps — the pair stays
+                    // fenced.
+                    if (from.tuple || from.indexValue)
                         return null;
                     if (tf.type.kind === "dyn") {
                         plan.set(tf.name, { absentDyn: true });
@@ -2865,6 +3077,92 @@ export class Lowerer {
             this.widthPlanning.delete(key);
         }
     }
+    /** Post-hoc classifier for SC2002's record→record residue: WHY the
+     * width family (recordWidthPlan and the overflow capture — widthCoerce's
+     * two record arms) declined this pair — the FIRST blocking rule, named.
+     * Pure description on the failure path (the site already carries the
+     * rejection): mirrors the planners' gates, never changes what coerces,
+     * and answers null when no pointed story applies (the generic message
+     * stands). */
+    describeRecordWidthBlocker(fromId, toId) {
+        const from = this.shapes.get(fromId);
+        const to = this.shapes.get(toId);
+        if (!from || !to)
+            return null;
+        if (to.indexValue) {
+            // The overflow CAPTURE's gates (lowerRecordOvfCaptureHelper).
+            if (from.tuple || to.tuple)
+                return "a tuple cannot reshape into an index-signature record";
+            const tIv = to.indexValue;
+            const slotOk = (t) => typeEquals(t, tIv) ||
+                (tIv.kind === "dyn" && (t.kind === "dyn" || this.dynConvertible(t))) ||
+                this.widthLiftPlan(t, tIv) !== null;
+            const consumed = new Set();
+            for (const tf of to.fields) {
+                const sf = from.fields.find((f) => f.name === tf.name);
+                if (sf) {
+                    if (this.widthLiftPlan(sf.type, tf.type) !== null) {
+                        consumed.add(tf.name);
+                        continue;
+                    }
+                    return `field '${tf.name}': '${this.fmt(sf.type)}' does not lift into '${this.fmt(tf.type)}'`;
+                }
+                if (tf.type.kind !== "union" || this.armTag(tf.type.unionId, UNDEFINED_T) < 0) {
+                    return `the expected field '${tf.name}' is required and the source has no field to copy into it`;
+                }
+                if (tIv.kind === "dyn" ? !this.dynConvertible(tf.type) : !typeEquals(tf.type, tIv)) {
+                    return `the expected field '${tf.name}' ('${this.fmt(tf.type)}') cannot take a runtime key collision from the '${this.fmt(tIv)}' signature slot`;
+                }
+            }
+            for (const ff of from.fields) {
+                if (consumed.has(ff.name))
+                    continue;
+                if (!slotOk(ff.type)) {
+                    return `the source field '${ff.name}' ('${this.fmt(ff.type)}') cannot enter the expected '[key: string]: ${this.fmt(tIv)}' slot`;
+                }
+            }
+            if (from.indexValue && !slotOk(from.indexValue)) {
+                return `the source's '[key: string]: ${this.fmt(from.indexValue)}' slot cannot enter the expected '[key: string]: ${this.fmt(tIv)}' slot`;
+            }
+            // The dispatch-writes gate: runtime-keyed writes can collide with a
+            // declared field whose type is not the slot's.
+            const dispatchWrites = from.indexValue !== undefined ||
+                from.fields.some((ff) => !consumed.has(ff.name) && to.fields.some((f) => f.name === ff.name));
+            if (dispatchWrites) {
+                const bad = to.fields.find((f) => tIv.kind === "dyn" ? !this.dynConvertible(f.type) : !typeEquals(f.type, tIv));
+                if (bad) {
+                    return `runtime-keyed writes can collide with the expected field '${bad.name}' ('${this.fmt(bad.type)}'), which cannot take a '${this.fmt(tIv)}' slot value`;
+                }
+            }
+            return null;
+        }
+        // The field-copy plan's gates (recordWidthPlan).
+        if (!!from.tuple !== !!to.tuple)
+            return null;
+        if (from.tuple && from.fields.length !== to.fields.length) {
+            return `tuple arities differ (${from.fields.length} vs ${to.fields.length}; TS permits no tuple width)`;
+        }
+        for (const tf of to.fields) {
+            const ff = from.fields.find((f) => f.name === tf.name);
+            if (!ff) {
+                if (from.tuple)
+                    return null;
+                if (from.indexValue) {
+                    return `'${tf.name}' is not a declared field of the source, and the source's index signature could hold it at runtime (a completed undefined would drop that value)`;
+                }
+                if (tf.type.kind === "dyn")
+                    continue;
+                if (tf.type.kind !== "union" || this.armTag(tf.type.unionId, UNDEFINED_T) < 0) {
+                    return `the expected field '${tf.name}' is missing on the source and is not optional`;
+                }
+                continue;
+            }
+            if (this.widthLiftPlan(ff.type, tf.type) === null) {
+                return `field '${tf.name}': '${this.fmt(ff.type)}' does not lift into '${this.fmt(tf.type)}'`;
+            }
+        }
+        return null;
+    }
     recordWidthHelper(fromId, toId, loc) {
         const from = this.shapes.get(fromId);
         const to = this.shapes.get(toId);
@@ -3503,8 +3801,14 @@ export class Lowerer {
             return this.boundaryExitSafe(dst);
         if (dst.kind === "dyn")
             return src.kind !== "dyn" && this.dynConvertible(src);
-        if (src.kind === "dyn")
-            return this.jsonSafe(dst);
+        if (src.kind === "dyn") {
+            // The checked-dynamic function boundary's OUT direction joins the
+            // mechanical set: a dyn result landing in an adaptable func slot
+            // takes dynCheck's per-target shim (coerceToExpected's funcOk rule
+            // — the production/development function-choice ternary shape).
+            return (this.jsonSafe(dst) ||
+                (dst.kind === "func" && canAdaptDynFuncTo(dst, (id) => this.shapes.get(id), (id) => this.unions.get(id))));
+        }
         if (dst.kind === "union") {
             if (src.kind === "union")
                 return this.unionRetagMappable(src.unionId, dst.unionId);
@@ -3517,6 +3821,28 @@ export class Lowerer {
         }
         return false;
     }
+    /** True when a `src` function value enters a `dst` slot through
+     * funcCoerceAdapter with NO stranded (trap-only) piece: no rest packs,
+     * no surplus source params, every slot parameter converts into the
+     * wrapped function's own type, and the result converts back (a void
+     * slot drops it; a void result answers the exact JS undefined for
+     * dyn/jsval slots). The width family's func gate — widthLiftPlan
+     * bridges only signatures whose every call succeeds by construction. */
+    cleanFuncAdaptable(src, dst) {
+        if (src.rest === true || dst.rest === true)
+            return false;
+        if (src.params.length > dst.params.length)
+            return false;
+        for (let i = 0; i < src.params.length; i++) {
+            if (!this.coercibleValue(dst.params[i], src.params[i]))
+                return false;
+        }
+        if (dst.ret.kind === "void")
+            return src.ret.kind !== "jsval";
+        if (this.coercibleValue(src.ret, dst.ret))
+            return true;
+        return src.ret.kind === "void" && (dst.ret.kind === "dyn" || dst.ret.kind === "jsval");
+    }
     /** Interned `%fn.adapt.<n>(f)` — the GENERAL function-value adapter: a
      * `fromT` function value flowing into a `toT` slot whose pieces differ
      * only by coercibleValue conversions. The slot's callers pass toT's
@@ -3552,10 +3878,19 @@ export class Lowerer {
                 strandParams = true;
         }
         let voidRet = null;
+        let strandRet = false;
         if (toT.ret.kind !== "void" && !this.coercibleValue(fromT.ret, toT.ret)) {
-            if (fromT.ret.kind !== "void")
-                return null;
-            voidRet = toT.ret.kind === "dyn" ? "dyn" : toT.ret.kind === "jsval" ? "jsval" : "strand";
+            if (fromT.ret.kind !== "void") {
+                // A RESULT that cannot convert — the strandParams stance, result
+                // side (the production/development function-choice ternary: the
+                // untaken arm's result shape never lands in the slot's): the
+                // assignment compiles, INVOKING the slot runs the function and
+                // throws the stranded TypeError where its result would convert.
+                strandRet = true;
+            }
+            else {
+                voidRet = toT.ret.kind === "dyn" ? "dyn" : toT.ret.kind === "jsval" ? "jsval" : "strand";
+            }
         }
         if (toT.ret.kind === "void" && fromT.ret.kind === "jsval")
             return null;
@@ -3623,6 +3958,12 @@ export class Lowerer {
                     strandThrow(`a void result where the '${this.fmt(toT)}' slot promises '${this.fmt(toT.ret)}' (a thrower typed 'never' never reaches this; a genuinely void function has no result to hand over)`),
                 ];
             }
+            else if (strandRet) {
+                body = [
+                    { kind: "exprStmt", expr: call, loc },
+                    strandThrow(`a '${this.fmt(fromT)}' function invoked through a '${this.fmt(toT)}' slot (the result cannot convert to '${this.fmt(toT.ret)}' — the checker's loose function compatibility admitted the assignment, but the call has no exact lowering)`),
+                ];
+            }
             else {
                 const result = this.coerceToExpected(call, toT.ret);
                 if (!typeEquals(result.type, toT.ret))
@@ -4646,6 +4987,25 @@ export class Lowerer {
                 e = { kind: "call", callee: helper, args: [e], type: expected, loc: e.loc };
             }
         }
+        // A JS FUNC value outside the island marshal set flowing into a
+        // jsval slot (`withPlugins(getSupportInfoWithoutPlugins, 0)` — a
+        // wrapper built at module init around a function the run may never
+        // call): the crossing defers to a call-time fence closure instead of
+        // stopping the statement — jsvalIn's deferral, the implicit-coercion
+        // spelling.
+        if (expected.kind === "jsval" && e.type.kind === "func" && !typeEquals(e.type, expected)) {
+            const diagsBefore = this.diags.length;
+            try {
+                this.requireExactShape(node, e.type, expected);
+            }
+            catch (err) {
+                const fence = islandFuncValueFence(this, err, diagsBefore, node);
+                if (fence)
+                    return fence;
+                throw err;
+            }
+            return e;
+        }
         this.requireExactShape(node, e.type, expected);
         return e;
     }
@@ -4732,6 +5092,55 @@ export class Lowerer {
                 return this.coerceInto(node, this.lowerArrayLiteral(x, expected), expected);
             }
         }
+        // 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
+        // island gate could claim the checker's `any` context (an island
+        // build could never land in the slot: no engine→DOM crossing).
+        if (expected?.kind === "dyn") {
+            let x = node;
+            while (ts.isParenthesizedExpression(x))
+                x = x.expression;
+            if (ts.isObjectLiteralExpression(x) && isJsSourceFile(x.getSourceFile())) {
+                return lowerDynObjectLiteral(this, x);
+            }
+        }
+        // An ARRAY LITERAL against a UNION slot whose own type has no static
+        // home (the JS dyn fallback — the checker gave no usable context):
+        // when the union has exactly ONE array-family arm — an array, or an
+        // arity-matching tuple (the option-table `default: [{ value: [] }]`
+        // shape) — build AS that arm and wrap; the IR-directed twin of
+        // lowerArrayLiteral's contextual-union rule.
+        if (expected?.kind === "union") {
+            let x = node;
+            while (ts.isParenthesizedExpression(x))
+                x = x.expression;
+            if (ts.isArrayLiteralExpression(x)) {
+                const own = this.mapTypeOf(this.checker.getContextualType(x) ?? this.typeOf(x));
+                // Elements beyond bare null/undefined literals can never live in
+                // a unit-only-element array — a checker type that degraded to one
+                // (`[]`-flavored inference over a populated literal) carries no
+                // element information.
+                const nonUnitElems = x.elements.some((el) => !ts.isOmittedExpression(el) &&
+                    el.kind !== ts.SyntaxKind.NullKeyword &&
+                    !(ts.isIdentifier(el) && el.text === "undefined"));
+                if (own === null || own.kind === "dyn" || own.kind === "jsval" ||
+                    (own.kind === "array" && nonUnitElems && this.unitOnlyElem(own.elem)) ||
+                    this.widthLiftPlan(own, expected) === null) {
+                    const def = this.unions.get(expected.unionId);
+                    const arms = (def?.arms ?? []).filter((a) => (a.kind === "array" && !(nonUnitElems && this.unitOnlyElem(a.elem))) ||
+                        (a.kind === "record" &&
+                            !!this.shapes.get(a.shapeId)?.tuple &&
+                            this.shapes.get(a.shapeId).fields.length === x.elements.length &&
+                            !x.elements.some(ts.isSpreadElement)));
+                    if (arms.length === 1) {
+                        const arm = arms[0];
+                        const built = this.lowerArrayLiteral(x, arm);
+                        return this.coerceInto(node, built, expected);
+                    }
+                }
+            }
+        }
         const e = this.lowerExpr(node);
         return expected ? this.coerceInto(node, e, expected) : e;
     }
@@ -4999,8 +5408,8 @@ export class Lowerer {
     lowerGenericFnValue(ref, info) {
         return lowerGenericFnValue(this, ref, info);
     }
-    inferTypeParamBindings(expr, info, rsig) {
-        return inferTypeParamBindings(this, expr, info, rsig);
+    inferTypeParamBindings(expr, info, rsig, tsBindings) {
+        return inferTypeParamBindings(this, expr, info, rsig, tsBindings);
     }
     lowerGenericInstance(info, inst) {
         return lowerGenericInstance(this, info, inst);
@@ -6332,6 +6741,11 @@ export class Lowerer {
         const streamServed = lowerStreamModuleCall(this, call, bi, locOf(access));
         if (streamServed)
             return streamServed;
+        // fs._toUnixTimestamp — off the param tables (an underscore-stable
+        // internal), served by its own spoke before the table fence.
+        const fsTs = this.lowerFsToUnixTimestampCall(call, bi, locOf(access));
+        if (fsTs)
+            return fsTs;
         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));
@@ -6362,6 +6776,11 @@ export class Lowerer {
         const bi = this.builtinMemberOf(expr);
         if (!bi)
             return null;
+        // events.defaultMaxListeners READS the process-wide default (its
+        // write twin routes through emitter.setDefaultMaxChk).
+        if (bi.module === "events" && bi.member === "defaultMaxListeners") {
+            return { kind: "libCall", fn: "emitter.getDefaultMax", args: [], type: F64, loc };
+        }
         const c = builtinModuleConstOf(this, bi.module, bi.member);
         if (c !== undefined)
             return builtinConstLit(c, loc);
@@ -6377,6 +6796,9 @@ export class Lowerer {
     lowerBuiltinModuleCall(expr, bi, fn, loc) {
         return lowerBuiltinModuleCall(this, expr, bi, fn, loc);
     }
+    lowerFsToUnixTimestampCall(expr, bi, loc) {
+        return lowerFsToUnixTimestampCall(this, expr, bi, loc);
+    }
     lowerChildArgsArg(node, loc) {
         return lowerChildArgsArg(this, node, loc);
     }