@scriptc/compiler 0.0.2 → 0.0.4

package/dist/frontend/lowering/lower-exprs.d.ts

@@ -522,3 +522,13 @@ export declare function lowerPromiseAllTupleCall(L: Lowerer, call: ts.CallExpres
    * Restricted to side-effect-free receivers (identifier or `this`)
    * because the desugar evaluates the receiver twice. */
 export declare function lowerFieldCompound(L: Lowerer, access: ts.PropertyAccessExpression | ts.ElementAccessExpression, op: CompoundOp, rhsNode: ts.Expression | null, loc: SrcLoc): IrStmt;
+/** The primitive-constructor closure (`String`/`Number`/`Boolean` as a
+ * VALUE): interns one synthesized module function per constructor —
+ * `%builtin.String` et al. — and returns the zero-capture closure over it.
+ * The body IS the string-coercion the type mapping promised
+ * (`(value: string) => primitive`): String is identity, Number the ECMA
+ * StringToNumber (num.fromString — the same runtime call the direct
+ * `Number(s)` lowering emits), Boolean the emptiness test. Interning makes
+ * every reference the SAME immortal closure, so `opt.type === String`
+ * compares like JS function identity. */
+export declare function primitiveCtorClosure(L: Lowerer, name: "String" | "Number" | "Boolean", loc: SrcLoc): IrExpr;

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

@@ -6,11 +6,11 @@
  * (FieldTarget). */
 import * as ts from "../ts7/adapter.js";
 import { dirname } from "node:path";
-import { BOOL, CAUGHT, DYN, DYN_HANDLE_KINDS, F64, JSVAL, NULL_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_ERROR_CLASSES, SEARCH_PARAMS_T, STRING, UNDEFINED_T, VOID, arrayOf, canAdaptDynFuncTo, canBoxFuncIntoDyn, canDynCheckTo, isJsonSafeType, isUnitType, jsOpResultKind, shapeHasAccessorSlots, typeEquals, typeKey } from "../../ir/nodes.js";
+import { BOOL, CAUGHT, DYN, DYN_HANDLE_KINDS, F64, JSVAL, NULL_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_ERROR_CLASSES, SEARCH_PARAMS_T, STRING, UNDEFINED_T, VOID, arrayOf, canAdaptDynFuncTo, canBoxFuncIntoDyn, canDynCheckTo, funcOf, isJsonSafeType, isUnitType, jsOpResultKind, shapeHasAccessorSlots, typeEquals, typeKey, unionFuncSetArmsOk } from "../../ir/nodes.js";
 import { cjsClassExprWholeExportOf, cjsExportAssignmentOf, cjsExportDiscardReason, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, isNodeEsmFile, locOf } from "../program.js";
 import { ARRAY_METHODS, builtinConstLit, builtinFenceHintOf, builtinModuleConstOf, builtinModuleFnOf, ISLAND_SURFACE, isChildSurfaceMember, MAP_METHODS, NARROW_FIRST, SET_METHODS, STR_METHODS, UNSUPPORTED_EXPR, sideEffectFreeOptionValue, stdlibGlobalNameOf } from "./surfaces.js";
 import { blockedBindingUseDiag, recordShapeMismatchDiag, requiresDynamicPackageDiag, unsupportedDiag } from "../../diagnostics/diagnostic.js";
-import { PoisonError, jsFuncNameOf, neverTaintedJsType, own } from "./lowerer.js";
+import { PoisonError, dynUndefinedExpr, jsFuncNameOf, neverTaintedJsType, own } from "./lowerer.js";
 import { lowerIndexMergeHelper, lowerNpmStaticSafeIndexRead, strCharsCall } from "./lower-containers.js";
 import { npmStaticPackageOfPath } from "../npm-static.js";
 import { fenceEnumObjectValue, lowerEnumAccess } from "./lower-enums.js";
@@ -20,7 +20,7 @@ import { lowerSocketInstanceOf } from "./lower-server.js";
 import { findGenericMethodOn, lowerStaticFieldRead } from "./lower-classes.js";
 import { bindingNeverReassigned, implicitMonoFile, lowerTaggedTemplate, objLitGenericFnInfoOf, objLitGenericFnNodeOf, requireObjLitGenericReceiver } from "./lower-calls.js";
 import { mixinFnOfCallee } from "./lower-mixins.js";
-import { isGenericCallableMemberType, unitOnlyUnion } from "../types.js";
+import { isConstAssertionTypeNode, isGenericCallableMemberType, underConstAssertion, unitOnlyUnion } from "../types.js";
 import { lowerYield } from "./lower-generators.js";
 import { lowerStreamProperty, lowerStreamStateProperty, streamSidesOf } from "./lower-stream.js";
 /** A template piece's RAW text (String.raw's contract: escapes stay
@@ -195,7 +195,15 @@ function lowerExprInner(L, expr) {
         (() => {
             const ctxTs = L.checker.getContextualType(expr);
             const mapped = (ctxTs ? L.mapTypeOf(ctxTs) : null) ?? L.mapTypeOf(L.typeOf(expr));
-            return mapped?.kind === "jsval";
+            if (mapped?.kind !== "jsval")
+                return false;
+            // The tsgo readonly-[] panic repair (see lowerArrayLiteral): an
+            // EMPTY array literal under a const assertion is the empty tuple —
+            // its `any` answer is a panicked query, not an island slot.
+            if (ts.isArrayLiteralExpression(expr) && expr.elements.length === 0 && underConstAssertion(expr)) {
+                return false;
+            }
+            return true;
         })()) {
         if (ts.isObjectLiteralExpression(expr)) {
             // Two engine literals when a CONDITIONAL spread participates
@@ -537,6 +545,20 @@ function lowerExprInner(L, expr) {
                 return { kind: "numLit", value: expr.text === "NaN" ? NaN : Infinity, type: F64, loc };
             }
         }
+        // The primitive constructors as VALUES (`const f = String`, an
+        // option table's `type: Boolean` field, `opt.type === Number`): the
+        // interned coercion closure — one synthesized module function per
+        // constructor per program, so every reference is the SAME zero-
+        // capture closure and `===` is JS identity (the type mapping in
+        // types.ts pins the one concrete signature `(value: string) =>
+        // primitive`; direct calls `String(x)` never reach here — the call
+        // lowering intercepts them with the wider static coercions).
+        // JavaScript sources keep the identity-token path below.
+        if ((expr.text === "String" || expr.text === "Number" || expr.text === "Boolean") &&
+            !isJsSourceFile(expr.getSourceFile()) &&
+            L.isStdlibSymbol(L.checker.getSymbolAtLocation(expr))) {
+            return primitiveCtorClosure(L, expr.text, loc);
+        }
         // The lib fence's IDENTIFIER chokepoint: the real standard library
         // resolves names the old minimal ambient world never declared
         // (Symbol, Reflect, Infinity, Date, ...) — and the adopted
@@ -938,6 +960,22 @@ 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`
+            // in a plain JS function — dyn.this — or a checked-dynamic local
+            // behind an any-typed spelling): the property read is the DOM'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 —
+            // the two dynamic worlds don't share a value representation.
+            if (receiver.type.kind === "dyn") {
+                return {
+                    kind: "dynKeyGet",
+                    key: { kind: "strLit", value: expr.name.text, type: STRING, loc },
+                    value: receiver,
+                    type: DYN,
+                    loc,
+                };
+            }
             const read = { kind: "jsOp", op: "getProp", name: expr.name.text, args: [receiver], type: JSVAL, loc };
             // A member the .d.ts DECLARES as a primitive exits eagerly to that
             // static type (`f.mediaType` on a package handle IS a string):
@@ -2835,6 +2873,17 @@ export function lowerArrayLiteral(L, expr, expected) {
                 mapped = arrayArms[0];
         }
     }
+    // An EMPTY literal under a CONST ASSERTION whose type queries panicked
+    // (tsgo's readonly-[] TupleType conversion — the facade answers `any`,
+    // which maps to nothing statically and to an island value under
+    // --dynamic): the value is provably the empty tuple; ride the
+    // unit-element array, mapType's own `[] as const` rule.
+    if ((mapped === null || mapped.kind === "jsval") &&
+        expr.elements.length === 0 &&
+        (tsType.flags & ts.TypeFlags.Any) !== 0 &&
+        underConstAssertion(expr)) {
+        mapped = arrayOf(unitOnlyUnion(L.unions));
+    }
     // A TUPLE-typed slot (`const t: [string, number] = ["a", 1]`): the
     // literal constructs the tuple's record shape — one positional field
     // per element, source order (which IS index order, so evaluation order
@@ -3301,6 +3350,102 @@ function fenceClosureProbe(L, node, slotType, attempt) {
         return { kind: "closure", fnName: name, captures: [], type: fieldType, loc };
     }
 }
+/** The union arm an object LITERAL inhabits when its fields must widen
+ * PER FIELD into exactly one record arm — the reducer-action pattern
+ * (`{ kind: "a", parsed: 1 }` into `{ kind: "a"; parsed: number | null }
+ * | { kind: "b" }`). The IR shapes erased the literal types tsc
+ * discriminated on, so the probe runs against the contextual union's
+ * CHECKER members: every literal field must exist on the member
+ * (excess-property freshness — tsc already enforced it), every arm field
+ * missing from the literal must be optional-flavored (an undefined-armed
+ * union, or a dyn slot — the absent-completion rule), and each present
+ * field's LITERAL type must fit the member's field type — literal against
+ * literal decides by VALUE (the discriminant), everything else by the
+ * widened IR pair under the width-lift relation. Exactly ONE fitting arm
+ * answers it; zero or several answer null and the caller keeps its
+ * fences. Plain property-assignment/shorthand literals only — spreads,
+ * accessors, methods, and unfoldable computed keys keep their own paths. */
+function literalUnionArmOf(L, expr, tsType, recordArms) {
+    if (!tsType.isUnionType())
+        return null;
+    const props = [];
+    for (const p of expr.properties) {
+        if (ts.isPropertyAssignment(p) && !ts.isComputedPropertyName(p.name)) {
+            props.push({ name: propNameText(L, p.name), node: p.initializer });
+        }
+        else if (ts.isShorthandPropertyAssignment(p) && ts.isIdentifier(p.name)) {
+            props.push({ name: p.name.text, node: p.name });
+        }
+        else {
+            return null;
+        }
+    }
+    /** litT fits ftT: unions per arm; literal-vs-literal by value; unit
+     * types only into their own unit; otherwise the widened IR pair must be
+     * equal or width-liftable. */
+    const fits = (litT, ftT) => {
+        if (ftT.isUnionType())
+            return ftT.getTypes().some((a) => fits(litT, a));
+        if (ftT.isStringLiteralType())
+            return litT.isStringLiteralType() && litT.value === ftT.value;
+        if (ftT.isNumberLiteralType())
+            return litT.isNumberLiteralType() && litT.value === ftT.value;
+        if (ftT.flags & ts.TypeFlags.BooleanLiteral) {
+            return (litT.flags & ts.TypeFlags.BooleanLiteral) !== 0 && L.checker.typeToString(litT) === L.checker.typeToString(ftT);
+        }
+        if (ftT.flags & ts.TypeFlags.Null)
+            return (litT.flags & ts.TypeFlags.Null) !== 0;
+        if (ftT.flags & ts.TypeFlags.Undefined)
+            return (litT.flags & ts.TypeFlags.Undefined) !== 0;
+        if (litT.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined))
+            return false;
+        const li = L.mapTypeOf(L.checker.getBaseTypeOfLiteralType(litT));
+        const fi = L.mapTypeOf(ftT);
+        if (!li || !fi)
+            return false;
+        return typeEquals(li, fi) || L.widthLiftPlan(li, fi) !== null;
+    };
+    const armShapeIds = new Set(recordArms.map((a) => a.shapeId));
+    const candidates = new Set();
+    for (const member of tsType.getTypes()) {
+        const mMapped = L.mapTypeOf(member);
+        if (mMapped?.kind !== "record" || !armShapeIds.has(mMapped.shapeId) || candidates.has(mMapped.shapeId))
+            continue;
+        const shape = L.shapes.get(mMapped.shapeId);
+        if (!shape || shape.tuple || shape.indexValue)
+            continue;
+        // Excess-property freshness: every literal field must exist on the
+        // member (tsc rejected the others for a fresh literal).
+        if (!props.every((p) => L.checker.getPropertyOfType(member, p.name) !== undefined))
+            continue;
+        // Arm fields the literal leaves unset must be optional-flavored (the
+        // absent-completion rule: an undefined-armed union or a dyn slot).
+        const names = new Set(props.map((p) => p.name));
+        const absentOk = shape.fields.every((f) => {
+            if (names.has(f.name))
+                return true;
+            if (f.type.kind === "dyn")
+                return true;
+            if (f.type.kind !== "union")
+                return false;
+            return L.unions.get(f.type.unionId)?.arms.some((a) => a.kind === "undefinedT") ?? false;
+        });
+        if (!absentOk)
+            continue;
+        const fieldsFit = props.every((p) => {
+            const sym = L.checker.getPropertyOfType(member, p.name);
+            if (!sym)
+                return false;
+            return fits(L.typeOf(p.node), L.checker.getTypeOfSymbol(sym));
+        });
+        if (fieldsFit)
+            candidates.add(mMapped.shapeId);
+    }
+    if (candidates.size !== 1)
+        return null;
+    const [only] = candidates;
+    return recordArms.find((a) => a.shapeId === only) ?? null;
+}
 export function lowerObjectLiteral(L, expr) {
     const loc = locOf(expr);
     // The RUNTIME-KEYED literal (JS): a computed key that doesn't fold to a
@@ -3491,6 +3636,26 @@ export function lowerObjectLiteral(L, expr) {
                     mapped = recordArms[0];
                 }
             }
+            else if (recordArms.length > 1) {
+                const ownShapeId = mapped?.kind === "record" ? mapped.shapeId : null;
+                // SEVERAL record arms (the reducer-action / discriminated-message
+                // pattern): the literal's own inferred shape re-tags into no arm
+                // — its field types widened per field (`parsed: 1` against
+                // `parsed: number | null`), so the IR-level candidate probe is
+                // ambiguous (a narrower arm also admits the literal by dropping
+                // fields). The LITERAL types tsc checked carry the discriminant
+                // the shapes erased: match the literal's fields against each
+                // union member's CHECKER types (literal-vs-literal field pairs
+                // decide by value — the `kind: "a"` discriminant), and when
+                // exactly ONE member fits, build AS that arm — its field types
+                // drive every property's coercion, exactly the single-record-arm
+                // rule above. Ambiguous literals keep the SC2003 fence.
+                if (ownShapeId === null || !recordArms.some((a) => a.shapeId === ownShapeId)) {
+                    const arm = literalUnionArmOf(L, expr, tsType, recordArms);
+                    if (arm)
+                        mapped = arm;
+                }
+            }
         }
     }
     // The CJS EXPORT-TABLE literal in VALUE position (JS): importers reach
@@ -4177,9 +4342,13 @@ export function lowerObjectLiteral(L, expr) {
         for (const f of shape.fields) {
             if (provided.has(f.name))
                 continue;
-            const absent = L.wrappedUndefined(f.type, loc);
+            // 'unknown' fields complete with the DOM 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).
+            const absent = L.wrappedUndefined(f.type, loc) ?? (f.type.kind === "dyn" ? dynUndefinedExpr(loc) : null);
             if (!absent)
-                throw shapeMismatch(expr); // only optional (undefined-armed) fields may be omitted
+                throw shapeMismatch(expr); // only optional (undefined-armed) and 'unknown' fields may be omitted
             fields.push({ name: f.name, value: absent });
         }
     }
@@ -5257,6 +5426,17 @@ export function lowerTemplate(L, expr) {
 /** `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) {
+    // `[] as const` — tsgo panics computing the expression's `readonly []`
+    // type (the facade's fence answers `any`), but the syntax pins the
+    // value exactly: the empty tuple, ridden as the unit-element array
+    // (mapType's empty-tuple rule). Lower it directly; enclosing slots
+    // coerce like any other empty-array source.
+    if (ts.isAsExpression(expr) &&
+        isConstAssertionTypeNode(expr.type) &&
+        ts.isArrayLiteralExpression(expr.expression) &&
+        expr.expression.elements.length === 0) {
+        return { kind: "arrayLit", elems: [], type: arrayOf(unitOnlyUnion(L.unions)), loc: locOf(expr) };
+    }
     // `e as C` on a CATCH BINDING (`(err as Error).message`): the checked
     // extraction — an instanceof match extracts the payload, anything else
     // throws the catchable TypeError (dynCheck's trust-but-verify stance,
@@ -5635,6 +5815,22 @@ export function lowerBinary(L, expr) {
         const nullTest = lowerLooseNullCompare(L, expr, loc);
         if (nullTest)
             return nullTest;
+        // SAME-KIND loose equality IS strict equality (the spec's ==
+        // dispatches to === when both operands share a type): `typeof v ==
+        // 'object'`, `n != 0`, `flag == true` all lower exactly. Mixed
+        // kinds (where == coerces) keep the fence.
+        {
+            const negated = op === ts.SyntaxKind.ExclamationEqualsToken;
+            const left = L.lowerExpr(expr.left);
+            const right = L.lowerExpr(expr.right);
+            if (left.type.kind === "string" && right.type.kind === "string") {
+                return { kind: "strEq", negated, left, right, type: BOOL, loc };
+            }
+            if ((left.type.kind === "f64" && right.type.kind === "f64") ||
+                (left.type.kind === "bool" && right.type.kind === "bool")) {
+                return { kind: "bin", op: negated ? "!==" : "===", left, right, type: BOOL, loc };
+            }
+        }
         L.unsupported("SC1040", expr);
     }
     if (op === ts.SyntaxKind.AmpersandAmpersandToken || op === ts.SyntaxKind.BarBarToken) {
@@ -6940,6 +7136,147 @@ export function lowerInstanceOf(L, expr, loc) {
     }
     L.unsupported("SC1090", expr, "statically-decided 'instanceof' on computed operands (bind the value to a variable first)");
 }
+/** `#name in obj` — the ergonomic brand check. In this closed world a
+   * brand is held by exactly the instances of the declaring class
+   * (subclasses included — construction always runs the declaring class's
+   * own initializers), so the test IS `obj instanceof <declaring class>`:
+   * statically decided when the receiver's class sits at/below the
+   * declarer (true) or in a disjoint subtree (false) — both folds under
+   * the instanceof purity rule — and a runtime interval test when the
+   * declarer sits strictly BELOW the receiver's static class (the
+   * narrowing use; tsc types the true branch at the class, and reads
+   * bridge through maybeNarrow's downcast exactly like instanceof). tsc
+   * confines the spelling to the declaring class's body and rejects
+   * primitive/unknown receivers, so Node's in-operator TypeError is
+   * unreachable in compilable programs. Timing residue: JS installs
+   * brands DURING construction, so a check reachable from a base
+   * constructor can observe false mid-construction where this answers
+   * true (SEMANTICS.md). */
+function lowerPrivateIn(L, expr, priv, loc) {
+    const pname = priv.text;
+    // The declaring class: the nearest enclosing class declaring the name
+    // (JS scoping — an inner class's spelling shadows an outer one's).
+    let classDecl = null;
+    let staticBrand = false;
+    for (let n = priv.parent; n; n = n.parent) {
+        if (ts.isClassDeclaration(n) || ts.isClassExpression(n)) {
+            const owner = n.members.find((m) => {
+                const name = m.name;
+                return name !== undefined && ts.isPrivateIdentifier(name) && name.text === pname;
+            });
+            if (owner) {
+                classDecl = n;
+                staticBrand =
+                    ts.canHaveModifiers(owner) &&
+                        ts.getModifiers(owner)?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword) === true;
+                break;
+            }
+        }
+    }
+    // tsc rejects the spelling outside a declaring class body; defensive.
+    if (!classDecl)
+        L.unsupported("SC1090", expr, `'${pname} in …' outside a class declaring '${pname}'`);
+    if (staticBrand) {
+        L.unsupported("SC1090", expr, `'${pname} in …' brand checks for private STATICS (JS brands the declaring class OBJECT, not instances — compare against the class value directly)`);
+    }
+    const info = L.currentClass?.decl === classDecl
+        ? L.currentClass
+        : (() => {
+            const sym = classDecl.name ? L.checker.getSymbolAtLocation(classDecl.name) : undefined;
+            return sym ? L.classBySymbol.get(sym) : undefined;
+        })();
+    if (!info) {
+        L.unsupported("SC1090", expr, `'${pname} in …' where the declaring class has no lowering (see the class declaration's own diagnostic)`);
+    }
+    // A GENERIC family: JS has ONE runtime class and ONE brand for every
+    // instantiation, while these layouts mint one class per instantiation
+    // — a cross-instantiation check would answer false where Node says
+    // true, so the family fences rather than silently splitting the brand.
+    if (info.generic || info.genericInstance) {
+        L.unsupported("SC1090", expr, `'${pname} in …' inside a generic class (JS shares one brand across every instantiation; these layouts mint one class per instantiation)`);
+    }
+    const recv = L.lowerExpr(expr.right);
+    const declName = info.def.name;
+    // A UNION of class instances (`o: Counter | Helper` — the
+    // discriminating use): every object arm answers membership STATICALLY
+    // (at/below the declarer → true, disjoint subtree → false), so the
+    // whole test collapses to runtime TAG tests — the record-shape 'in'
+    // discrimination, brand form. An arm ABOVE the declarer answers per
+    // VALUE (its slot can hold branded and unbranded instances), and
+    // non-object arms have no brand story — both fence.
+    if (recv.type.kind === "union") {
+        const unionId = recv.type.unionId;
+        const arms = L.unions.get(unionId)?.arms ?? [];
+        const answers = [];
+        let staticAnswers = arms.length > 0;
+        for (const arm of arms) {
+            const tag = L.armTag(unionId, arm);
+            if (tag < 0 || arm.kind !== "object" || L.isSubclassOf(declName, arm.className)) {
+                staticAnswers = false;
+                break;
+            }
+            answers.push({ tag, has: arm.className === declName || L.isSubclassOf(arm.className, declName) });
+        }
+        if (staticAnswers) {
+            const pureRecv = recv.kind === "varRef" || recv.kind === "recordGet" || recv.kind === "fieldGet";
+            const isTag = (tag, negated) => ({
+                kind: "unionIsTag",
+                unionId,
+                tag,
+                negated,
+                value: recv,
+                type: BOOL,
+                loc,
+            });
+            const trues = answers.filter((a) => a.has);
+            if (trues.length === answers.length || trues.length === 0) {
+                const ans = trues.length !== 0;
+                if (pureRecv)
+                    return { kind: "boolLit", value: ans, type: BOOL, loc };
+                // Constant either way, receiver still evaluates once: one tag
+                // test whose branches agree (the record-'in' rule verbatim).
+                return {
+                    kind: "ternary",
+                    cond: isTag(answers[0].tag, false),
+                    then: { kind: "boolLit", value: ans, type: BOOL, loc },
+                    else_: { kind: "boolLit", value: ans, type: BOOL, loc },
+                    type: BOOL,
+                    loc,
+                };
+            }
+            if (trues.length === 1)
+                return isTag(trues[0].tag, false);
+            const falses = answers.filter((a) => !a.has);
+            if (falses.length === 1)
+                return isTag(falses[0].tag, true);
+            if (pureRecv) {
+                let out = isTag(trues[0].tag, false);
+                for (const t of trues.slice(1)) {
+                    out = { kind: "logical", op: "||", left: out, right: isTag(t.tag, false), type: BOOL, loc };
+                }
+                return out;
+            }
+            L.unsupported("SC1090", expr, `statically-decided '${pname} in …' on computed receivers (bind the value to a variable first)`);
+        }
+    }
+    if (recv.type.kind !== "object") {
+        L.unsupported("SC1090", expr, `'${pname} in …' on '${L.fmt(recv.type)}' receivers (only class-instance receivers — and unions of classes below or beside the declarer — have a static brand answer; narrow first)`);
+    }
+    const lhsName = recv.type.className;
+    const lhsInfo = L.classes.get(lhsName);
+    if (!lhsInfo)
+        throw new Error(`lowerer bug: unknown class ${lhsName}`);
+    if (L.isSubclassOf(declName, lhsName)) {
+        // The narrowing direction: the declarer strictly below the
+        // receiver's static class — a strict subclass relation puts both in
+        // a hierarchy, so the vtable interval test always exists.
+        return { kind: "instanceOf", value: recv, className: declName, type: BOOL, loc };
+    }
+    const value = lhsName === declName || L.isSubclassOf(lhsName, declName);
+    if (recv.kind === "varRef")
+        return { kind: "boolLit", value, type: BOOL, loc };
+    L.unsupported("SC1090", expr, `statically-decided '${pname} in …' on computed operands (bind the value to a variable first)`);
+}
 /** `"key" in v` — the key-presence test. Three lowered receivers:
    * process.env (getenv(3) presence — Node-exact, an empty value still
    * counts as present), and monomorphic record shapes, where the answer is
@@ -6955,6 +7292,12 @@ export function lowerInstanceOf(L, expr, loc) {
    * and dyn/unknown stay fenced. Keys are literal strings — a computed key
    * over a shape would need the runtime key table. */
 export function lowerInExpression(L, expr, loc) {
+    // `#name in obj` — the ergonomic brand check (ES2022) — resolves
+    // before any string-key machinery: the left operand is a private
+    // NAME, not a value.
+    if (ts.isPrivateIdentifier(expr.left)) {
+        return lowerPrivateIn(L, expr, expr.left, loc);
+    }
     // Compile-time-known STRING keys fold — literals, and the same
     // const/enum-literal and template folding computed property keys get
     // (foldedStringKeyOf); runtime-valued keys keep the fence.
@@ -7522,6 +7865,16 @@ function lowerUnionKeyedRead(L, expr, unionId, value, key, literalField) {
     }
     if (joinArms.length === 0)
         return null;
+    // The join must be a BUILDABLE union: arm kinds the union invariants
+    // admit (no map/dyn/jsval/generator arms; func arms only beside
+    // func/unit siblings — unionFuncSetArmsOk, the validator's rule). A
+    // join mixing, say, a func answer with data answers has no union to
+    // surface as; the caller owns the fence message.
+    if (joinArms.length > 1 &&
+        (!unionFuncSetArmsOk(joinArms) ||
+            joinArms.some((a) => a.kind === "map" || a.kind === "dyn" || a.kind === "jsval" || a.kind === "generator" || a.kind === "caught"))) {
+        return null;
+    }
     joinArms.sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
     const type = joinArms.length === 1 ? joinArms[0] : { kind: "union", unionId: L.unions.intern(joinArms) };
     // Pass 2: every arm's answer must SURFACE as the join, and index arms
@@ -7824,9 +8177,23 @@ export function fieldGetExpr(L, target, loc, blame) {
             loc,
         };
     }
-    return target.container === "class"
-        ? { kind: "fieldGet", obj: target.obj, className: target.className, field: target.field, type: target.fieldType, loc }
-        : { kind: "recordGet", obj: target.obj, shapeId: target.shapeId, field: target.field, type: target.fieldType, loc };
+    if (target.container === "class") {
+        const read = { kind: "fieldGet", obj: target.obj, className: target.className, field: target.field, type: target.fieldType, loc };
+        // DEFERRED-INIT fields (`stream!: T` assigned past the constructor's
+        // top level — ClassInfo.deferredInitFields): the SLOT is the
+        // undefined-armed union; the read CHECKED-extracts the declared type
+        // — a genuinely unassigned read throws the catchable TypeError
+        // where Node reads an undefined the declared type cannot hold.
+        if (L.classes.get(target.className)?.deferredInitFields?.has(target.field) === true &&
+            target.fieldType.kind === "union") {
+            const inner = L.stripUndefinedArm(target.fieldType);
+            const helper = L.deferredReadHelper(target.fieldType.unionId, inner, loc);
+            if (helper)
+                return { kind: "call", callee: helper, args: [read], type: inner, loc };
+        }
+        return read;
+    }
+    return { kind: "recordGet", obj: target.obj, shapeId: target.shapeId, field: target.field, type: target.fieldType, loc };
 }
 /** The write statement for a field target (fieldSet / recordSet / setter
    * call). A write to a getter-only property never gets here in a clean
@@ -8108,4 +8475,38 @@ function lowerStreamObjectProperty(L, expr) {
         return null;
     return lowerStreamProperty(L, expr, info);
 }
+/** The primitive-constructor closure (`String`/`Number`/`Boolean` as a
+ * VALUE): interns one synthesized module function per constructor —
+ * `%builtin.String` et al. — and returns the zero-capture closure over it.
+ * The body IS the string-coercion the type mapping promised
+ * (`(value: string) => primitive`): String is identity, Number the ECMA
+ * StringToNumber (num.fromString — the same runtime call the direct
+ * `Number(s)` lowering emits), Boolean the emptiness test. Interning makes
+ * every reference the SAME immortal closure, so `opt.type === String`
+ * compares like JS function identity. */
+export function primitiveCtorClosure(L, name, loc) {
+    const ret = name === "String" ? STRING : name === "Number" ? F64 : BOOL;
+    const fnT = funcOf([STRING], ret);
+    let fnName = L.primitiveCtorFns.get(name);
+    if (!fnName) {
+        fnName = `%builtin.${name}`;
+        L.primitiveCtorFns.set(name, fnName);
+        const s = { kind: "varRef", localId: "v.0", type: STRING, loc };
+        const value = name === "String"
+            ? s
+            : name === "Number"
+                ? { kind: "libCall", fn: "num.fromString", args: [s], type: F64, loc }
+                : { kind: "strEq", negated: true, left: s, right: { kind: "strLit", value: "", type: STRING, loc }, type: BOOL, loc };
+        const fn = {
+            name: fnName,
+            params: [{ localId: "v.0", name: "value", type: STRING }],
+            returnType: ret,
+            locals: [{ id: "v.0", name: "value", type: STRING, mutable: false }],
+            body: [{ kind: "return", value, loc }],
+            loc,
+        };
+        L.liftedFns.push(fn);
+    }
+    return { kind: "closure", fnName, captures: [], type: fnT, loc };
+}
 //# sourceMappingURL=lower-exprs.js.map