@scriptc/compiler 0.0.11 → 0.0.13

package/dist/frontend/lowering/lower-exprs.js

@@ -17,7 +17,7 @@ import { unsupportedModuleFeatureOf } from "../shared.js";
 import { fenceEnumObjectValue, lowerEnumAccess } from "./lower-enums.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, contextualUndefReadType, fenceEarlyAliasUse, fenceEarlyNsMemberRef, lowerNsIdentifierValue, nsMemberIdentOf, nsUndefRead, nsWritableTarget } from "./lower-namespaces.js";
 import { expandoMemberRead, expandoWritableTarget } from "./lower-expando.js";
-import { lowerSocketInstanceOf } from "./lower-server.js";
+import { lowerSocketInstanceOf, lowerTlsRootCertificates } from "./lower-server.js";
 import { findGenericMethodOn, lowerStaticFieldRead } from "./lower-classes.js";
 import { bindingNeverReassigned, implicitMonoFile, lowerTaggedTemplate, nullishGenericBindingUnitOf, objLitGenericFnInfoOf, objLitGenericFnNodeOf, requireObjLitGenericReceiver } from "./lower-calls.js";
 import { mixinFnOfCallee } from "./lower-mixins.js";
@@ -222,9 +222,9 @@ function lowerExprInner(L, expr) {
             // A JS variable INITIALIZER whose BINDING registered as a
             // checked-dynamic module global (the typedef-annotated
             // doc-builder consts whose JSDoc types degraded — DYN slots):
-            // the island build could never land (no engine→DOM crossing
+            // the island build could never land (no engine→dyn crossing
             // exists), so the literal takes its own world's path instead —
-            // the DOM literal, or a static record the slot converts.
+            // the dyn literal, or a static record the slot converts.
             if (isJsSourceFile(expr.getSourceFile()) &&
                 ts.isVariableDeclaration(expr.parent) &&
                 expr.parent.initializer === expr &&
@@ -239,7 +239,7 @@ function lowerExprInner(L, expr) {
             // reference degraded to checker-`any` — the tsgo multi-file
             // value-as-type residue) is not an npm slot: when the literal's
             // OWN type maps statically, it builds that way — the binding's
-            // checked-dynamic slot takes the DOM conversion. Genuinely
+            // checked-dynamic slot takes the dyn conversion. Genuinely
             // island slots (npm .d.ts provenance, plain `any`) keep the
             // native build.
             if (ctxTs !== undefined && (ctxTs.flags & ts.TypeFlags.Any) === 0) {
@@ -274,13 +274,22 @@ function lowerExprInner(L, expr) {
             const argsWith = [];
             const getters = [];
             let spread = null;
-            // A MEMBER a JS file cannot lower or marshal (a generic function
-            // as a value, a signature with checked-dynamic parameters — the
-            // doc-builder public aggregate's degraded pieces): defer like a
-            // statement fence — the slot holds a host closure that THROWS the
-            // captured diagnostic when invoked, so building the aggregate
-            // compiles and only a CALL through the island stops the run.
-            const islandMemberFence = (diagsBefore, err, valueNode) => {
+            // A MEMBER a JS file cannot lower or marshal: defer like a
+            // statement fence, shaped by what the member IS. A FUNCTION-shaped
+            // member (a generic function as a value, a signature with
+            // checked-dynamic parameters — the doc-builder public aggregate's
+            // degraded pieces) becomes a host closure that THROWS the captured
+            // diagnostic when invoked — building the aggregate compiles and
+            // only a CALL through the island stops the run. A DATA-shaped
+            // member must NOT become a callable (the retired fence box's
+            // silent wrong answers: typeof said "function", downstream errors
+            // blamed the wrong thing — the withPlugins `plugins:` slot), so it
+            // defines through the engine's getter machinery instead: READING
+            // the member throws the diagnostic — the honest granularity, since
+            // using the value is exactly what cannot be answered. `getterName`
+            // null keeps the closure shape (function-shaped members, and the
+            // conditional-spread arms where getters cannot combine).
+            const islandMemberFence = (diagsBefore, err, valueNode, getterName = null) => {
                 if (!(err instanceof PoisonError) ||
                     !isJsSourceFile(expr.getSourceFile()) ||
                     L.diagSink !== null ||
@@ -310,8 +319,33 @@ function lowerExprInner(L, expr) {
                     loc: locOf(valueNode),
                 });
                 const fence = { kind: "closure", fnName, captures: [], type: funcOf([], VOID), loc: locOf(valueNode) };
+                if (getterName !== null) {
+                    getters.push({ name: getterName, fn: L.jsvalIn(fence, valueNode), loc: locOf(valueNode) });
+                    return null;
+                }
                 return L.jsvalIn(fence, valueNode);
             };
+            // The member's SHAPE decides the fence's granularity: syntactic
+            // functions and checker-callable values keep the call-time
+            // closure; everything else (call results, awaits, data reads —
+            // the withPlugins `plugins:` shape) fences at the READ.
+            const funcShapedMember = (p) => {
+                if (ts.isMethodDeclaration(p))
+                    return true;
+                const src = ts.isPropertyAssignment(p)
+                    ? p.initializer
+                    : ts.isShorthandPropertyAssignment(p)
+                        ? p.name
+                        : null;
+                if (!src || !ts.isExpression(src))
+                    return true; // unknown form: keep the closure shape
+                let inner = src;
+                while (ts.isParenthesizedExpression(inner))
+                    inner = inner.expression;
+                if (ts.isArrowFunction(inner) || ts.isFunctionExpression(inner))
+                    return true;
+                return L.checker.getCallSignatures(L.typeOf(src)).length > 0;
+            };
             const pushProp = (name, value, valueNode, into) => {
                 const diagsBefore = L.diags.length;
                 let marshaled;
@@ -319,7 +353,15 @@ function lowerExprInner(L, expr) {
                     marshaled = L.jsvalIn(value, valueNode);
                 }
                 catch (err) {
-                    marshaled = islandMemberFence(diagsBefore, err, valueNode);
+                    // A value that LOWERED but cannot cross (a promise, a class
+                    // instance): func-typed values keep the call-time closure;
+                    // data-shaped values fence at the read (the getter), unless a
+                    // conditional spread owns the literal (getters cannot combine).
+                    const asGetter = value.type.kind !== "func" && spread === null;
+                    const fence = islandMemberFence(diagsBefore, err, valueNode, asGetter ? name.text : null);
+                    if (fence === null)
+                        return; // registered as a fence getter — no data property
+                    marshaled = fence;
                 }
                 for (const args of into) {
                     args.push({
@@ -403,7 +445,11 @@ function lowerExprInner(L, expr) {
                                 : null;
                 }
                 catch (err) {
-                    value = islandMemberFence(valueDiagsBefore, err, prop);
+                    const nameText = name && (ts.isIdentifier(name) || ts.isStringLiteral(name)) ? name.text : null;
+                    const asGetter = nameText !== null && spread === null && !funcShapedMember(prop);
+                    value = islandMemberFence(valueDiagsBefore, err, prop, asGetter ? nameText : null);
+                    if (value === null)
+                        continue; // registered as a fence getter — no data property
                 }
                 if (value && name && (ts.isIdentifier(name) || ts.isStringLiteral(name))) {
                     pushProp(name, value, prop, [argsWithout, argsWith]);
@@ -494,7 +540,7 @@ function lowerExprInner(L, expr) {
         }
         // A checker-narrowed dyn read arrives as a VALIDATED extraction
         // (maybeNarrow's dynCheck bridge). typeof needs no extraction — the
-        // DOM kind table answers the question directly, and answers it even
+        // dyn kind table answers the question directly, and answers it even
         // where the flow type lied (the extraction would throw instead) —
         // so unwrap back to the dyn value and take the dyn.typeof path.
         if (operand.kind === "dynCheck" && operand.value.type.kind === "dyn") {
@@ -539,7 +585,7 @@ function lowerExprInner(L, expr) {
         if (operand.type.kind === "dyn") {
             // Bare typeof on a dyn value: the runtime's kind→string table
             // (null answers "object", boxed closures "function" — JS-exact
-            // for every DOM kind; "bigint"/"symbol" have no producers).
+            // for every dyn kind; "bigint"/"symbol" have no producers).
             return { kind: "libCall", fn: "dyn.typeof", args: [operand], type: STRING, loc };
         }
         L.unsupported("SC1090", expr, "typeof expressions on statically-typed values");
@@ -549,7 +595,7 @@ function lowerExprInner(L, expr) {
             return { kind: "selfRef", type: L.ctx.selfType, loc };
         }
         // `arguments` in a variadic JS function (the rest-marked form): the
-        // synthetic trailing DOM-array param — lambdaSignature marked the
+        // synthetic trailing dyn-array param — lambdaSignature marked the
         // type and lowerLambda declared the local.
         if (expr.text === "arguments" && L.ctx.argumentsLocal) {
             return { kind: "varRef", localId: L.ctx.argumentsLocal.id, type: DYN, loc };
@@ -618,7 +664,7 @@ function lowerExprInner(L, expr) {
             // optional/default/rest declarations pass the value fence first.
             L.noteEdge(sig.name);
             // dynRest slots stay out of the VALUE type's param list (fn.length
-            // semantics); the rest marker carries the trailing DOM-array ABI.
+            // semantics); the rest marker carries the trailing dyn-array ABI.
             const funcType = {
                 kind: "func",
                 params: sig.params.filter((p) => p.mode !== "dynRest").map((p) => p.type),
@@ -647,10 +693,11 @@ function lowerExprInner(L, expr) {
             if (acc)
                 return acc;
         }
-        // A binding destructured from http2.constants: the baked literal
-        // (the declaration emitted nothing — http2ConstantsDestructureDecl).
+        // A binding destructured from a baked constants object
+        // (http2.constants / crypto.constants): the literal — the
+        // declaration emitted nothing (builtinConstantsDestructureDecl).
         {
-            const h2c = L.http2ConstantBindingOf(expr);
+            const h2c = L.builtinConstantBindingOf(expr);
             if (h2c)
                 return h2c;
         }
@@ -669,6 +716,14 @@ function lowerExprInner(L, expr) {
                 if (bi.module === "module" && bi.member === "builtinModules") {
                     return builtinModulesArrayLit(loc);
                 }
+                // tls.rootCertificates: a runtime-valued module constant (the
+                // cached bundled-CA array) — the one member read that lowers
+                // to a libCall instead of a baked literal.
+                {
+                    const roots = lowerTlsRootCertificates(L, bi, loc);
+                    if (roots)
+                        return roots;
+                }
                 // JavaScript sources: a builtin member taken as a bare VALUE is
                 // the same identity-token story as stdlib globals above (the
                 // harness adds worker_threads.Worker to its identity Set).
@@ -999,7 +1054,7 @@ function lowerExprInner(L, expr) {
         if (value.type.kind !== "promise") {
             // A CHECKED-DYNAMIC operand (`await v` where v rode an untyped
             // binding — a destructured helper's return, a dyn call result):
-            // the runtime decides — a DOM promise adopts (rejections
+            // the runtime decides — a dyn promise adopts (rejections
             // re-throw), anything else takes JS's one-hop non-thenable await
             // and answers itself. Thenable adoption stays unmodeled
             // (SEMANTICS.md).
@@ -1157,9 +1212,9 @@ function lowerExprInner(L, expr) {
         // bound handle).
         if (L.isIslandExpr(expr.expression)) {
             const receiver = L.lowerExpr(expr.expression);
-            // The checker said 'any' but the VALUE lives in the DOM (`this`
+            // The checker said 'any' but the VALUE lives in the checked-dynamic tree (`this`
             // in a plain JS function — dyn.this — or a checked-dynamic local
-            // behind an any-typed spelling): the property read is the DOM's
+            // behind an any-typed spelling): the property read is the checked-dynamic tree's
             // own keyed read, dyn results and dyn chains exactly like every
             // checked-dynamic member access (a nullish receiver throws V8's
             // catchable TypeError, exactly Node). Never a jsOp over a dyn —
@@ -1401,7 +1456,7 @@ function lowerExprInner(L, expr) {
             L.lowerFsConstantsProperty(expr) ??
             // http2.constants.NGHTTP2_CANCEL (any constants-object spelling):
             // the baked-literal table.
-            L.lowerHttp2ConstantsProperty(expr) ??
+            L.lowerBuiltinConstantsProperty(expr) ??
             // Builtin namespace imports (`path.sep`, `os.EOL`,
             // `fs.constants.R_OK` where the root is `import * as ...`): the
             // same constants and per-member fences as named builtin imports.
@@ -1443,14 +1498,14 @@ function lowerExprInner(L, expr) {
         // .length` where the binding is an evolving any[] living as a
         // checked-dynamic global): the stdlib member fence below would blame
         // the unmappable checker type (`any[].length`), but the VALUE is a
-        // DOM node — lower the receiver first and read through the DOM keyed
+        // dyn node — lower the receiver first and read through the dyn keyed
         // read (ARR answers length; everything else JS's own-property
         // answer). Mapped receivers keep the fence-first order: their
         // members' gaps are real surface gaps ([1,2].entries), not
         // representation artifacts. `.length` on a receiver whose checker
         // ARRAY type lowers to the checked-dynamic representation —
         // `unknown[]`, the collapsed `(string | object)[]`, and the `any[]`
-        // an Array.isArray guard narrows a collapsed union to — is the DOM
+        // an Array.isArray guard narrows a collapsed union to — is the checked-dynamic tree
         // array's OWN length (a keyed read the ARR kind answers exactly),
         // never an `Array.prototype` surface gap; both source languages.
         // Prototype-method VALUE reads (`ps.map` unparenthesized) keep the
@@ -1460,7 +1515,7 @@ function lowerExprInner(L, expr) {
         if ((isJsSourceFile(expr.getSourceFile()) &&
             (L.mapTypeOf(L.typeOf(expr.expression)) === null ||
                 // A never-tainted receiver type maps (never rides as f64) but
-                // its VALUE lowered checked-dynamic — same DOM read.
+                // its VALUE lowered checked-dynamic — same dyn read.
                 neverTaintedJsType(L, expr.expression, L.typeOf(expr.expression)))) ||
             (expr.name.text === "length" &&
                 (L.checkerAnyArray(expr.expression) ||
@@ -1571,7 +1626,7 @@ function lowerExprInner(L, expr) {
         // the property and the receiver's type instead of "property access".
         const recvLowered = L.lowerExpr(expr.expression);
         // A dyn receiver — JSON.parse's `any`, or `unknown` the checker
-        // narrowed to `object` — reads through the DOM keyed read: member
+        // narrowed to `object` — reads through the dyn keyed read: member
         // or undefined (JS's own-property answer), throwing JS's TypeError
         // on undefined/null receivers unless an earlier `?.` guards the
         // chain. Scalar-narrowed occurrences bridge via maybeNarrow's
@@ -1812,16 +1867,17 @@ export function lowerTernary(L, expr, expected) {
         // tagged element type the checker's own type doesn't spell).
         const own = L.mapTypeOf(L.typeOf(expr));
         const useCtx = (ctxMapped?.kind === "record" || ctxMapped?.kind === "union" || ctxMapped?.kind === "object") &&
-            (own === null || (own.kind === "union" && !typeEquals(own, ctxMapped)));
+            (own === null ||
+                (own.kind === "union" && !typeEquals(own, ctxMapped) && !L.inLogicalLeftPosition(expr)));
         // Mixed dyn/unit arms under an unmappable own type (`typeof pkg.name
         // === "string" ? pkg.name : null` — the lowering world types the
         // unknown-receiver read `any`, which a static build cannot hold):
         // dyn represents null and undefined directly, so the ternary stays
-        // dyn — a unit arm converts to the DOM unit value (the dynFrom form
+        // dyn — a unit arm converts to the dyn unit value (the dynFrom form
         // the index-signature lowerings already use). A FRESH literal arm
         // (`... ? pkg.scripts : {}` — the default-object idiom) converts the
         // same way when it is JSON-safe: nothing else aliases a literal, so
-        // the DOM copy is unobservable.
+        // the dyn copy is unobservable.
         const dynish = (e) => e.type.kind === "dyn" ||
             e.kind === "unitLit" ||
             ((e.kind === "recordLit" || e.kind === "arrayLit") && L.dynConvertible(e.type));
@@ -1907,13 +1963,13 @@ export function maybeNarrow(L, expr, node) {
             (narrowed.kind === "f64" || narrowed.kind === "bool" || narrowed.kind === "string")) {
             return { kind: "dynCheck", value: expr, type: narrowed, loc: expr.loc };
         }
-        // An `instanceof Uint8Array` narrow: the DOM's bytes kind, extracted
+        // An `instanceof Uint8Array` narrow: the checked-dynamic tree's bytes kind, extracted
         // with the same validated copy the checked cast uses (a Buffer that
         // crossed in rides the kind too — it IS a Uint8Array in Node).
         if (narrowed?.kind === "bytes" && narrowed.elem === "u8") {
             return { kind: "dynCheck", value: expr, type: narrowed, loc: expr.loc };
         }
-        // An `instanceof Error` narrow: the DOM's error encoding rebuilds a
+        // An `instanceof Error` narrow: the checked-dynamic tree's error encoding rebuilds a
         // fresh %Error (name/message/code from the marker object — a COPY,
         // the unknown boundary's stance; SEMANTICS.md 67), validated like
         // every dyn extraction.
@@ -2089,7 +2145,7 @@ export function lowerLooseNullCompare(L, expr, loc) {
         return { kind: "boolLit", value: !negated, type: BOOL, loc };
     }
     if (other.type.kind === "dyn") {
-        // `v != null` on unknown: one DOM kind test covers both units.
+        // `v != null` on unknown: one dyn kind test covers both units.
         return {
             kind: "dynTest",
             test: "nullish",
@@ -2248,7 +2304,7 @@ export function lowerNullishCoalesce(L, expr, loc) {
         // runtime kind (scr_dyn_is_nullish — UNDEF/NULL take the default;
         // a wrapped island value routes to the engine's test, defensively:
         // the wrap constructor scalar-normalizes engine null/undefined
-        // away). Both sides live in the DOM — the right converts through
+        // away). Both sides live in the checked-dynamic tree — the right converts through
         // the usual boundary and evaluates lazily in its branch; a default
         // with no dyn representation keeps the fence.
         const right = L.coerceToExpected(L.lowerExpr(expr.right), DYN);
@@ -2530,7 +2586,7 @@ export function lowerOptionalChain(L, expr) {
             }
             // NUMBER-typed indices (`entries?.[0]`): the property key is
             // ToString(i), exactly JS — the canonical number text answers
-            // array indices in the DOM helper, anything else (fractions,
+            // array indices in the dyn helper, anything else (fractions,
             // negatives, NaN) reads as an absent key.
             if (key.type.kind === "f64") {
                 const skey = { kind: "toString", operand: key, type: STRING, loc: key.loc };
@@ -2538,12 +2594,12 @@ export function lowerOptionalChain(L, expr) {
             }
         }
         // The METHOD-call step (`rawName?.match(re)` on a dyn value): a
-        // nullish receiver short-circuits to the undefined DOM singleton
+        // nullish receiver short-circuits to the undefined dyn singleton
         // (dyn represents undefined directly); anything else runs the
         // VALIDATED dynamic dispatch — the same one the truthy-guarded
         // spelling (`v ? v.match(...) : null`) compiles to, Node-shaped
         // TypeError on a kind mismatch included. The dispatch's static
-        // result converts back into the DOM (the chain's checker type is
+        // result converts back into the checked-dynamic tree (the chain's checker type is
         // the error-any world's `any`, so dyn IS its representation).
         if (ts.isCallExpression(expr) &&
             ts.isPropertyAccessExpression(dotNode) &&
@@ -2714,7 +2770,7 @@ export function finishOptionalChain(L, expr, id, receiver, body, loc) {
     }
     // A dyn body (`pricing?.[key]` — an unknown-valued index-signature
     // read) stays dyn: `unknown | undefined` IS unknown, and dyn represents
-    // undefined directly (the unit path yields the undefined DOM value).
+    // undefined directly (the unit path yields the undefined dyn value).
     if (body.type.kind === "dyn") {
         return { kind: "optChain", id, receiver, body, type: DYN, loc };
     }
@@ -2770,8 +2826,8 @@ export function ensureBool(L, e, node) {
         return { kind: "toBool", operand: e, type: BOOL, loc: e.loc };
     }
     if (e.type.kind === "dyn") {
-        // ToBoolean over the DOM (`if (pkg)` on a JSON.parse result): every
-        // DOM kind has a JS-exact answer — the truthy dynTest reads the kind
+        // ToBoolean over the checked-dynamic tree (`if (pkg)` on a JSON.parse result): every
+        // dyn kind has a JS-exact answer — the truthy dynTest reads the kind
         // tag (plus the scalar payload for number/string).
         return { kind: "dynTest", test: "truthy", value: e, type: BOOL, loc: e.loc };
     }
@@ -2797,7 +2853,7 @@ export function ensureBool(L, e, node) {
     L.badType(node, L.typeOf(node));
 }
 /** Truthiness needs a ToBoolean per arm: dyn/caught arms have none (a
-   * dynamic ToBoolean over the DOM / the snapshot box) — fence those
+   * dynamic ToBoolean over the checked-dynamic tree / the snapshot box) — fence those
    * unions; every other arm kind is answerable (units false, scalars and
    * strings by value, refs true, jsval by the engine). */
 export function requireTruthyUnion(L, unionId, node) {
@@ -2826,7 +2882,7 @@ export function lowerIntrinsicProperty(L, expr) {
         return null;
     // A never-tainted JS receiver type lowered checked-dynamic
     // (neverTaintedJsType — `cmd.length` on `const cmd = ['pwd', []]`):
-    // stand down so the DOM keyed read below the chain answers, instead
+    // stand down so the dyn keyed read below the chain answers, instead
     // of an array libCall over a dyn receiver hitting the boundary fence.
     let kind = neverTaintedJsType(L, expr.expression, L.typeOf(expr.expression))
         ? undefined
@@ -3090,8 +3146,8 @@ export function lowerIntrinsicProperty(L, expr) {
             return { kind: "jsExit", value: read, type: F64, loc: locOf(expr) };
         }
         // A CHECKED-DYNAMIC value behind an array-typed checker spelling
-        // (`Object.keys(u).length` — the dyn walk answers a DOM array while
-        // tsc spells string[]): the runtime-world dispatch — a DOM keyed
+        // (`Object.keys(u).length` — the dyn walk answers a dyn array while
+        // tsc spells string[]): the runtime-world dispatch — a dyn keyed
         // read validated into the declared number (a lying length throws
         // the catchable TypeError, the dynCheck stance).
         if (receiver.type.kind === "dyn") {
@@ -3134,7 +3190,7 @@ export function lowerArrayLiteral(L, expr, expected) {
     // A JS literal whose OWN inferred type is never-tainted
     // (neverTaintedJsType — the evolving `const gb = []`, the mixed
     // command tuple `['pwd', []]`) carries no element information: route
-    // it to the DOM fallback below rather than letting never's f64
+    // it to the checked-dynamic tree fallback below rather than letting never's f64
     // representation build a static number array (a later dyn push would
     // throw "expected number at $, got string"; the tuple's union arm
     // would re-tag as number[] and fence). A REAL slot still wins:
@@ -3264,14 +3320,14 @@ export function lowerArrayLiteral(L, expr, expected) {
     if (!mapped || mapped.kind !== "array") {
         // The JS declaration fallback, literal-side: an element type with no
         // static home (a string | string[] mixed command tuple, an evolving
-        // []) builds as a DOM ARRAY — one dyn value whose elements each
+        // []) builds as a dyn ARRAY — one dyn value whose elements each
         // convert through the usual boundary (dynFrom's JSON-safe domain);
         // an element that cannot convert fences per element. length/index
-        // reads and dynamic consumers ride the keyed-DOM paths. TS literals
+        // reads and dynamic consumers ride the keyed-dyn paths. TS literals
         // take the same build when the slot ITSELF is checked-dynamic — an
         // `unknown[]` annotation or a collapsed `(string | object)[]` maps
         // to DYN wholesale now (mapType's dyn-element array rule), so the
-        // literal IS the DOM array.
+        // literal IS the dyn array.
         if (isJsSourceFile(expr.getSourceFile()) || mapped?.kind === "dyn") {
             const elems = expr.elements.map((el) => {
                 if (ts.isSpreadElement(el)) {
@@ -3557,12 +3613,12 @@ function propNameText(L, name) {
     return name.text;
 }
 /** The runtime-keyed JS object literal (a computed key that doesn't fold):
-   * builds a DOM object member-by-member. Keys evaluate before their values,
+   * builds a dyn object member-by-member. Keys evaluate before their values,
    * properties in source order — JS's object-literal evaluation exactly.
    * Identifier/string keys are compile-time strings; numeric keys take
    * their canonical number string (`{ 0x10: v }` stores "16" — JS's
    * ToPropertyKey); computed keys evaluate and pass through ToString (the
-   * DOM's String() for dyn operands — `{ [field]: v }` where field is a
+   * dyn's String() for dyn operands — `{ [field]: v }` where field is a
    * checked-dynamic param). Values convert through the usual dyn boundary
    * (dynFrom's domain, functions box); a value with no dyn representation
    * fences per property. Spreads, accessors, and methods stay fenced —
@@ -3655,7 +3711,7 @@ export function lowerDynObjectLiteral(L, expr) {
                 L.unsupported("SC1101", valueExpr, `holding '${L.fmt(v.type)}' values in a runtime-keyed (computed-key) object literal`);
             }
             catch (err) {
-                // A member value the DOM cannot hold — a func whose signature
+                // A member value the checked-dynamic tree cannot hold — a func whose signature
                 // cannot box, an island ('any') handle, a record carrying func
                 // fields (the export aggregate's typed utilities and npm-handle
                 // members): the same call-time fence deferral as an unlowerable
@@ -3725,7 +3781,7 @@ function fenceClosureProbe(L, node, slotType, attempt) {
         return null;
     }
     // The trap's ABI: the field's func slot when one exists; otherwise (the
-    // DOM-object literal path — the value boxes into dyn) the all-dyn
+    // dyn-object literal path — the value boxes into dyn) the all-dyn
     // signature of the lambda's own arity, which canBoxFuncIntoDyn always
     // admits.
     const fieldType = slotType !== undefined && slotType.kind === "func"
@@ -3868,7 +3924,7 @@ export function lowerObjectLiteral(L, expr) {
     const loc = locOf(expr);
     // The RUNTIME-KEYED literal (JS): a computed key that doesn't fold to a
     // compile-time string means the literal's shape is not a compile-time
-    // fact — no record shape can hold it. The whole literal builds as a DOM
+    // fact — no record shape can hold it. The whole literal builds as a dyn
     // object instead (`{ [field]: criteria, actual: 0, ... }` —
     // test/common's _mustCallInner context), where keys are runtime string
     // values. TypeScript keeps the record world and its fence: this shape
@@ -4117,13 +4173,13 @@ export function lowerObjectLiteral(L, expr) {
         const shapeId = L.shapes.intern(fields.map((f) => ({ name: f.name, type: f.value.type })));
         return { kind: "recordLit", fields, type: { kind: "record", shapeId }, loc };
     }
-    // The JS declaration fallback, literal-side (the DOM-array rule's
+    // The JS declaration fallback, literal-side (the checked-dynamic tree-array rule's
     // object form): a literal whose shape has no static home — an
     // unmappable contextual type over unmappable own fields (the
     // PropertyDescriptorMap argument of Object.defineProperties, nested
-    // descriptor records with `any` values) — builds as a DOM OBJECT:
+    // descriptor records with `any` values) — builds as a dyn OBJECT:
     // each field converts through the usual dyn boundary, and dynamic
-    // consumers ride the keyed-DOM paths. TypeScript keeps the fence.
+    // consumers ride the keyed-dyn paths. TypeScript keeps the fence.
     if ((!mapped || mapped.kind === "dyn") && isJsSourceFile(expr.getSourceFile())) {
         return lowerDynObjectLiteral(L, expr);
     }
@@ -4389,8 +4445,8 @@ export function lowerObjectLiteral(L, expr) {
                 const recArm = recArms[0];
                 const recTag = def.arms.indexOf(recArm);
                 // A checked-dynamic VALUE under the union-mapped checker type
-                // (a JS DOM-holding binding): the present/absent desugar tests
-                // union tags a DOM box does not carry — fence honestly instead
+                // (a JS dyn-holding binding): the present/absent desugar tests
+                // union tags a dyn box does not carry — fence honestly instead
                 // of the validator's ICE.
                 const probedSrc = srcLowered ?? probeLower(L, srcNode);
                 if (probedSrc?.type.kind === "dyn") {
@@ -4572,11 +4628,11 @@ export function lowerObjectLiteral(L, expr) {
                     throw new PoisonError();
                 }
                 const obj = srcLowered ?? L.lowerExpr(srcNode);
-                // A record-mapped CHECKER type whose VALUE lives in the DOM (a
+                // A record-mapped CHECKER type whose VALUE lives in the checked-dynamic tree (a
                 // JS file-scope object-literal global): read each field from
-                // the DOM (dynKeyGet) and VALIDATE it into the source shape's
+                // the checked-dynamic tree (dynKeyGet) and VALIDATE it into the source shape's
                 // field type (dynCheck) — the checked-dynamic member-read
-                // discipline. A missing key answers the DOM undefined, exactly
+                // discipline. A missing key answers the dyn undefined, exactly
                 // the undefined-armed optional's absent case; a mismatched
                 // runtime value throws the catchable TypeError, never a silent
                 // wrong copy. Runtime-ADDED keys drop — width subtyping in
@@ -4584,7 +4640,7 @@ export function lowerObjectLiteral(L, expr) {
                 let value;
                 if (obj.type.kind === "dyn") {
                     if (!canDynCheckTo(f.type, (id) => L.shapes.get(id), (id) => L.unions.get(id))) {
-                        L.unsupported("SC1100", prop, `object spread of a checked-dynamic source whose field '${f.name}' ('${L.fmt(f.type)}') cannot validate out of the DOM (copy the fields explicitly)`);
+                        L.unsupported("SC1100", prop, `object spread of a checked-dynamic source whose field '${f.name}' ('${L.fmt(f.type)}') cannot validate out of the checked-dynamic tree (copy the fields explicitly)`);
                     }
                     value = {
                         kind: "dynCheck",
@@ -4723,7 +4779,7 @@ export function lowerObjectLiteral(L, expr) {
                 // lowering: a union field with one array-family arm builds the
                 // literal AS that arm (lowerExprExpecting's IR-directed rule —
                 // the option-table `default: [{ value: [] }]` shape), where the
-                // bare lowering would take the JS DOM fallback and fence.
+                // bare lowering would take the JS dyn fallback and fence.
                 let init = prop.initializer;
                 while (ts.isParenthesizedExpression(init))
                     init = init.expression;
@@ -4768,7 +4824,7 @@ export function lowerObjectLiteral(L, expr) {
         }
         if (!fieldType) {
             // Overflow entry: the value flows into the index signature's value
-            // slot — dyn slots take a DOM conversion (dynFrom), typed slots the
+            // slot — dyn slots take a dyn conversion (dynFrom), typed slots the
             // ordinary coercion path. Later duplicates override (map semantics
             // are last-write-wins already; a duplicate literal key is a tsc
             // error anyway).
@@ -4810,7 +4866,7 @@ export function lowerObjectLiteral(L, expr) {
         for (const f of shape.fields) {
             if (provided.has(f.name))
                 continue;
-            // 'unknown' fields complete with the DOM undefined — the absent
+            // 'unknown' fields complete with the dyn undefined — the absent
             // property reads as undefined in Node, and a dyn slot holds
             // exactly that (the options-record call shape against
             // `{ plugins: unknown, ... }` — a JS caller the checker admits).
@@ -5171,7 +5227,7 @@ export function lowerElementAccess(L, expr) {
     // A never-tainted JS receiver type (neverTaintedJsType — `cmd[1]` on
     // `const cmd = ['pwd', []]`, whose binding lowered checked-dynamic)
     // dispatches as unmapped so the dyn-receiver branch below reads
-    // through the DOM instead of dynChecking into never's f64 residue.
+    // through the checked-dynamic tree instead of dynChecking into never's f64 residue.
     const receiverIr = neverTaintedJsType(L, expr.expression, L.typeOf(expr.expression))
         ? null
         : L.mapTypeOf(L.typeOf(expr.expression));
@@ -5179,7 +5235,7 @@ export function lowerElementAccess(L, expr) {
         // Dispatch follows the RUNTIME world (383(d)): a checker-'any'
         // receiver whose value LOWERED checked-dynamic (`bag.list[0]` where
         // bag.list is a routed keyed read off a wrapped island value) takes
-        // the DOM keyed read below — the routed JSVAL arm reads the real
+        // the dyn keyed read below — the routed JSVAL arm reads the real
         // engine element; a jsval-lowered receiver keeps the island read.
         const recv = L.lowerExpr(expr.expression);
         if (recv.type.kind !== "dyn")
@@ -5258,7 +5314,7 @@ export function lowerElementAccess(L, expr) {
         }
     }
     // `pkg["k"]` / `scripts[name]` / `scopeMatch[1]` on a dyn receiver (a
-    // JSON.parse result): the DOM keyed read, exactly the dot form.
+    // JSON.parse result): the dyn keyed read, exactly the dot form.
     // NUMBER-typed indices convert through ToString first — JS property
     // keys are strings, and the canonical number text answers array
     // indices in the helper (fractions, negatives, and NaN read as
@@ -5368,7 +5424,7 @@ export function lowerElementAccess(L, expr) {
         return islandElementRead(L, expr, arr);
     // The checker sees an array but the VALUE lowered checked-dynamic (a
     // jsdoc-typed default export from a .js module — signature 14): the
-    // read rides the dynCheck boundary when the array shape is one the DOM
+    // read rides the dynCheck boundary when the array shape is one the checked-dynamic tree
     // can validate, and fences by name when it is not — an arrayGet over a
     // dyn receiver is never emitted (the validator ICE).
     if (arr.type.kind === "dyn") {
@@ -5444,7 +5500,7 @@ function islandElementRead(L, expr, obj) {
    * the index signature's value type (dyn for `unknown`), or its
    * undefined-armed union under noUncheckedIndexedAccess. Every declared
    * field must be able to SURFACE as that type (equal, an arm of it, or —
-   * for dyn results — JSON-safe for the DOM conversion); shapes mixing in
+   * for dyn results — JSON-safe for the dyn conversion); shapes mixing in
    * fields outside that stay fenced. Declared-only shapes support reads
    * whose key type proves membership (tsc's keyof check): all fields must
    * share the result type, and a smuggled miss traps. */
@@ -5463,16 +5519,19 @@ export function lowerRecordKeyRead(L, expr, shapeId, shape) {
     // The receiver lowers FIRST (both branches below read it, and JS
     // evaluates the receiver before the key).
     const obj = L.lowerExpr(expr.expression);
-    // A record-mapped CHECKER type over a VALUE living in the DOM (a JS
+    // A record-mapped CHECKER type over a VALUE living in the checked-dynamic tree (a JS
     // file-scope object-literal global): the checked-dynamic keyed read —
-    // dynKeyGet against the runtime keys (a missing key answers the DOM
+    // dynKeyGet against the runtime keys (a missing key answers the checked-dynamic tree
     // undefined, exactly JS); consumers validate (dynCheck) where a
     // static type is required, the member-read discipline.
     if (obj.type.kind === "dyn") {
         let dk = litKey !== null
             ? { kind: "strLit", value: litKey, type: STRING, loc: locOf(keyNode) }
             : L.lowerExpr(keyNode);
-        if (dk.type.kind === "f64")
+        // Number AND checked-dynamic keys ride the JS-exact formatter —
+        // property keys ARE strings (o[k] is o[String(k)] in JS), and a dyn
+        // key (agent.sockets[agent.getName(...)]) stringifies the same way.
+        if (dk.type.kind === "f64" || dk.type.kind === "dyn")
             dk = L.ensureString(dk, keyNode);
         if (dk.type.kind !== "string") {
             L.unsupported("SC1090", keyNode, "indexing records with non-string or non-number keys");
@@ -5574,8 +5633,8 @@ export function recordKeyTypeLiteralText(L, node) {
 }
 /** Can every value a dynamic key can reach (declared fields + the
  * overflow) surface as the read's result type? dyn results need
- * DOM-convertible fields (JSON-safe, with the undefined arm allowed at
- * the top — an optional field's undefined becomes the undefined DOM
+ * dyn-convertible fields (JSON-safe, with the undefined arm allowed at
+ * the top — an optional field's undefined becomes the undefined dyn
  * value, exactly what the missing-key path produces); typed results need
  * each field to be the type itself or one of its arms, and the overflow
  * value to be the type or wrappable into it. */
@@ -5643,7 +5702,7 @@ export function lowerElementWrite(L, expr) {
     if (receiverIr?.kind === "jsval") {
         const obj = L.lowerExpr(target.expression);
         // Dispatch follows the RUNTIME world (383(d)): a checker-'any'
-        // receiver whose value LOWERED checked-dynamic takes the DOM keyed
+        // receiver whose value LOWERED checked-dynamic takes the dyn keyed
         // write — the routed JSVAL arm lands it on the real engine object.
         if (obj.type.kind === "dyn") {
             const loc = locOf(expr);
@@ -5670,12 +5729,12 @@ export function lowerElementWrite(L, expr) {
         return { kind: "exprStmt", expr: { kind: "jsOp", op: "setIdx", args: [obj, key, value], type: VOID, loc }, loc };
     }
     // A checked-dynamic receiver TYPE (`unknown[]` and the collapsed
-    // `(string | object)[]` map to DYN wholesale now): the DOM keyed
+    // `(string | object)[]` map to DYN wholesale now): the dyn keyed
     // write — dyn.keySet. Number keys canonicalize through the JS-exact
     // formatter; ARR receivers take canonical index keys as element
     // set/extend (undefined-hole padding, JS's length growth exactly),
     // OBJ receivers set the member, and the runtime throws Node's
-    // TypeErrors on every other kind. Values convert into the DOM;
+    // TypeErrors on every other kind. Values convert into the checked-dynamic tree;
     // unconvertible ones fence per site (the dynFrom stance).
     if (receiverIr?.kind === "dyn") {
         const obj = L.lowerExpr(target.expression);
@@ -5689,7 +5748,7 @@ export function lowerElementWrite(L, expr) {
             }
             const value = L.coerceToExpected(L.lowerExpr(expr.right), DYN);
             if (value.type.kind !== "dyn") {
-                L.unsupported("SC1101", expr.right, `storing '${L.fmt(value.type)}' values in a checked-dynamic array (the value cannot convert into the DOM)`);
+                L.unsupported("SC1101", expr.right, `storing '${L.fmt(value.type)}' values in a checked-dynamic array (the value cannot convert into the checked-dynamic tree)`);
             }
             return { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet", args: [obj, key, value], type: VOID, loc }, loc };
         }
@@ -5729,11 +5788,11 @@ export function lowerElementWrite(L, expr) {
                 const loc = locOf(expr);
                 return { kind: "exprStmt", expr: { kind: "jsOp", op: "setIdx", args: [obj, key, value], type: VOID, loc }, loc };
             }
-            // A record-mapped CHECKER type over a VALUE living in the DOM (a
+            // A record-mapped CHECKER type over a VALUE living in the checked-dynamic tree (a
             // JS file-scope object-literal global): the checked-dynamic keyed
             // write — dyn.keySet (later writes win, insertion order; Node's
             // TypeErrors on non-object receivers), the value converting into
-            // the DOM. Literal and runtime keys alike: the DOM's key set is
+            // the checked-dynamic tree. Literal and runtime keys alike: the checked-dynamic tree's key set is
             // open, so no declared-field collision analysis applies.
             if (obj.type.kind === "dyn") {
                 const loc = locOf(expr);
@@ -5748,7 +5807,7 @@ export function lowerElementWrite(L, expr) {
                 }
                 const value = L.coerceToExpected(L.lowerExpr(expr.right), DYN);
                 if (value.type.kind !== "dyn") {
-                    L.unsupported("SC1101", expr.right, `storing '${L.fmt(value.type)}' values in a checked-dynamic object (the value cannot convert into the DOM)`);
+                    L.unsupported("SC1101", expr.right, `storing '${L.fmt(value.type)}' values in a checked-dynamic object (the value cannot convert into the checked-dynamic tree)`);
                 }
                 return { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet", args: [obj, key, value], type: VOID, loc }, loc };
             }
@@ -5836,7 +5895,7 @@ export function lowerElementWrite(L, expr) {
             // A LITERAL key naming no declared field is a pure overflow insert
             // — no collision to validate. Runtime keys must be able to collide
             // with every declared field: dyn slots validate through the
-            // dynCheck walker (fields must be DOM-convertible — the same
+            // dynCheck walker (fields must be dyn-convertible — the same
             // convertibility the read needs); typed slots write through
             // directly, so every field must BE the index-value type.
             const overflowOnly = litKey !== null;
@@ -5875,7 +5934,7 @@ export function lowerElementWrite(L, expr) {
     // `result[key] = value`): dyn.keySet, exactly the record-mapped dyn
     // arm above — later writes win in insertion order, number keys
     // canonicalize through the JS-exact formatter (ToPropertyKey's string
-    // side), index keys on DOM arrays set/extend elements, and non-object
+    // side), index keys on dyn arrays set/extend elements, and non-object
     // receivers throw Node's TypeErrors at runtime. An UNMAPPED checker
     // type (static `any` — mapTypeOf answers null without --dynamic)
     // probes the receiver's own lowered world: a dyn value takes the same
@@ -5898,7 +5957,7 @@ export function lowerElementWrite(L, expr) {
             }
             const value = L.coerceToExpected(L.lowerExpr(expr.right), DYN);
             if (value.type.kind !== "dyn") {
-                L.unsupported("SC1101", expr.right, `storing '${L.fmt(value.type)}' values in a checked-dynamic object (the value cannot convert into the DOM)`);
+                L.unsupported("SC1101", expr.right, `storing '${L.fmt(value.type)}' values in a checked-dynamic object (the value cannot convert into the checked-dynamic tree)`);
             }
             return { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet", args: [obj, key, value], type: VOID, loc }, loc };
         }
@@ -5932,7 +5991,7 @@ export function ensureString(L, e, node) {
     if (e.type.kind === "string")
         return e;
     if (e.type.kind === "dyn") {
-        // String(u) / `${u}`: a runtime dispatch over the DOM kind — Node's
+        // String(u) / `${u}`: a runtime dispatch over the dyn kind — Node's
         // String() exactly (undefined/null texts, JS number formatting,
         // strings verbatim, arrays via join, objects as "[object Object]").
         return { kind: "toString", operand: e, type: STRING, loc: e.loc };
@@ -6058,7 +6117,7 @@ export function lowerTemplate(L, expr) {
    *   documented divergence: a lying cast throws instead of corrupting
    *   memory);
    * - dyn → anything else (closures, class instances, void) is rejected:
-   *   those types cannot be found inside a JSON DOM. */
+   *   those types cannot be found inside a JSON dyn. */
 /** `e as T` and the old-style assertion `<T>e` — one node shape (both
  * carry `.type` and `.expression`), one lowering. */
 export function lowerAsExpression(L, expr) {
@@ -6162,7 +6221,7 @@ export function lowerAsExpression(L, expr) {
         return inner; // `as unknown`: erasure
     if (target.kind === "void" || !L.jsonSafe(target)) {
         // Bare undefined-armed targets pass when every OTHER arm is
-        // JSON-safe: the DOM holds a first-class undefined value now
+        // JSON-safe: the checked-dynamic tree holds a first-class undefined value now
         // (index-signature overflow reads produce it for missing keys), and
         // the undefined arm matches exactly it — `p[key] as string |
         // undefined` is the missing-key idiom. Parsed JSON still never
@@ -6171,7 +6230,7 @@ export function lowerAsExpression(L, expr) {
         if (target.kind === "union" && L.dynConvertible(target)) {
             return { kind: "dynCheck", value: inner, type: target, loc: locOf(expr) };
         }
-        // Uint8Array targets: the DOM carries a bytes kind now (converted
+        // Uint8Array targets: the checked-dynamic tree carries a bytes kind now (converted
         // stdin chunks) — the extraction validates the kind and copies out.
         if (target.kind === "bytes" && target.elem === "u8") {
             return { kind: "dynCheck", value: inner, type: target, loc: locOf(expr) };
@@ -6194,7 +6253,7 @@ export function lowerAsExpression(L, expr) {
         // — the errno-probing idiom): there is nothing to validate (every
         // field is unknown, exactly what the dyn value already answers) and
         // nothing to build — the cast is pure typing, so it ERASES and the
-        // reads ride the DOM keyed read.
+        // reads ride the dyn keyed read.
         if (target.kind === "record") {
             const shape = L.shapes.get(target.shapeId);
             if (shape &&
@@ -6355,7 +6414,7 @@ export function lowerBinary(L, expr) {
         }
         // `events.defaultMaxListeners = v` — the module-property write
         // Node validates (validateNumber(n, 'defaultMaxListeners', 0)):
-        // the value crosses into the DOM and the runtime ladder throws
+        // the value crosses into the checked-dynamic tree and the runtime ladder throws
         // ERR_INVALID_ARG_TYPE / ERR_OUT_OF_RANGE with Node's exact slot
         // name; valid numbers apply. The expression's value is the RHS
         // (JS's assignment yield).
@@ -6528,8 +6587,8 @@ export function lowerBinary(L, expr) {
         }
         if (left.type.kind === "dyn" || right.type.kind === "dyn") {
             // A checked-dynamic operand (`fn.name || '<anonymous>'` —
-            // test/common's _mustCallInner): both sides live in the DOM and
-            // the deciding test is ToBoolean over the DOM kind
+            // test/common's _mustCallInner): both sides live in the checked-dynamic tree and
+            // the deciding test is ToBoolean over the dyn kind
             // (scr_dyn_truthy) — JS value semantics exactly, result dyn. The
             // non-dyn side converts through the usual boundary; a value with
             // no dyn representation keeps the fence.
@@ -6566,6 +6625,30 @@ export function lowerBinary(L, expr) {
             // shapes lower through lowerCondition's bool descent instead.
             const target = L.mapTypeOf(L.typeOf(expr));
             if (target?.kind === "union") {
+                // `||` whose left does NOT fit the result union: the checker built
+                // that result by DROPPING the left's falsy arms (`process.env.X ||
+                // null` is `string | null`, `|| 3000` is `string | number` — the
+                // `undefined` is gone from both), so coercing the left eagerly, as
+                // the shared shape below does, retags an arm the test is about to
+                // rule out and throws where Node yields the default. Single-eval
+                // instead: test the left in its OWN union and retag only on the
+                // truthy side, where the dropped arms are unreachable. `&&` keeps
+                // the eager shape — there the falsy left IS the result, so the
+                // checker keeps those arms in the target and they must coerce.
+                if (op === ts.SyntaxKind.BarBarToken && left.type.kind === "union" && !typeEquals(left.type, target)) {
+                    const retag = L.unionRetagHelper(left.type.unionId, target.unionId, loc);
+                    if (retag) {
+                        L.requireTruthyUnion(left.type.unionId, expr);
+                        return {
+                            kind: "orDefault",
+                            left,
+                            right: L.coerceInto(expr.right, right, target),
+                            retag,
+                            type: target,
+                            loc,
+                        };
+                    }
+                }
                 L.requireTruthyUnion(target.unionId, expr);
                 return {
                     kind: "logical",
@@ -6665,7 +6748,7 @@ export function lowerBinary(L, expr) {
     const right = L.lowerExpr(expr.right);
     if (left.type.kind === "dyn" || right.type.kind === "dyn") {
         // The narrowing unit comparisons ARE answerable on unknown: `v ===
-        // undefined` / `v !== null` test the DOM node's kind directly, and
+        // undefined` / `v !== null` test the dyn node's kind directly, and
         // tsc's control flow narrows the branches (reads then bridge through
         // maybeNarrow's validated extraction).
         if (op === ts.SyntaxKind.EqualsEqualsEqualsToken ||
@@ -6685,14 +6768,14 @@ export function lowerBinary(L, expr) {
             }
             // dyn vs SCALAR strict equality (`value !== ""`, `u === 5` — the
             // normalizePricing filter): a guarded kind test + payload compare,
-            // JS-exact (strict equality never coerces; a non-matching DOM kind
+            // JS-exact (strict equality never coerces; a non-matching dyn kind
             // answers false). dyn vs dyn keeps the fence below.
             const dynSide = left.type.kind === "dyn" ? left : right;
             const scalarSide = dynSide === left ? right : left;
             if (dynSide.type.kind === "dyn" &&
                 (scalarSide.type.kind === "f64" || scalarSide.type.kind === "string" || scalarSide.type.kind === "bool" ||
                     // dyn vs dyn (`context.actual !== context.exact` —
-                    // test/common's exit accounting): the runtime's whole-DOM
+                    // test/common's exit accounting): the runtime's whole-dyn
                     // strict equality — scalars by value, units by kind,
                     // reference kinds by node identity (scr_dyn_strict_eq).
                     scalarSide.type.kind === "dyn")) {
@@ -6747,7 +6830,7 @@ export function lowerBinary(L, expr) {
                 }
                 if (other.type.kind === "string") {
                     // String-context `+`: JS's answer is String(unknown) — the
-                    // JS-exact DOM walker (numbers format, arrays join, objects
+                    // JS-exact dyn walker (numbers format, arrays join, objects
                     // print [object Object], handles the same) — never a checked
                     // cast: `'status ' + res.statusCode` concatenates like Node.
                     const strOf = (e) => e.type.kind === "dyn" ? { kind: "toString", operand: e, type: STRING, loc: e.loc } : e;
@@ -6765,7 +6848,7 @@ export function lowerBinary(L, expr) {
             L.anyOpFence(`the '${ts.tokenToString(op) ?? ts.SyntaxKind[op]}' operator`, expr);
         }
         // tsc allows ===/!== on unknown (arithmetic/comparisons it rejects
-        // itself); a dynamic equality would need a DOM walk — validate first.
+        // itself); a dynamic equality would need a dyn walk — validate first.
         L.unsupported("SC1100", expr, "operators on 'unknown' values");
     }
     // Operators over 'any' execute in the island with JS-exact semantics
@@ -6932,6 +7015,12 @@ export function lowerBinary(L, expr) {
                 typeEquals(idLeft.type, idRight.type)) {
                 return { kind: "bin", op: negated ? "!==" : "===", left: idLeft, right: idRight, type: BOOL, loc };
             }
+            // Runtime HANDLES are objects to === too: one handle per socket/
+            // request/response, so pointer identity IS JS's object equality
+            // (`c.pause() === c` — Node's chaining assertions). */
+            if (DYN_HANDLE_KINDS.has(idLeft.type.kind) && typeEquals(idLeft.type, idRight.type)) {
+                return { kind: "bin", op: negated ? "!==" : "===", left: idLeft, right: idRight, type: BOOL, loc };
+            }
             L.unsupported("SC1043", expr);
             break;
         }
@@ -7303,7 +7392,7 @@ export function lowerUnionTypeofTest(L, expr, loc) {
     return null;
 }
 /** `typeof v === "lit"` / `typeof v !== "lit"` where v is `unknown`-typed
-   * (dyn): the runtime kind test over the DOM node's tag. Only the kinds a
+   * (dyn): the runtime kind test over the dyn node's tag. Only the kinds a
    * later read can bridge narrow ("string"/"number"/"boolean") plus
    * "undefined" (no payload to read); "object"/"function" tests keep the
    * fence — an object-narrowed `unknown` read has no lowering anyway (a
@@ -7387,7 +7476,7 @@ export function lowerDynTypeofTest(L, expr, loc) {
                 loc,
             };
         }
-        // `typeof v === "object"`: the DOM answers exactly (object, array,
+        // `typeof v === "object"`: the dyn answers exactly (object, array,
         // bytes, and null kinds — JS's oldest wart preserved). tsc narrows
         // the branch to `object | null`; reads past the narrow take the
         // checked-cast path per site.
@@ -7401,7 +7490,7 @@ export function lowerDynTypeofTest(L, expr, loc) {
                 loc,
             };
         }
-        // `typeof v === "function"`: a REAL runtime test since the DOM's
+        // `typeof v === "function"`: a REAL runtime test since the checked-dynamic tree's
         // function kind exists (boxed closures — the mustCall guard
         // `if (typeof fn !== 'function') throw` answers honestly).
         if (b.text === "function") {
@@ -7564,7 +7653,7 @@ export function probeLower(L, node) {
    * over a hierarchy class, `typeof` over a primitive), the read bridges
    * with a kind-unchecked `caughtNarrow` extraction (trust-the-checker,
    * exactly like unionNarrow). Every OTHER read is the narrowness fence:
-   * the binding's payload is a typed exception snapshot, not a dyn DOM, so
+   * the binding's payload is a typed exception snapshot, not a dyn, so
    * un-narrowed uses have nothing sound to lower to. */
 export function caughtRead(L, node, local, loc) {
     const ref = { kind: "varRef", localId: local.id, type: CAUGHT, loc };
@@ -7580,10 +7669,10 @@ export function caughtRead(L, node, local, loc) {
         }
     }
     // An UN-narrowed use — the occurrence still types `unknown` — converts
-    // to a dyn DOM value (`options.onError?.(error)` — the caught snapshot
+    // to a dyn value (`options.onError?.(error)` — the caught snapshot
     // flowing into an unknown slot): the typed→unknown deep-copy stance
     // extended to exception payloads. Error payloads keep their
-    // observability (instanceof Error / .message / String() — the DOM's
+    // observability (instanceof Error / .message / String() — the checked-dynamic tree's
     // error encoding); other object payloads are type-erased at runtime and
     // convert to the "[object Object]" approximation — SEMANTICS.md 67.
     if (narrowed?.kind === "dyn") {
@@ -7689,14 +7778,14 @@ export function lowerInstanceOf(L, expr, loc) {
         L.builtinStreamInfoOf(rhsMemberSymbol) ??
         undefined;
     if (!target) {
-        // `u instanceof Uint8Array` on an `unknown` value: the DOM carries a
+        // `u instanceof Uint8Array` on an `unknown` value: the checked-dynamic tree carries a
         // bytes kind — one runtime tag test, and tsc's narrowing types the
         // true branch (reads bridge through maybeNarrow's validated
         // extraction, like the typeof tests). Node's Buffer IS a Uint8Array
         // subclass and rides the same bytes kind, so both worlds answer true
         // for Buffer payloads — Node-exact (the bytes kind's other
         // divergences are SEMANTICS.md 45). Catch bindings stay out (their
-        // payload is a typed snapshot, not a DOM).
+        // payload is a typed snapshot, not a dyn).
         if (ts.isIdentifier(expr.right) &&
             L.isStdlibGlobal(expr.right, "Uint8Array") &&
             !L.caughtLocalOf(expr.left)) {
@@ -7787,7 +7876,7 @@ export function lowerInstanceOf(L, expr, loc) {
         };
     }
     const left = L.lowerExpr(expr.left);
-    // `u instanceof Error` on an `unknown` value: the DOM's error encoding
+    // `u instanceof Error` on an `unknown` value: the checked-dynamic tree's error encoding
     // (the shape caughtToDyn builds for Error payloads — the reserved
     // "%error" marker) answers the test, so a caught Error passed through
     // an unknown slot narrows like Node (`error instanceof Error ?
@@ -7800,7 +7889,7 @@ export function lowerInstanceOf(L, expr, loc) {
         return { kind: "dynTest", test: "error", value: left, type: BOOL, loc };
     }
     // `u instanceof TypeError` (and the other BUILTIN error classes) on a
-    // dyn value: the from_error cache holds the DOM↔error identity edge,
+    // dyn value: the from_error cache holds the checked-dynamic tree↔error identity edge,
     // so the runtime resolves the encoding back to its error and asks the
     // vtable's stamped interval — exact for every error that crossed the
     // boundary (a hand-built {%error} literal answers false: subclass
@@ -8031,6 +8120,25 @@ export function lowerInExpression(L, expr, loc) {
         const rIn = lowerRuntimeKeyIn(L, expr, loc);
         if (rIn)
             return rIn;
+        // A runtime key over a CHECKED-DYNAMIC receiver (`name in
+        // agent.sockets` — both sides computed; the checker may type the
+        // receiver as a Dict while the VALUE lives in the checked-dynamic tree, so the
+        // LOWERED type decides): the dyn presence answer, with the key
+        // stringified like every property key (o[k] is o[String(k)] in JS;
+        // `in` shares the coercion).
+        {
+            const probed = probeLower(L, expr.right);
+            if (probed?.type.kind === "dyn") {
+                let k = L.lowerExpr(expr.left); // JS order: the key evaluates first
+                if (k.type.kind === "f64" || k.type.kind === "string" || k.type.kind === "dyn") {
+                    k = L.ensureString(k, expr.left);
+                    const recvD = L.lowerExpr(expr.right);
+                    if (recvD.type.kind === "dyn") {
+                        return { kind: "libCall", fn: "dyn.hasKey", args: [recvD, k], type: BOOL, loc };
+                    }
+                }
+            }
+        }
         L.unsupported("SC1090", expr.left, "'in' with computed (non-literal) keys (a const whose type is one string literal folds; a string-typed key answers over index-signature record receivers)");
     }
     // A receiver re-read (the static folds below) is safe for plain reads
@@ -8093,7 +8201,7 @@ export function lowerInExpression(L, expr, loc) {
         }
     }
     // A dyn receiver (`"portless" in pkg` after the `typeof pkg ===
-    // "object"` guard): own-member presence on the DOM — tsc admits `in`
+    // "object"` guard): own-member presence on the checked-dynamic tree — tsc admits `in`
     // only on object-typed operands, so unit receivers are unreachable.
     if (recv.type.kind === "dyn") {
         return { kind: "dynHasKey", key, value: recv, type: BOOL, loc };
@@ -8831,8 +8939,8 @@ export function lowerUnionProperty(L, expr) {
     // fallback's discipline.
     // A checker-union receiver whose VALUE lowered checked-dynamic (a
     // never-tainted JS chain — `cmd[1].length` on `const cmd = ['pwd',
-    // []]`, where the element read stayed a DOM node): read through the
-    // DOM keyed read like the unmappable-receiver path below the chain.
+    // []]`, where the element read stayed a dyn node): read through the
+    // dyn keyed read like the unmappable-receiver path below the chain.
     if (value.type.kind === "dyn") {
         const key = { kind: "strLit", value: expr.name.text, type: STRING, loc: locOf(expr.name) };
         return { kind: "dynKeyGet", key, value, type: DYN, loc: locOf(expr) };
@@ -9219,9 +9327,9 @@ export function symbolFieldTarget(L, expr) {
    * tsc-clean (the property types as the setter's param), but Node yields
    * undefined, which these property types cannot represent. */
 export function fieldGetExpr(L, target, loc, blame) {
-    // A record-shaped CHECKER target whose receiver VALUE lives in the DOM
+    // A record-shaped CHECKER target whose receiver VALUE lives in the checked-dynamic tree
     // (a JS file-scope object-literal global): the checked-dynamic keyed
-    // read — dynKeyGet (a missing key answers the DOM undefined, exactly
+    // read — dynKeyGet (a missing key answers the dyn undefined, exactly
     // JS); consumers validate (dynCheck) where a static type is required.
     if ((target.container === "record" || target.container === "recordOvf") &&
         target.obj.type.kind === "dyn") {
@@ -9302,15 +9410,15 @@ export function fieldGetExpr(L, target, loc, blame) {
    * call). A write to a getter-only property never gets here in a clean
    * program (tsc's TS2540 is the fence); the rejection is the backstop. */
 export function fieldSetStmt(L, target, value, loc, blame) {
-    // A record-shaped CHECKER target whose receiver VALUE lives in the DOM:
+    // A record-shaped CHECKER target whose receiver VALUE lives in the checked-dynamic tree:
     // the checked-dynamic keyed write — dyn.keySet (later writes win,
     // insertion order; Node's TypeErrors on non-object receivers), the
-    // value converting into the DOM.
+    // value converting into the checked-dynamic tree.
     if ((target.container === "record" || target.container === "recordOvf") &&
         target.obj.type.kind === "dyn") {
         const v = L.coerceToExpected(value, DYN);
         if (v.type.kind !== "dyn") {
-            L.unsupported("SC1101", blame, `storing '${L.fmt(value.type)}' values in a checked-dynamic object (the value cannot convert into the DOM)`);
+            L.unsupported("SC1101", blame, `storing '${L.fmt(value.type)}' values in a checked-dynamic object (the value cannot convert into the checked-dynamic tree)`);
         }
         return {
             kind: "exprStmt",
@@ -9398,7 +9506,7 @@ export function lowerPromiseRejectCall(L, call, access) {
     const type = ctxT ? L.mapTypeOf(ctxT) : null;
     const reasonNode = call.arguments[0];
     // A CHECKED-DYNAMIC reason (`Promise.reject(value)` where value rode
-    // an untyped binding — the tracingChannel suite's shape): the DOM
+    // an untyped binding — the tracingChannel suite's shape): the checked-dynamic tree
     // value IS the rejection payload (the thrown-dyn representation, so
     // identity survives to catch/unhandledRejection observers), and the
     // result is promise<dyn> when no context names a concrete one.
@@ -9541,7 +9649,7 @@ export function lowerFieldCompound(L, access, op, rhsNode, loc) {
             const concat = {
                 kind: "strConcat",
                 // String-context read: JS's String(unknown) over the field —
-                // the JS-exact DOM walker, never a checked cast.
+                // the JS-exact dyn walker, never a checked cast.
                 left: { kind: "toString", operand: read, type: STRING, loc },
                 right: rhs,
                 type: STRING,