@scriptc/compiler 0.4.8 → 0.4.9

package/dist/frontend/lowering/lowerer.js

@@ -13,6 +13,7 @@ import { checkedTable, countTable, fixedScalar, flagScalar, functionTable, irDat
 import { UnitReuse, unitReuseVerify, verifyStoredUnit } from "./unit-reuse.js";
 import { moduleNamespaceDynValue, moduleNamespaceObject, moduleNamespaceValue, } from "./module-namespace-elements.js";
 import { keyedHelperName, moduleTagNumber, portableRelativePath } from "./stable-names.js";
+import { noteCodecMode, ZLIB_STREAM_FACTORIES, ZLIB_STREAM_T } from "./builtins/compression.js";
 import { positionTag, StructuralPositions } from "./structural-positions.js";
 import { activeNodeIslands, setActiveNodeIslands, } from "../../node-islands/boundary.js";
 import { bindingSymbolOfRead, onlyForwarded, stripTypeWrappers } from "./typed-arguments.js";
@@ -64,7 +65,7 @@ import { lowerBuiltinCall } from "./builtin-calls.js";
 import { CoercionState } from "./coercions/state.js";
 import { widthLiftPlan, unitOnlyElem, recordWidthPlan, describeRecordWidthBlocker, objToRecordPlan, recordToClassPlan, } from "./coercions/structural-plans.js";
 import { widthCoerce, applyWidthLift, unionRecordWidthHelper, unionArrayWidthHelper, recordWidthHelper, tupleArrayWidthHelper, emptyArrayLiftHelper, arrayWidthHelper, objRecordWidthHelper, recordClassWidthHelper, classStaticsProjection, } from "./coercions/structural.js";
-import { funcReturnWidthAdapter, coercibleValue, cleanFuncAdaptable, funcCoerceAdapter, spawnResFnAdapterPlan, spawnResFnAdapter, } from "./coercions/function-adapters.js";
+import { funcReturnWidthAdapter, coercibleValue, cleanFuncAdaptable, funcCoerceAdapter, sortComparatorResultAdapter, spawnResFnAdapterPlan, spawnResFnAdapter, } from "./coercions/function-adapters.js";
 import { unionRetagMappable, narrowedRetagHelper, uninhabitedArmRetagHelper, strandedUnitTrap, strandedCoercionTrap, recordUnionRouteHelper, recordUnionWrapHelper, unionRetagHelper, narrowedArmHelper, checkedNarrowCall, checkedNarrowOperand, deferredReadHelper, widthNarrowHelper, } from "./coercions/unions.js";
 import { assertedConversion } from "./coercions/asserted.js";
 import { boxBuiltinValuesChecked, lowerUtilTypeValue, checkedNativeCallableValue, pathModuleValue, utilTypesModuleValue, } from "./lower-builtin-values.js";
@@ -85,7 +86,7 @@ import { RuntimeOptionalLocals } from "./runtime-optional-locals.js";
 import { collectContractAnnotations } from "../contract-types.js";
 import { sanitizeUnregisteredClassTypes } from "./sanitize-class-types.js";
 import { UnregisteredClassTypes } from "./unregistered-class-types.js";
-import { bindingInContext, captureContextBinding, declareContextLocal, declareContextThis, newFnCtx, } from "./function-context.js";
+import { bindingInContext, captureContextBinding, captureContextLocal, declareContextLocal, declareContextThis, newFnCtx, } from "./function-context.js";
 import { InternalCompilerError } from "../../errors.js";
 import { defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "./optional-arguments.js";
 import {} from "./class-protocol-dispatch.js";
@@ -94,12 +95,12 @@ import { addUntypedIntegrityWords, guardClassAttributeWrites } from "./class-att
 import { inferredCollectionType } from "./js-collection-types.js";
 import { sloppyDynamicWrites } from "./frozen-records.js";
 import { guardFrozenWrites, markSloppyRecordWrites } from "./frozen-records.js";
-import { applyHandleProperties } from "./handle-properties.js";
+import { alignHandlePropertyChildFact, applyHandleProperties, handlePropertyScanRoots, } from "./handle-properties.js";
 import { installBufferValue } from "./containers/bytes.js";
 import { installMutableBuffersArm } from "./buffers.js";
 import { ClassProtocols } from "./class-protocols.js";
 import { earlyReadVarSymbols } from "./var-hoisting.js";
-import { recordTextCodecClass } from "../../ir/ir.js";
+import { recordTextCodecClass, sortArms } from "../../ir/ir.js";
 import { assignLegacyTiers } from "../../ir/tiers.js";
 import { dynamicSlotOperationCounts, dynamicTierWarning } from "./dynamic-tier.js";
 import { promoteJsvals } from "../../ir/jsval.js";
@@ -137,11 +138,11 @@ import { discriminantOwners, literalUnionArm } from "../union-discriminants.js";
 import { declarationGroupKey, typeFailureOf } from "./type-failure.js";
 import { dynamicSlotDiag } from "../../diagnostics/dynamic-slots.js";
 import { unsupportedAnyOperationDiag, blockedBindingUseDiag, checkerPanicDiag, componentTypeDiag, isCheckerPanic, genericSignatureTypeDiag, hostGlobalDiag, indexSignatureTypeDiag, intersectionTypeDiag, noLoweringDiag, overloadedSignatureTypeDiag, recordShapeMismatchDiag, stdlibSnapshotValueUseDiag, unsupportedNativeApiDiag, unsupportedPackageValueDiag, unionMismatchDiag, UNSUPPORTED, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
-import { arrayOf, BOOL, canAdaptDynFuncTo, canBoxFuncIntoDyn, 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 { arrayOf, BOOL, canAdaptDynFuncTo, canBoxFuncIntoDyn, canDynCheckTo, canConvertToDyn, DYN, 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 { canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, cjsExportsAssignedInFunctions, cjsReexportedModules, cjsNamespaceExportNames, isCheckedJsSourceFile, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isNodeEsmFile, locOf, orderedImportsOf, npmStaticDepSf7, requireSpecOf, isJsWriteTarget7, isStrictCode, resolveImport, workspacePackageOfPath, } from "../program.js";
 import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, erasedOverloadMemberType, formatIrType, FETCH_AMBIENT_TYPES, isOsConstantsSymbol, isOverloadedCallableMemberType, isUnitOnlyTsType, isWorkerHandleType, isFetchHandleType, jsOpenObjectType, mapType, computeSymbolProvenance, declaresLegacyUrl, declaresWebAssemblyNamespace, ShapeRegistry, noteScopeSensitiveMapping, 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 { builtinConstLit, builtinModuleConstOf, builtinModulesArrayLit, builtinFenceHintOf, builtinModuleFnOf, FS_CALLBACK_VALUE_LENGTHS, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalNameOf, stdlibGlobalMember, nodeTypesOnlySymbol, } from "./surfaces.js";
 import { builtinClassAliasOf, runtimeClassValueOfType, } from "./builtins/class-values.js";
 import { splitFiles, collectProgram, collectNpmImports, collectJsonImports, moduleArtifacts, collectGlobals, declSymbolOf, defaultExportSymbolOf, lowerFileInit, lowerDefaultExport, buildMain, appendDynamicImportModules, appendForkModules, appendWorkerModules, } from "./lower-modules.js";
 import { prepareCjsModuleGraph, usesCjsTopLevelThis } from "./lower-node-module.js";
@@ -177,10 +178,10 @@ import { lowerTimersPromisesSetInterval, lowerTimeoutMethodCall } from "./builti
 import { lowerFsToUnixTimestampCall, lowerFsLadderCall, lowerStatsMethodCall, } from "./builtins/filesystem.js";
 import { lowerSpawnSyncCall, lowerSpawnCall, lowerExecFileCall } from "./builtins/child-process.js";
 import { lowerExecSyncCall } from "./builtins/child-process-sync.js";
-import { isProcessEnv, envValueType, lowerProcessEnvGet, refuseHeldEnvWrite, } from "./builtins/environment.js";
+import { isAmbientProcessEnv, envValueType, lowerProcessEnvGet, refuseHeldEnvWrite, } from "./builtins/environment.js";
 import { lowerJsonMethodCall, lowerJsonProperty } from "./builtins/json.js";
 import { lowerCryptoComposedCall, lowerCryptoModuleCall } from "./builtins/crypto.js";
-import { lowerUrlMethodCall, lowerSearchParamsMethodCall } from "./builtins/url.js";
+import { legacyUrlClassValue, lowerUrlMethodCall, lowerSearchParamsMethodCall, } from "./builtins/url.js";
 import { lowerChildMethodCall } from "./builtins/child-process-methods.js";
 import { lowerAtomicsCall } from "./builtins/atomics.js";
 import { lowerBuiltinExtraProperty } from "./builtins/properties.js";
@@ -208,7 +209,7 @@ import { assertFunctionValue, lowerAssertModuleCall, lowerAssertDirectCall, } fr
 import { lowerUtilModuleCall } from "./lower-inspect.js";
 import { lowerSystemErrorMapValue } from "./lower-system-errors.js";
 import { lowerComptime, comptimeBakeable, rejectComptimeCaptures, comptimeValueToIr, } from "./lower-comptime.js";
-import { lowerStmts, hasJsTypeAnnotation, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, checkBindingElement, bindPatternTarget, isParseArgsDynCheckerType, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement, matchGroupsPatternSource, isGuardedRecordRead, holdsEvolvingArray, } from "./lower-stmts.js";
+import { lowerStmts, hasJsTypeAnnotation, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, assertedOnlyFieldRead, checkBindingElement, bindPatternTarget, isParseArgsDynCheckerType, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement, matchGroupsPatternSource, isGuardedRecordRead, holdsEvolvingArray, } from "./lower-stmts.js";
 import { lowerExpr, maybeNarrow, lowerUnitComparison, lowerNullishCoalesce, lowerCondition, ensureBool, requireTruthyUnion, eqComparableUnion, lowerIntrinsicProperty, lowerArrayLiteral, lowerElementAccess, lowerElementWrite, lowerRecordKeyRead, ensureString, lowerTemplate, lowerAsExpression, lowerPrefixUnary, lowerBinary, lowerCaughtTypeofTest, caughtRead, caughtLocalOf, caughtToString, lowerInstanceOf, lowerRegexLiteral, lowerFieldRead, lowerUnionProperty, fieldTarget, fieldGetExpr, fieldSetStmt, lowerFieldCompound, uniqueSymbolKeyOf, matchCallbackParamGroupsOf, } from "./lower-exprs.js";
 import { finishOptionalChain, isOptionalChainTail, lowerOptionalChain, } from "./expressions/optional-chains.js";
 import { foldedStringKeyOf, lowerDynObjectLiteral, lowerObjectLiteral, lowerShorthandValue, rejectThisInObjectMethod, } from "./expressions/object-literals.js";
@@ -490,6 +491,7 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
         projectCheckJs: options.projectCheckJs ?? false,
         targetPlatform,
         startupCrash,
+        admittedOpinions: options.admittedOpinions,
         inlineRequireCycleCalls,
         dynamicImportRejections: options.dynamicImportRejections,
         ffiImports,
@@ -538,13 +540,23 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
     let result = emitted.result;
     let resultLowerer = reachableEmit;
     timing("reachable-emit", { reachable: reachable.size });
+    // The general stream representation (TypeMapperCtx.generalNodeStreams)
+    // is a per-program decision: only a program whose reachable code moved
+    // a general stream into a stdio-represented stream slot lowers again
+    // with it. Every other program keeps the single pass above unchanged.
+    // The stream pass below replaces this pass's result outright, so the
+    // whole-slot comparison runs after it for those programs (it would
+    // otherwise pay for a result the stream pass throws away).
+    const generalNodeStreams = reachableEmit.requiresGeneralNodeStreams;
     // Localized failure (stage L3): push-down must never cost a failing
     // program more errors than the whole-slot checked dynamic. A pushed-down
     // type is baked into the globals, fields and signatures that hold it, so
     // when the program still fails, the emit runs once more with every
     // degraded type held whole, and the pass with fewer errors wins (ties
     // keep push-down). A program that compiles never takes this path.
-    if (result.diagnostics.length > 0 && reachableEmit.hasPartialDegradedTypes()) {
+    if (!generalNodeStreams &&
+        result.diagnostics.length > 0 &&
+        reachableEmit.hasPartialDegradedTypes()) {
         const whole = new Lowerer(program, entry, moduleOrder, {
             facts,
             frontendServices: options.frontendServices,
@@ -576,11 +588,6 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
         }
         timing("whole-slot-relower", { reachable: wholeEmitted.reachable.size });
     }
-    // The general stream representation (TypeMapperCtx.generalNodeStreams)
-    // is a per-program decision: only a program whose reachable code moved
-    // a general stream into a stdio-represented stream slot lowers again
-    // with it. Every other program keeps the single pass above unchanged.
-    const generalNodeStreams = reachableEmit.requiresGeneralNodeStreams;
     // Checked-dynamic stream slots (dyn-streams.ts) are a further per-program
     // decision under the general representation: only a program that moves an
     // untyped value into a stream slot lowers again with them.
@@ -665,6 +672,48 @@ function lowerToIrWithIslands(program, entry, moduleOrder, options) {
         resultLowerer = emit;
         timing("historical-order-relower");
     }
+    // A stream program whose passes still fail takes the whole-slot
+    // comparison here, against the pass whose result stands: the stream pass
+    // replaces the earlier result outright, so the comparison is only worth
+    // paying for on the pass it would judge. The rule is unchanged — the
+    // whole-slot pass is kept only when it has strictly fewer errors.
+    if (generalNodeStreams &&
+        result.diagnostics.length > 0 &&
+        resultLowerer.hasPartialDegradedTypes()) {
+        const whole = new Lowerer(program, entry, moduleOrder, {
+            facts,
+            frontendServices: options.frontendServices,
+            projectCheckJs: options.projectCheckJs ?? false,
+            generalNodeStreams: true,
+            ...(dynNodeStreams ? { dynNodeStreams: true } : {}),
+            targetPlatform,
+            startupCrash,
+            admittedOpinions: options.admittedOpinions,
+            inlineRequireCycleCalls,
+            dynamicImportRejections: options.dynamicImportRejections,
+            ffiImports,
+            libraryCallbacks,
+            forkTargets,
+            workerTargets,
+            ffiBindingSymbols: ffiValidation.symbolsByName,
+            externalTypes,
+            externalTypeSpecifiersByFile,
+            tierMode,
+            runtimeOptionalReport,
+            wholeSlotDegradation: true,
+        });
+        for (const d of extraModuleCycleDiags)
+            whole.pushDiag(d);
+        for (const d of ffiValidation.diagnostics)
+            whole.pushDiag(d);
+        const wholeEmitted = whole.emitReachable(options.libRoots);
+        if (wholeEmitted.result.diagnostics.length < result.diagnostics.length) {
+            reachable = wholeEmitted.reachable;
+            result = wholeEmitted.result;
+            resultLowerer = whole;
+        }
+        timing("whole-slot-relower", { reachable: wholeEmitted.reachable.size });
+    }
     // LIBRARY mode: the profile's export names resolved to the units that
     // supply them — the entry's own unit for a direct export, the declaring
     // module's tagged unit for a re-exported one. The export-map resolution
@@ -1952,6 +2001,14 @@ export class Lowerer {
      * program's JavaScript adds to them (handle-properties.ts). */
     writesOntoChildren = false;
     childAdditions = null;
+    /** Whether the program's JavaScript adds own properties to handles, asks
+     * their integrity, and which class members it shadows
+     * (handle-properties.ts). */
+    handleAdditions = undefined;
+    /** Whether the program has a JavaScript implementation file, the only kind
+     * that can add own properties to a handle, so a typed handle operation of
+     * a program without one keeps its own lowering (handle-properties.ts). */
+    handleJsSources = undefined;
     /** Bindings whose unchecked string arithmetic can produce either a number
      * (NaN for an absent read) or a string. Preserve that result union at bare
      * reads instead of applying the checker-bare string narrowing adapter. */
@@ -2299,7 +2356,16 @@ export class Lowerer {
                     this.armTag(signature.returnType.unionId, UNDEFINED_T) >= 0));
         }
         if (ts.isIdentifier(origin)) {
-            const local = this.resolveLocal(origin);
+            // The whole-program analyses ask this question before any body lowers
+            // (speculativeTypeQueries around analyzeRuntimeOptionalArrayReads), so
+            // there is no function context and no local binding to consult yet: a
+            // binding's storage class settles when its declaration (or its
+            // parameter ABI) lowers, and a query must never mint a capture. Until
+            // then the module global's storage is the only one readable. Every
+            // other caller lowers a body, where an empty stack stays a lowerer bug.
+            const local = this.speculativeTypeQueryDepth > 0 && this.fnStack.length === 0
+                ? null
+                : this.resolveLocal(origin);
             const root = local ? this.runtimeOptionalRootOf(local) : null;
             const global = this.globalOf(origin);
             return ((!!root && this.runtimeOptionalStorageLocals.has(root)) ||
@@ -2951,7 +3017,8 @@ export class Lowerer {
      * record types (finalizeRecordLinks checks them against link sources). */
     recordMethodCalls = [];
     /** Completions of "custom" linked helpers (record-links.ts), which
-     * finalizeRecordLinks runs once the links are known. */
+     * finalizeRecordLinks runs once the links are known, with the record
+     * shapes a checked conversion can leave holding a kept source. */
     linkedHelperFinalizers = [];
     /** Helpers over record types that finalizeRecordLinks completes. */
     linkedHelpers = [];
@@ -3755,6 +3822,10 @@ export class Lowerer {
         // are checked against.
         "ownClassProtocols",
         "verifySymbolProvenance",
+        // Whether the program has a JavaScript implementation file depends only on
+        // its modules, so the answer is a memo computed on first use and the
+        // census in handle-properties.ts reads it again when a unit replays.
+        "handleJsSources",
         // The whole-program prepass analyzeJsWidenedBindings computes this set
         // before lowering begins: a pure function of the program's modules.
         "jsWidenedBindings",
@@ -3902,6 +3973,7 @@ export class Lowerer {
             fixed("errorMethodDispatchRevision", () => this.errorMethodDispatchRevision),
             fixed("errorPropertyDispatchRevision", () => this.errorPropertyDispatchRevision),
             fixed("childAdditions", () => this.childAdditions),
+            fixed("handleAdditions", () => this.handleAdditions),
             fixed("emitterEventTable", () => this.emitterEventTable),
             fixed("emitterAnyNameListener", () => this.emitterAnyNameListener),
             fixed("globalThisWrittenNames", () => this.globalThisWrittenNames),
@@ -5257,6 +5329,30 @@ export class Lowerer {
         }
         return createRequireProgramModuleOf(this, decl.initializer)?.dep ?? null;
     }
+    /** The table module a top-level CommonJS `const { a, ...rest } =
+     * require("./m")` pattern's rest elements copy from: Node builds `rest`
+     * from the module's own enumerable export properties at the require, and
+     * the table's statically known members are exactly those properties.
+     * Null when the pattern has no rest element or the target is not a
+     * table module. */
+    cjsRequireRestTableOf(decl) {
+        if (!ts.isObjectBindingPattern(decl.name))
+            return null;
+        if (!decl.name.elements.nodes.some((e) => e.dotDotDotToken !== undefined))
+            return null;
+        const stmt = decl.parent?.parent;
+        if (stmt === undefined || !ts.isVariableStatement(stmt) || !ts.isSourceFile(stmt.parent))
+            return null;
+        if (!isJsSourceFile(stmt.parent) || decl.initializer === undefined)
+            return null;
+        const spec = requireSpecOf(decl.initializer);
+        if (spec === null)
+            return null;
+        const sf = stmt.parent;
+        const dep = resolveImport(this.program, sf, spec, "require") ??
+            npmStaticDepSf7(this.program, sf, spec, "require");
+        return dep !== null && cjsNamespaceModule(this, dep) ? dep : null;
+    }
     createRequireBindingTargets = new Map();
     createRequireElementTargets = new Map();
     /** The program module a `const x = createRequire(...)("./m")` binding
@@ -5493,7 +5589,19 @@ export class Lowerer {
      * calls of these names. Runs in every pass so the ids are
      * deterministic. */
     prepareModuleInits(parts) {
-        parts.forEach((fp, i) => this.initNameOf.set(fp.sf, `%init.${i}`));
+        // The entry module's %init is %init.0; every other module's number comes
+        // from its stable file name, so adding or reordering modules leaves every
+        // other module's init name unchanged.
+        const initNumbers = new Set([0]);
+        for (const fp of parts) {
+            if (fp.sf === this.entry) {
+                this.initNameOf.set(fp.sf, "%init.0");
+                continue;
+            }
+            const n = moduleTagNumber(this.stableFileName(fp.sf), initNumbers);
+            initNumbers.add(n);
+            this.initNameOf.set(fp.sf, `%init.${n}`);
+        }
         for (const fp of parts) {
             const rawTag = this.fileTag.get(fp.sf) ?? "";
             const tag = rawTag === "" ? "e." : rawTag.replace(/^%/, "");
@@ -6522,7 +6630,7 @@ export class Lowerer {
                 const right = this.mapTypeOf(this.typeOf(e.right));
                 const primitive = (t) => t?.kind === "f64" || t?.kind === "string" || t?.kind === "bool";
                 if (primitive(left) && primitive(right) && !typeEquals(left, right)) {
-                    const arms = [left, right].sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
+                    const arms = sortArms([left, right]);
                     return { kind: "union", unionId: this.unions.intern(arms) };
                 }
                 return null;
@@ -9212,6 +9320,12 @@ export class Lowerer {
         // becomes its js twin), so coverage's dynamic statements are unchanged.
         if (module && this.dynamicFunctions.length > 0)
             promoteJsvals(module);
+        // The child wrapper a handle-property table asks for must match the
+        // module fact that links scr_child.c (the emitter's childProcess
+        // feature): the census that requests it scans files the program may not
+        // reach. Aligned on the final module, so both sides read one fact.
+        if (module)
+            alignHandlePropertyChildFact(module);
         // A program that replaces a process output stream's write method beside
         // Node islands is refused by the executable planner (SC8006): an
         // island's process.stdout is its own object. Only island builds pay for
@@ -9405,6 +9519,11 @@ export class Lowerer {
         // Establish the same managed header/top-level batch here before
         // collection, while the production path simply finds warm memos.
         this.checker.prefetchSourceFileStructures(parts.map((fp) => fp.sf));
+        // The own-property census decides whether a program's JavaScript may
+        // add properties to a handle. It visits every body, reached or not, so
+        // batch the receiver types it reads before collection; the census then
+        // makes no per-node checker request inside a deferred body.
+        this.checker.prefetchCollectionTypes(handlePropertyScanRoots(parts.map((fp) => fp.sf)));
         // Signature collection may read the initializer type of a default whose
         // body type still admits undefined (for example `value =
         // process.env.VALUE`). The expression executes only when reached, but
@@ -11461,7 +11580,8 @@ export class Lowerer {
         // (constructing a dyn from static values is deliberately out this
         // round; only JSON.parse results are dyn).
         if (actual.kind === "dyn") {
-            this.unsupported("SC1100", node, `passing 'unknown' values where '${this.fmt(expected)}' is expected`);
+            this.unsupported("SC1100", node, `passing 'unknown' values where '${this.fmt(expected)}' is expected ` +
+                `(${this.dynCheckBlocker(expected) ?? "this target"} is outside the checked conversion's domain)`);
         }
         if (expected.kind === "dyn") {
             // Function values BOX into dyn when their signature crosses
@@ -11865,33 +11985,10 @@ export class Lowerer {
         // forgiven chains): the VALIDATED extraction — dynCheck, the
         // checked-cast machinery, applied automatically. A value outside the
         // slot's type throws a catchable TypeError instead of misreading the
-        // payload. Only dynCheck's own domain (JSON-representable types,
-        // undefined-armed unions of those, bytes<u8>, the %Error root)
-        // converts; everything else keeps requireExactShape's SC1100 fence.
+        // payload. The domain is EXACTLY the explicit cast's (canDynCheckTo),
+        // so the two crossings can never disagree about what converts;
+        // everything else keeps requireExactShape's SC1100 fence.
         if (expr.type.kind === "dyn" && expected.kind !== "dyn") {
-            const undefArmedOk = expected.kind === "union" &&
-                (this.unions
-                    .get(expected.unionId)
-                    ?.arms.every((a) => a.kind === "undefinedT" ||
-                    this.jsonSafe(a) ||
-                    isDynTypedRefType(a) ||
-                    DYN_HANDLE_KINDS.has(a.kind)) ??
-                    false);
-            const bytesOk = expected.kind === "bytes" && expected.elem === "u8";
-            const errorOk = expected.kind === "object" && expected.className === "%Error";
-            // Program and runtime class instances can return only from a
-            // compiler-owned typed-reference capsule. A parsed/plain dyn object
-            // fails the runtime check; an exact capsule unwraps the original
-            // instance and preserves identity.
-            const classOk = isDynTypedRefType(expected);
-            // ADAPTABLE function targets (the checked-dynamic function
-            // boundary's OUT direction — `const wrapped: F = mustCall(fn)`):
-            // check callable-kind, then unwrap an identical boxed signature
-            // directly or adapt through a per-target shim that dynChecks
-            // arguments/results per F.
-            const funcOk = expected.kind === "func" &&
-                canAdaptDynFuncTo(expected, (id) => this.shapes.get(id), (id) => this.unions.get(id));
-            const handleOk = DYN_HANDLE_KINDS.has(expected.kind);
             noteUntypedStreamFlow(this, expected);
             // `[EventEmitter]` in JavaScript builds an untyped array of the
             // untyped constructor, which a typed array of the class cannot
@@ -11903,13 +12000,7 @@ export class Lowerer {
                 this.pushDiag(unsupportedDiag("SC1090", expr.loc, `holding runtime-provided class values ('${expected.elem.className.slice(1)}') in a typed array`));
                 throw new PoisonError();
             }
-            if (canDynCheckTo(expected, (id) => this.shapes.get(id), (id) => this.unions.get(id)) ||
-                undefArmedOk ||
-                bytesOk ||
-                errorOk ||
-                classOk ||
-                funcOk ||
-                handleOk) {
+            if (canDynCheckTo(expected, (id) => this.shapes.get(id), (id) => this.unions.get(id))) {
                 return { kind: "dynCheck", value: expr, type: expected, loc: expr.loc };
             }
             return expr;
@@ -12369,6 +12460,9 @@ export class Lowerer {
     funcCoerceAdapter(fromT, toT, loc) {
         return funcCoerceAdapter(this, fromT, toT, loc);
     }
+    sortComparatorResultAdapter(fromT, loc) {
+        return sortComparatorResultAdapter(this, fromT, loc);
+    }
     spawnResFnAdapterPlan(fromT, toT) {
         return spawnResFnAdapterPlan(this, fromT, toT);
     }
@@ -13043,6 +13137,65 @@ export class Lowerer {
         return (this.dynConvertible(from) &&
             canDynCheckTo(to, (id) => this.shapes.get(id), (id) => this.unions.get(id)));
     }
+    /** The first reason `t` lies outside the checked conversion's domain
+     * (canDynCheckTo), phrased for a diagnostic; null when it converts. Names
+     * the blocking member rather than restating the whole domain, so an
+     * SC1090/SC1100 fence points at the part that has to change. */
+    dynCheckBlocker(t, seen = new Set()) {
+        const shapes = (id) => this.shapes.get(id);
+        const unions = (id) => this.unions.get(id);
+        if (canDynCheckTo(t, shapes, unions))
+            return null;
+        if (seen.has(typeKey(t)))
+            return `a recursive '${this.fmt(t)}' value`;
+        seen.add(typeKey(t));
+        switch (t.kind) {
+            case "array": {
+                const inner = this.dynCheckBlocker(t.elem, seen);
+                return inner ? `an array whose element is ${inner}` : null;
+            }
+            case "record": {
+                const shape = this.shapes.get(t.shapeId);
+                const field = shape?.fields.find((f) => !canDynCheckTo(f.type, shapes, unions));
+                if (field) {
+                    const inner = this.dynCheckBlocker(field.type, seen);
+                    return inner
+                        ? `a record whose member '${field.name}' is ${inner}`
+                        : `a record whose member '${field.name}' is '${this.fmt(field.type)}'`;
+                }
+                if (shape?.indexValue && !canDynCheckTo(shape.indexValue, shapes, unions)) {
+                    return `a record whose indexed value is '${this.fmt(shape.indexValue)}'`;
+                }
+                return `a '${this.fmt(t)}' record (a layout a dyn value cannot be checked into)`;
+            }
+            case "func": {
+                const param = t.params.find((p) => p.kind !== "dyn" && !canConvertToDyn(p, shapes, unions));
+                if (param) {
+                    return (`a function whose parameter is '${this.fmt(param)}' ` +
+                        `(an argument cannot be converted from the dynamic tier)`);
+                }
+                if (t.rest === true && t.restAbi !== undefined && t.params.at(-1)?.kind !== "array") {
+                    return `a function whose rest parameter is not an array`;
+                }
+                return `a function returning '${this.fmt(t.ret)}' (a result no checked conversion produces)`;
+            }
+            case "promise": {
+                const inner = this.dynCheckBlocker(t.inner, seen);
+                return inner ? `a promise of ${inner}` : null;
+            }
+            case "union": {
+                const arms = this.unions.get(t.unionId)?.arms ?? [];
+                const arm = arms.find((a) => !isUnitType(a) && !canDynCheckTo(a, shapes, unions));
+                if (arm) {
+                    const inner = this.dynCheckBlocker(arm, seen);
+                    return inner ? `a union with an arm that is ${inner}` : null;
+                }
+                return `a '${this.fmt(t)}' union`;
+            }
+            default:
+                return `a '${this.fmt(t)}' value`;
+        }
+    }
     /** True when a static type converts to a dyn value (the dynFrom
      * walker's domain): JSON-safe, bytes<u8> (Uint8Array/Buffer — the checked-dynamic tree's
      * bytes kind, payload copied; stdin chunks into unknown-typed helpers),
@@ -13374,7 +13527,7 @@ export class Lowerer {
      * miss (process.env reads). "undefined" sorts last among all arm typeKeys,
      * so the sorted pair is always [t, undefined]. */
     withUndefinedArm(t) {
-        const arms = [t, UNDEFINED_T].sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
+        const arms = sortArms([t, UNDEFINED_T]);
         return { kind: "union", unionId: this.unions.intern(arms) };
     }
     paramShape(param) {
@@ -13405,14 +13558,23 @@ export class Lowerer {
         return wrappedUndefined(this, type, loc);
     }
     /** The value an OMITTED or deleted property leaves in a record field
-     * slot of `type`: the ABSENT state for undefined-armed unions (the slot
-     * reads as undefined but the property does not exist), the dyn
-     * undefined for 'unknown' slots, and null when the slot cannot be
-     * missing. Only legal as a direct field-slot write (IR fieldAbsent). */
-    absentFieldValue(type, loc) {
+     * slot: the ABSENT state for undefined-armed unions (the slot reads as
+     * undefined but the property does not exist), the absent dyn marker for
+     * an OPTIONAL checked-dynamic slot (`optional: true` on the shape field —
+     * an omitted `?: unknown` property is absent, not present-and-undefined),
+     * the dyn undefined for a required 'unknown' slot, and null when the
+     * slot cannot be missing. Pass the shape FIELD when the caller has one:
+     * the bare dyn type cannot tell optional from required. Only legal as a
+     * direct field-slot write (IR fieldAbsent). */
+    absentFieldValue(field, loc) {
+        const type = "kind" in field ? field : field.type;
+        const optional = "kind" in field ? false : field.optional === true;
         if (type.kind === "union" && this.armTag(type.unionId, UNDEFINED_T) >= 0) {
             return { kind: "fieldAbsent", unionId: type.unionId, type, loc };
         }
+        if (type.kind === "dyn" && optional) {
+            return { kind: "fieldAbsent", type, loc };
+        }
         return this.wrappedUndefined(type, loc);
     }
     /** A field copy that keeps absence: `value` (the converted read of
@@ -13420,26 +13582,32 @@ export class Lowerer {
      * property exists, else the target slot's ABSENT state. Fields that are
      * always present, and targets that cannot be absent, copy `value`
      * as-is. Only legal as a direct field-slot write. */
-    presenceKeepingCopy(obj, shapeId, field, value, loc) {
+    presenceKeepingCopy(obj, shapeId, field, value, loc, 
+    /** The destination field, when the copy changes shape: its optional dyn
+     * flag decides whether an absent source keeps the marker or writes an
+     * ordinary dyn undefined. Defaults to the source field. */
+    target) {
         const present = this.recordFieldPresent(obj, shapeId, field, loc);
         if (present.kind !== "recordHas")
             return value;
-        const absent = this.absentFieldValue(value.type, loc);
+        const absent = this.absentFieldValue(target ?? value.type, loc);
         if (absent?.kind !== "fieldAbsent")
             return value;
         return { kind: "ternary", cond: present, then: value, else_: absent, type: value.type, loc };
     }
     /** Own-property presence of declared field `field` on record `obj`
      * (borrowed — callers pass a repeatable receiver): a runtime test for
-     * undefined-armed union fields, which can be absent, and `true` for
-     * every other declared field. */
+     * undefined-armed union fields and for optional checked-dynamic fields,
+     * which can be absent, and `true` for every other declared field. */
     recordFieldPresent(obj, shapeId, field, loc) {
         // A partial record view (partial-assertions.ts) can lack a field its
         // asserted literal never wrote, whatever the field's required type.
         if (partialAssertionFields(this, shapeId).has(field))
             return { kind: "recordHas", obj, shapeId, field, type: BOOL, loc };
         const f = this.shapes.get(shapeId)?.fields.find((x) => x.name === field);
-        if (f && f.type.kind === "union" && this.armTag(f.type.unionId, UNDEFINED_T) >= 0) {
+        if (f &&
+            ((f.type.kind === "union" && this.armTag(f.type.unionId, UNDEFINED_T) >= 0) ||
+                (f.optional === true && f.type.kind === "dyn"))) {
             return { kind: "recordHas", obj, shapeId, field, type: BOOL, loc };
         }
         return { kind: "boolLit", value: true, type: BOOL, loc };
@@ -14169,6 +14337,12 @@ export class Lowerer {
     declareHiddenLocal(name, type) {
         return declareContextLocal(this.ctx, name, type, false, undefined, undefined);
     }
+    /** Read a hidden slot from the current function: the slot itself when it
+     * was declared here, a threaded capture when the read sits in a function
+     * the declaring one encloses. Null when the owner context is gone. */
+    captureHiddenLocal(local, owner) {
+        return captureContextLocal(this.fnStack, local, owner);
+    }
     /** The body binding of a fixed-tuple rest parameter: one native slot per
      * position (the flattened ABI), rebuilt into the tuple the source names.
      * The empty tuple rides the empty-array representation. */
@@ -14832,6 +15006,12 @@ export class Lowerer {
     lowerDestructuringAssignParts(target, rhs, loc) {
         return lowerDestructuringAssignParts(this, target, rhs, loc);
     }
+    /** The asserted-only member answer (lower-stmts.ts): the value one
+     * element reads from a record shape for a property only an asserted
+     * intersection declares, answered from the shape's kept source. */
+    assertedOnlyFieldRead(propName, srcType, srcRef, bodyT, loc) {
+        return assertedOnlyFieldRead(this, propName, srcType, srcRef, bodyT, loc);
+    }
     lowerBindingPattern(pattern, srcRef, srcType, isLet, out, dynSpell, allowDynObject = false) {
         if (ts.isObjectBindingPattern(pattern)) {
             fenceFetchObjectBinding(this, pattern);
@@ -15772,6 +15952,11 @@ export class Lowerer {
             (bi.member === "posix" || bi.member === "win32")) {
             return pathModuleValue(this, `path/${bi.member}`, loc);
         }
+        // url.Url as a value: the legacy Url constructor (JavaScript sources;
+        // @types/node declares Url as a type only). Its prototype is the one
+        // url.parse() results carry.
+        if (bi.module === "url" && bi.member === "Url")
+            return legacyUrlClassValue(loc);
         // events.defaultMaxListeners READS the process-wide default (its
         // write twin routes through emitter.setDefaultMaxChk). Through an ES
         // module namespace it reads the namespace's copy instead.
@@ -15889,22 +16074,81 @@ export class Lowerer {
             return lowerSystemErrorMapValue(this, loc);
         if (bi.module === "fs" &&
             builtinModuleFnOf(this, bi.module, bi.member)?.fn === "fs.callbackCall") {
-            return {
-                kind: "libCall",
-                fn: "fs.callbackValue",
-                args: [{ kind: "strLit", value: bi.member, type: STRING, loc }],
-                type: DYN,
-                loc,
-            };
+            return this.lowerFsCallbackValue(bi.member, loc);
         }
         // The buffer module's Buffer is the global constructor's value.
         if (bi.module === "buffer" && bi.member === "Buffer")
             return { kind: "libCall", fn: "buffer.constructor", args: [], type: DYN, loc };
         if (bi.module === "fs" && (bi.member === "realpathSync" || bi.member === "realpathSync.native"))
             return fsRealpathValue(this, bi.member === "realpathSync.native", loc);
+        if (bi.module === "zlib") {
+            const mode = ZLIB_STREAM_FACTORIES[bi.member];
+            if (mode !== undefined)
+                return this.lowerZlibStreamFactoryValue(bi.member, mode, loc);
+        }
         const fn = builtinModuleFnOf(this, bi.module, bi.member);
         return fn ? this.lowerNativeCallableValue(fn, `${bi.module}.${bi.member}`, loc) : null;
     }
+    /** An error-first filesystem function as a value: the checked-dynamic
+     * function the runtime dispatches every argument through, carrying Node's
+     * own name and length for the member. */
+    lowerFsCallbackValue(member, loc) {
+        return {
+            kind: "libCall",
+            fn: "fs.callbackValue",
+            args: [
+                { kind: "strLit", value: member, type: STRING, loc },
+                numLit(FS_CALLBACK_VALUE_LENGTHS[member] ?? 0, loc),
+            ],
+            type: DYN,
+            loc,
+        };
+    }
+    /** A zlib stream factory as a value: the options argument reaches the
+     * same runtime constructor the direct call uses, and the value keeps
+     * Node's name and length. */
+    lowerZlibStreamFactoryValue(member, mode, loc) {
+        // The value is called later, often with no other Brotli or zstd call in
+        // the program: connect the codec at the point the factory is read, the
+        // same way a direct call does.
+        noteCodecMode(this, mode, loc);
+        const key = `zlib.streamNew:${member}`;
+        let fnName = this.builtinCallableValueFns.get(key);
+        if (!fnName) {
+            fnName = keyedHelperName(this, "%builtin.value.zlib.streamNew", key);
+            this.builtinCallableValueFns.set(key, fnName);
+            this.builtinCallableValueNames.set(fnName, member);
+            this.builtinCallableValueLengths.set(fnName, 1);
+            const options = { localId: "options.0", name: "options", type: DYN };
+            this.liftedFns.push({
+                name: fnName,
+                params: [options],
+                returnType: ZLIB_STREAM_T,
+                locals: [{ id: options.localId, name: options.name, type: options.type, mutable: false }],
+                body: [
+                    {
+                        kind: "return",
+                        value: {
+                            kind: "libCall",
+                            fn: "zlib.streamNew",
+                            args: [numLit(mode, loc), varRef(options.localId, DYN, loc)],
+                            type: ZLIB_STREAM_T,
+                            loc,
+                        },
+                        loc,
+                    },
+                ],
+                loc,
+            });
+        }
+        return {
+            kind: "closure",
+            fnName,
+            captures: [],
+            type: { kind: "func", params: [DYN], ret: ZLIB_STREAM_T },
+            loc,
+        };
+    }
     lowerNativeCallableValue(fn, display, loc) {
         const valueParams = fn.valueParams;
         if (!valueParams)
@@ -16200,8 +16444,11 @@ export class Lowerer {
     lowerProcessStreamProperty(expr) {
         return lowerProcessStreamProperty(this, expr);
     }
+    /** Whether `node` is the ambient `process.env` object a receiver names:
+     * parentheses and the erased wrappers (`as`, `!`, `satisfies`) are looked
+     * through (environment.ts). */
     isProcessEnv(node) {
-        return isProcessEnv(this, node);
+        return isAmbientProcessEnv(this, node);
     }
     envValueType() {
         return envValueType(this);