@scriptc/compiler 0.0.6 → 0.0.8

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

@@ -203,6 +203,45 @@ function lowerExprInner(L, expr) {
             if (ts.isArrayLiteralExpression(expr) && expr.elements.length === 0 && underConstAssertion(expr)) {
                 return false;
             }
+            // 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
+            // exists), so the literal takes its own world's path instead —
+            // the DOM literal, or a static record the slot converts.
+            if (isJsSourceFile(expr.getSourceFile()) &&
+                ts.isVariableDeclaration(expr.parent) &&
+                expr.parent.initializer === expr &&
+                ts.isIdentifier(expr.parent.name)) {
+                const bindSym = L.checker.getSymbolAtLocation(expr.parent.name);
+                const g = bindSym ? L.globalsBySymbol.get(bindSym) : undefined;
+                if (g?.type.kind === "dyn")
+                    return false;
+            }
+            // A PROJECT-DECLARED contextual type that only ABSORBED to the
+            // island (a doc-builder typedef whose field's JSDoc type
+            // 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
+            // island slots (npm .d.ts provenance, plain `any`) keep the
+            // native build.
+            if (ctxTs !== undefined && (ctxTs.flags & ts.TypeFlags.Any) === 0) {
+                // Intersection/tuple typedefs (`Line & {readonly soft: true}`)
+                // carry provenance on the ALIAS symbol.
+                const sym = ctxTs.getSymbol() ?? ctxTs.getAliasSymbol();
+                const decls = sym ? L.checker.declarationsOf(sym) : [];
+                const projectDeclared = decls.length > 0 &&
+                    decls.every((d) => {
+                        const sf = d.getSourceFile();
+                        return !sf.isDeclarationFile && !sf.fileName.includes("/node_modules/");
+                    });
+                if (projectDeclared) {
+                    const own = L.mapTypeOf(L.typeOf(expr));
+                    if (own?.kind === "record" || own?.kind === "array")
+                        return false;
+                }
+            }
             return true;
         })()) {
         if (ts.isObjectLiteralExpression(expr)) {
@@ -217,21 +256,73 @@ function lowerExprInner(L, expr) {
             // (`"k" in o` is false), which the static record path can't say.
             const argsWithout = [];
             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) => {
+                if (!(err instanceof PoisonError) ||
+                    !isJsSourceFile(expr.getSourceFile()) ||
+                    L.diagSink !== null ||
+                    L.diags.length <= diagsBefore ||
+                    L.diags.slice(diagsBefore).some((d) => d.code === "SC9001")) {
+                    throw err;
+                }
+                const captured = L.diags.splice(diagsBefore);
+                L.runtimeFences.push(...captured);
+                const first = captured[0];
+                const pos = ts.getLineAndCharacterOfPosition(L.program.getSourceFile(first.loc.file) ?? expr.getSourceFile(), first.loc.start);
+                const fnName = `%fn${L.lambdaCounter++}_islfence`;
+                L.liftedFns.push({
+                    name: fnName,
+                    params: [],
+                    returnType: VOID,
+                    locals: [],
+                    captures: [],
+                    body: [
+                        {
+                            kind: "runtimeFence",
+                            code: first.code,
+                            message: `${first.message} [${first.code} at ${first.loc.file}:${pos.line + 1}]`,
+                            loc: locOf(valueNode),
+                        },
+                    ],
+                    loc: locOf(valueNode),
+                });
+                const fence = { kind: "closure", fnName, captures: [], type: funcOf([], VOID), loc: locOf(valueNode) };
+                return L.jsvalIn(fence, valueNode);
+            };
             const pushProp = (name, value, valueNode, into) => {
+                const diagsBefore = L.diags.length;
+                let marshaled;
+                try {
+                    marshaled = L.jsvalIn(value, valueNode);
+                }
+                catch (err) {
+                    marshaled = islandMemberFence(diagsBefore, err, valueNode);
+                }
                 for (const args of into) {
                     args.push({
                         kind: "jsMarshal",
                         value: { kind: "strLit", value: name.text, type: STRING, loc: locOf(name) },
                         type: JSVAL, loc: locOf(name),
                     });
-                    args.push(L.jsvalIn(value, valueNode));
+                    args.push(marshaled);
                 }
             };
+            const spreadSrcs = [];
+            let sawPlainProp = false;
             for (const prop of expr.properties) {
                 if (ts.isSpreadAssignment(prop)) {
                     const cs = conditionalSpreadOf(prop.expression);
                     if (cs && cs !== "unsupported" && !spread) {
+                        if (spreadSrcs.length > 0) {
+                            L.unsupported("SC1090", prop, "a conditional spread mixed with plain spreads in an 'any'-typed object literal");
+                        }
                         const cond = L.lowerCondition(cs.cond);
                         if (!pureCondExpr(cond)) {
                             L.unsupported("SC1090", prop, "conditional spreads with effectful conditions in an 'any'-typed object literal (bind the condition to a const first)");
@@ -243,8 +334,23 @@ function lowerExprInner(L, expr) {
                         }
                         continue;
                     }
+                    // A PLAIN spread (`{ ...options, plugins }` — the withPlugins
+                    // argument-rebuild shape): the source copies into the fresh
+                    // engine object through the spec's CopyDataProperties (the
+                    // objSpread op). Spreads must precede explicit properties
+                    // (the composition applies explicit keys AFTER the copies —
+                    // JS's later-wins — which a spread after them would invert);
+                    // mixing with a conditional spread keeps the fence.
+                    if (cs === undefined || cs === null) {
+                        if (sawPlainProp || spread) {
+                            L.unsupported("SC1090", prop, "object spread after explicit properties (or mixed with a conditional spread) in an 'any'-typed object literal — spreads must come first");
+                        }
+                        spreadSrcs.push(L.jsvalIn(L.lowerExpr(prop.expression), prop.expression));
+                        continue;
+                    }
                     L.unsupported("SC1090", prop, "this spread form in an 'any'-typed object literal (one `...(c ? { k: v } : {})` conditional spread is supported — bind other shapes to a const and set keys explicitly)");
                 }
+                sawPlainProp = true;
                 // `name: value`, the shorthand `{ name }` (the value is the
                 // identifier itself, resolved through the shorthand VALUE symbol
                 // like the static record path), and METHODS — `{ load() {...} }`
@@ -254,22 +360,79 @@ function lowerExprInner(L, expr) {
                 // string-literal keys — engine property names have no
                 // identifier restriction ("content-type").
                 const name = prop.name;
-                const value = ts.isPropertyAssignment(prop)
-                    ? L.lowerExpr(prop.initializer)
-                    : ts.isShorthandPropertyAssignment(prop)
-                        ? L.lowerShorthandValue(prop)
-                        : ts.isMethodDeclaration(prop) && prop.body
-                            ? (L.rejectThisInObjectMethod(prop.body), L.lowerLambda(prop))
-                            : null;
+                // A GET accessor (`get root() { return ROOT_INDENT; }` — the
+                // doc-printer's self-referential root-indent shape): the body
+                // lowers as a zero-param closure marshaled into the engine, and
+                // the property defines through the engine's own getter
+                // machinery AFTER the literal builds (the defineGetter op) —
+                // reads through the handle invoke it natively. `this` in the
+                // body keeps the object-method rejection; setters stay fenced.
+                if (ts.isGetAccessorDeclaration(prop) && prop.body && name && (ts.isIdentifier(name) || ts.isStringLiteral(name))) {
+                    L.rejectThisInObjectMethod(prop.body);
+                    getters.push({ name: name.text, fn: L.jsvalIn(L.lowerLambda(prop), prop), loc: locOf(prop) });
+                    continue;
+                }
+                // A member VALUE that cannot lower at all (a generic function
+                // referenced as a value — the aggregate's `align`): the same
+                // call-time fence deferral pushProp applies to marshal failures.
+                let value = null;
+                const valueDiagsBefore = L.diags.length;
+                try {
+                    value = ts.isPropertyAssignment(prop)
+                        ? L.lowerExpr(prop.initializer)
+                        : ts.isShorthandPropertyAssignment(prop)
+                            ? L.lowerShorthandValue(prop)
+                            : ts.isMethodDeclaration(prop) && prop.body
+                                ? (L.rejectThisInObjectMethod(prop.body), L.lowerLambda(prop))
+                                : null;
+                }
+                catch (err) {
+                    value = islandMemberFence(valueDiagsBefore, err, prop);
+                }
                 if (value && name && (ts.isIdentifier(name) || ts.isStringLiteral(name))) {
                     pushProp(name, value, prop, [argsWithout, argsWith]);
                 }
                 else {
-                    L.unsupported("SC1090", prop, "this property form in an 'any'-typed object literal (only `name: value` and shorthand names are supported)");
+                    L.unsupported("SC1090", prop, "this property form in an 'any'-typed object literal (only `name: value`, shorthand names, methods, and get accessors are supported)");
                 }
             }
-            if (!spread)
-                return { kind: "jsOp", op: "objLit", args: argsWithout, type: JSVAL, loc };
+            const withGetters = (obj) => getters.reduce((acc, g) => ({
+                kind: "jsOp",
+                op: "defineGetter",
+                args: [
+                    acc,
+                    { kind: "jsMarshal", value: { kind: "strLit", value: g.name, type: STRING, loc: g.loc }, type: JSVAL, loc: g.loc },
+                    g.fn,
+                ],
+                type: JSVAL,
+                loc: g.loc,
+            }), obj);
+            if (!spread) {
+                if (spreadSrcs.length === 0) {
+                    return withGetters({ kind: "jsOp", op: "objLit", args: argsWithout, type: JSVAL, loc });
+                }
+                // Plain spreads compose left to right onto a fresh object, the
+                // explicit properties merging LAST (JS's later-wins): spread
+                // sources evaluate before later property values by nesting
+                // order, exactly the source order.
+                let acc = { kind: "jsOp", op: "objLit", args: [], type: JSVAL, loc };
+                for (const src of spreadSrcs) {
+                    acc = { kind: "jsOp", op: "objSpread", args: [acc, src], type: JSVAL, loc };
+                }
+                if (argsWithout.length > 0) {
+                    acc = {
+                        kind: "jsOp",
+                        op: "objSpread",
+                        args: [acc, { kind: "jsOp", op: "objLit", args: argsWithout, type: JSVAL, loc }],
+                        type: JSVAL,
+                        loc,
+                    };
+                }
+                return withGetters(acc);
+            }
+            if (getters.length > 0) {
+                L.unsupported("SC1090", expr, "get accessors combined with conditional spreads in an 'any'-typed object literal");
+            }
             const withLit = { kind: "jsOp", op: "objLit", args: argsWith, type: JSVAL, loc };
             const withoutLit = { kind: "jsOp", op: "objLit", args: argsWithout, type: JSVAL, loc };
             return {
@@ -1538,7 +1701,7 @@ export function lowerTernary(L, expr, expected) {
         // The ternary's IR type is normally the checker's own: it collapses
         // same-kind literal unions ("a" | "b" → string) and forms tagged
         // unions for mixed arms that map (`c ? okRec : errRec`); anything
-        // left unmappable gets SC2001 here. A record/union CONTEXTUAL type
+        // left unmappable gets the type fence (badType) here. A record/union CONTEXTUAL type
         // takes over exactly when the own type can't carry the value —
         // unmappable, or a DIFFERENT union (branch literals omitting
         // DIFFERENT optional subsets make the own type a union of the
@@ -1744,10 +1907,25 @@ export function lowerUnitComparison(L, left, right, negated, loc) {
     }
     if (other.type.kind === "union") {
         const tag = L.armTag(other.type.unionId, unit.type);
-        // A union without that unit arm cannot compare equal; tsc rejects
-        // no-overlap comparisons before lowering, so this is defensive.
-        if (tag < 0)
-            return null;
+        if (tag < 0) {
+            // A union WITHOUT that unit arm: legal TS (`miss === null` on a
+            // `number | undefined` — null/undefined guard comparisons are
+            // permitted against nullable-adjacent types), and === never
+            // coerces, so the answer is the constant `negated`. The literal
+            // must NOT flow into the union representation (the unionEq
+            // fallback would coerce it through the stranded-arm trap and
+            // throw where Node answers false). JS still evaluates the
+            // operand, so a non-droppable one (`xs.find(f) === null` — the
+            // callback's effects are observable) rides one throwaway tag
+            // test; droppable reads fold to the bare literal.
+            const answer = { kind: "boolLit", value: negated, type: BOOL, loc };
+            if (droppableStatic(other))
+                return answer;
+            const evalOnce = {
+                kind: "unionIsTag", unionId: other.type.unionId, tag: 0, negated: false, value: other, type: BOOL, loc,
+            };
+            return { kind: "logical", op: negated ? "||" : "&&", left: evalOnce, right: answer, type: BOOL, loc };
+        }
         return {
             kind: "unionIsTag",
             unionId: other.type.unionId,
@@ -1977,7 +2155,11 @@ export function lowerNullishCoalesce(L, expr, loc) {
         L.unsupported("SC1100", expr, "nullish coalescing on 'unknown' values");
     }
     if (left.type.kind === "jsval") {
-        L.unsupported("SC1090", expr, "nullish coalescing on 'any' values");
+        // `a ?? b` on an ISLAND value: the engine's own nullish test — the
+        // left evaluates once, the right runs lazily in its branch and
+        // marshals in (the emitter's jsval nullish arm).
+        const right = L.jsvalIn(L.lowerExpr(expr.right), expr.right);
+        return { kind: "nullish", left, right, type: JSVAL, loc };
     }
     if (left.type.kind !== "union")
         return left;
@@ -2818,7 +3000,7 @@ export function lowerIntrinsicProperty(L, expr) {
 /** `[a, b, c]`. The element type comes from the contextual type when tsc
    * has one (`const a: number[] = []`, arguments, nested literals) and from
    * the literal's own inferred type otherwise. A bare `[]` with no context
-   * is `never[]` — unmappable, rejected with SC2001. `expected` overrides
+   * is `never[]` — unmappable, rejected with the component fence (SC2009). `expected` overrides
    * the contextual lookup where the caller knows the slot's array type and
    * tsc's API doesn't surface it (ternary arms under an array context —
    * tsc accepts the arm covariantly, but a tagged element representation
@@ -2872,6 +3054,36 @@ export function lowerArrayLiteral(L, expr, expected) {
             if (arrayArms.length === 1)
                 mapped = arrayArms[0];
         }
+        // A NON-EMPTY literal whose own type has no static home (the JS dyn
+        // fallback — a null/dyn mapping, or an inference that degraded to a
+        // unit-only-element array over non-unit elements) under a union
+        // with exactly ONE array-family arm — an array, or an
+        // arity-matching tuple (the option-table `default: [{ value: [] }]`
+        // shape): build AS that arm, exactly the empty-literal rule above;
+        // the slot's coercion wraps it.
+        if (ctxUnion && expr.elements.length > 0) {
+            // A unit-only-element array (`(null | undefined)[]`) cannot hold
+            // non-unit elements — neither as the literal's own mapping nor as
+            // a competing union arm.
+            const nonUnitElems = expr.elements.some((el) => !ts.isOmittedExpression(el) &&
+                el.kind !== ts.SyntaxKind.NullKeyword &&
+                !(ts.isIdentifier(el) && el.text === "undefined"));
+            const ownUnhelpful = mapped === null || mapped.kind === "dyn" ||
+                // The checker echoing the context union back as the literal's
+                // own type decides nothing either — nor does an island ('any')
+                // residue under a STATIC union slot.
+                mapped.kind === "union" || mapped.kind === "jsval" ||
+                (mapped.kind === "array" && nonUnitElems && L.unitOnlyElem(mapped.elem));
+            if (ownUnhelpful) {
+                const def = L.unions.get(ctxUnion.unionId);
+                const arms = (def?.arms ?? []).filter((a) => (a.kind === "array" && !(nonUnitElems && L.unitOnlyElem(a.elem))) ||
+                    (a.kind === "record" &&
+                        !!L.shapes.get(a.shapeId)?.tuple &&
+                        L.shapes.get(a.shapeId).fields.length === expr.elements.length));
+                if (arms.length === 1)
+                    mapped = arms[0];
+            }
+        }
     }
     // An EMPTY literal under a CONST ASSERTION whose type queries panicked
     // (tsgo's readonly-[] TupleType conversion — the facade answers `any`,
@@ -3230,7 +3442,7 @@ function propNameText(L, name) {
    * (dynFrom's domain, functions box); a value with no dyn representation
    * fences per property. Spreads, accessors, and methods stay fenced —
    * none co-occur with the computed-key idiom in the wild. */
-function lowerDynObjectLiteral(L, expr) {
+export function lowerDynObjectLiteral(L, expr) {
     const loc = locOf(expr);
     const fields = [];
     for (const prop of expr.properties) {
@@ -3268,11 +3480,92 @@ function lowerDynObjectLiteral(L, expr) {
         // Lambda values that fail to lower become trap closures (the
         // per-call fence granularity — fenceClosureProbe) so the object
         // still builds; everything else keeps the per-property fence below.
-        const raw = fenceClosureProbe(L, valueExpr, undefined, () => L.lowerExpr(valueExpr)) ??
-            L.lowerExpr(valueExpr);
-        const v = L.coerceToExpected(raw, DYN);
+        let raw;
+        const propDiagsBefore = L.diags.length;
+        try {
+            raw =
+                fenceClosureProbe(L, valueExpr, undefined, () => L.lowerExpr(valueExpr)) ??
+                    L.lowerExpr(valueExpr);
+        }
+        catch (err) {
+            // A PURE member read a JS file cannot lower (a namespace object
+            // in an export aggregate): the slot takes a boxed fence closure —
+            // the diagnostics defer to the runtime-fence ledger, the object
+            // builds, and only USING the member stops the run.
+            const pureMember = ts.isIdentifier(valueExpr);
+            if (!(err instanceof PoisonError) ||
+                !pureMember ||
+                L.diagSink !== null ||
+                L.diags.length <= propDiagsBefore ||
+                L.diags.slice(propDiagsBefore).some((d) => d.code === "SC9001")) {
+                throw err;
+            }
+            const captured = L.diags.splice(propDiagsBefore);
+            L.runtimeFences.push(...captured);
+            const first = captured[0];
+            const pos = ts.getLineAndCharacterOfPosition(L.program.getSourceFile(first.loc.file) ?? expr.getSourceFile(), first.loc.start);
+            const fnName = `%fn${L.lambdaCounter++}_dynfence`;
+            L.liftedFns.push({
+                name: fnName,
+                params: [],
+                returnType: VOID,
+                locals: [],
+                captures: [],
+                body: [
+                    {
+                        kind: "runtimeFence",
+                        code: first.code,
+                        message: `${first.message} [${first.code} at ${first.loc.file}:${pos.line + 1}]`,
+                        loc: locOf(prop),
+                    },
+                ],
+                loc: locOf(prop),
+            });
+            raw = { kind: "closure", fnName, captures: [], type: funcOf([], VOID), loc: locOf(prop) };
+        }
+        let v = L.coerceToExpected(raw, DYN);
         if (v.type.kind !== "dyn") {
-            L.unsupported("SC1101", valueExpr, `holding '${L.fmt(v.type)}' values in a runtime-keyed (computed-key) object literal`);
+            const convDiagsBefore = L.diags.length;
+            try {
+                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
+                // 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
+                // member — the slot takes a boxed fence closure; only USING it
+                // stops the run. Probe mode and ICEs keep the poison.
+                if (!(err instanceof PoisonError) ||
+                    L.diagSink !== null ||
+                    L.diags.length <= convDiagsBefore ||
+                    L.diags.slice(convDiagsBefore).some((d) => d.code === "SC9001")) {
+                    throw err;
+                }
+                const captured = L.diags.splice(convDiagsBefore);
+                L.runtimeFences.push(...captured);
+                const first = captured[0];
+                const pos = ts.getLineAndCharacterOfPosition(L.program.getSourceFile(first.loc.file) ?? expr.getSourceFile(), first.loc.start);
+                const fnName = `%fn${L.lambdaCounter++}_dynfence`;
+                L.liftedFns.push({
+                    name: fnName,
+                    params: [],
+                    returnType: VOID,
+                    locals: [],
+                    captures: [],
+                    body: [
+                        {
+                            kind: "runtimeFence",
+                            code: first.code,
+                            message: `${first.message} [${first.code} at ${first.loc.file}:${pos.line + 1}]`,
+                            loc: locOf(prop),
+                        },
+                    ],
+                    loc: locOf(prop),
+                });
+                const fence = { kind: "closure", fnName, captures: [], type: funcOf([], VOID), loc: locOf(prop) };
+                v = L.coerceToExpected(fence, DYN);
+            }
         }
         fields.push({ key, value: v });
     }
@@ -3465,7 +3758,7 @@ export function lowerObjectLiteral(L, expr) {
     // Syntax fence FIRST: unsupported member forms get their specific
     // message even when they also make the literal's type unmappable
     // (a getter or a `this`-returning method would otherwise surface as an
-    // opaque SC2001 on the whole literal).
+    // opaque type fence on the whole literal).
     for (const prop of expr.properties) {
         if (ts.isSpreadAssignment(prop)) {
             // Supported shapes: FULL spreads of known record shapes read as
@@ -3610,7 +3903,11 @@ export function lowerObjectLiteral(L, expr) {
     // the slot's width coercion constructs through the trivial
     // parameter-property constructor (recordToClassPlan), or fences with
     // the record-shape story.
-    if (mapped === null || mapped.kind === "union" || mapped.kind === "dyn" || mapped.kind === "object") {
+    // A jsval-mapped context reaches here only when lowerExpr's island
+    // gate DECLINED it (a project-declared typedef that absorbed to the
+    // island through checker-`any` field residue): the literal builds at
+    // its own type like every unmappable context.
+    if (mapped === null || mapped.kind === "union" || mapped.kind === "dyn" || mapped.kind === "object" || mapped.kind === "jsval") {
         const ctxUnion = mapped?.kind === "union" ? mapped : null;
         mapped = L.mapTypeOf(L.typeOf(expr)) ?? mapped;
         // A literal whose own shape re-tags into NO arm of the contextual
@@ -3870,6 +4167,9 @@ export function lowerObjectLiteral(L, expr) {
     // contributor overriding one would silently drop that evaluation —
     // collisions fence in both directions.
     const conditionalNames = new Set();
+    // Member names DROPPED from the shape (JS deferral — unlowerable pure
+    // member reads narrow away; see the catch in the property loop).
+    const droppedNames = new Set();
     for (const prop of expr.properties) {
         if (ts.isSpreadAssignment(prop)) {
             const cs = conditionalSpreadOf(prop.expression);
@@ -4288,21 +4588,56 @@ export function lowerObjectLiteral(L, expr) {
         }
         let value;
         let valueNode = prop;
-        if (ts.isPropertyAssignment(prop)) {
-            valueNode = prop.initializer;
-            value =
-                fenceClosureProbe(L, prop.initializer, fieldType, () => L.lowerExpr(prop.initializer)) ??
-                    L.lowerExpr(prop.initializer);
-        }
-        else if (ts.isShorthandPropertyAssignment(prop)) {
-            value = L.lowerShorthandValue(prop);
-        }
-        else if (ts.isMethodDeclaration(prop)) {
-            value =
-                fenceClosureProbe(L, prop, fieldType, () => L.lowerLambda(prop)) ?? L.lowerLambda(prop);
-        }
-        else {
-            L.unsupported("SC1090", prop, `syntax '${ts.SyntaxKind[prop.kind]}'`);
+        const propDiagsBefore = L.diags.length;
+        try {
+            if (ts.isPropertyAssignment(prop)) {
+                valueNode = prop.initializer;
+                // ARRAY-LITERAL initializers route through the expected-type
+                // 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.
+                let init = prop.initializer;
+                while (ts.isParenthesizedExpression(init))
+                    init = init.expression;
+                value =
+                    fenceClosureProbe(L, prop.initializer, fieldType, () => L.lowerExpr(prop.initializer)) ??
+                        (fieldType !== undefined && ts.isArrayLiteralExpression(init)
+                            ? L.lowerExprExpecting(prop.initializer, fieldType)
+                            : L.lowerExpr(prop.initializer));
+            }
+            else if (ts.isShorthandPropertyAssignment(prop)) {
+                value = L.lowerShorthandValue(prop);
+            }
+            else if (ts.isMethodDeclaration(prop)) {
+                value =
+                    fenceClosureProbe(L, prop, fieldType, () => L.lowerLambda(prop)) ?? L.lowerLambda(prop);
+            }
+            else {
+                L.unsupported("SC1090", prop, `syntax '${ts.SyntaxKind[prop.kind]}'`);
+            }
+        }
+        catch (err) {
+            // A member VALUE a JS file cannot lower (a namespace object in an
+            // export aggregate — the sharedWithCli `errors` member): the
+            // member NARROWS AWAY like a CJS export-table accessor entry —
+            // the diagnostics defer to the runtime-fence ledger, the shape
+            // drops the field, and each READ of it meets its own per-site
+            // fence. Pure member forms only (identifier/shorthand reads);
+            // TypeScript, probe mode, and ICEs keep the poison.
+            const pureMember = ts.isShorthandPropertyAssignment(prop) ||
+                (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.initializer));
+            if (!(err instanceof PoisonError) ||
+                !pureMember ||
+                !isJsSourceFile(expr.getSourceFile()) ||
+                L.diagSink !== null ||
+                L.diags.length <= propDiagsBefore ||
+                L.diags.slice(propDiagsBefore).some((d) => d.code === "SC9001")) {
+                throw err;
+            }
+            L.runtimeFences.push(...L.diags.splice(propDiagsBefore));
+            droppedNames.add(name);
+            continue;
         }
         if (!fieldType) {
             // Overflow entry: the value flows into the index signature's value
@@ -4337,6 +4672,12 @@ export function lowerObjectLiteral(L, expr) {
     // omission of required fields before lowering, undefined-armed or not).
     // A REQUIRED missing field keeps the shape-mismatch rejection (possible
     // through `as`: the cast smuggles a narrower literal past freshness).
+    if (droppedNames.size > 0) {
+        const narrowed = shape.fields.filter((f) => !droppedNames.has(f.name));
+        const narrowedId = L.shapes.intern(narrowed.map((f) => ({ name: f.name, type: f.type })), false, shape.indexValue);
+        type = { kind: "record", shapeId: narrowedId };
+        shape = L.shapes.get(narrowedId);
+    }
     if (fields.filter((f) => !f.overflow).length !== shape.fields.length) {
         const provided = new Set(fields.filter((f) => !f.overflow).map((f) => f.name));
         for (const f of shape.fields) {
@@ -4967,7 +5308,11 @@ export function lowerRecordKeyRead(L, expr, shapeId, shape) {
     // NUMERIC literals are their canonical string spelling — JS object keys
     // ARE strings (`r[1]` reads `r["1"]`), so `b[1]` hits a declared field
     // named "1" (a mapped type over a numeric enum) exactly like `b["1"]`.
-    const litKey = recordKeyLiteralText(keyNode);
+    // A key IDENTIFIER whose type proves one literal (a literal-typed
+    // const, a keyof-constrained type parameter bound to a literal inside
+    // a generic instance) is the same static read — identifier evaluation
+    // is pure, so skipping it matches JS exactly.
+    const litKey = recordKeyLiteralText(keyNode) ?? recordKeyTypeLiteralText(L, keyNode);
     // The receiver lowers FIRST (both branches below read it, and JS
     // evaluates the receiver before the key).
     const obj = L.lowerExpr(expr.expression);
@@ -5054,6 +5399,32 @@ export function recordKeyLiteralText(node) {
         return String(Number(node.text));
     return null;
 }
+/** The compile-time key an IDENTIFIER's TYPE proves: a key variable whose
+ * (narrowed) type is one string/number literal — `const k: "a" = …; o[k]`,
+ * and the generic-body form where k's type is a keyof-constrained
+ * parameter bound to a literal (`pick(o, "a")`'s instance reads `o[k]`
+ * with K = "a", resolved through typeParamTsBindings). Identifier reads
+ * are pure, so the static field read may skip evaluating the key exactly
+ * like a syntactic literal. Null anywhere the type keeps more than one
+ * key. */
+export function recordKeyTypeLiteralText(L, node) {
+    if (!ts.isIdentifier(node))
+        return null;
+    let t = L.typeOf(node);
+    if (t.flags & ts.TypeFlags.TypeParameter) {
+        const bound = L.typeParamTsResolver(t);
+        if (!bound)
+            return null;
+        t = bound;
+    }
+    if (t.isStringLiteralType())
+        return t.value;
+    if (t.isNumberLiteralType()) {
+        const n = t.value;
+        return Number.isFinite(n) && n >= 0 ? String(n) : null;
+    }
+    return null;
+}
 /** 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
@@ -5217,8 +5588,13 @@ export function lowerElementWrite(L, expr) {
         if (shape && !shape.tuple) {
             // Literal keys — string literals AND numeric literals in their
             // canonical string spelling (`b[1] = v` writes field/key "1", JS's
-            // own key derivation) — name declared fields directly.
-            const litKey = recordKeyLiteralText(target.argumentExpression);
+            // own key derivation) — name declared fields directly. A key
+            // IDENTIFIER whose TYPE proves one literal (a literal-typed const,
+            // a keyof-constrained type parameter bound to a literal inside a
+            // generic instance — `set(o, "a", v)`'s body writing `o[k] = v`)
+            // is the same static field write.
+            const litKey = recordKeyLiteralText(target.argumentExpression) ??
+                recordKeyTypeLiteralText(L, target.argumentExpression);
             if (litKey !== null) {
                 const field = shape.fields.find((f) => f.name === litKey);
                 if (field) {
@@ -5228,7 +5604,40 @@ export function lowerElementWrite(L, expr) {
                 }
             }
             if (!shape.indexValue) {
-                L.unsupported("SC1090", target, "dynamic keyed writes to records without an index signature (spell the field name)");
+                // A SIGNATURE-FREE shape whose declared fields share ONE type
+                // writes through the same per-shape dispatch (the mockable-clock
+                // module shape: `mocked[functionality] = implementation` over a
+                // table of same-signature closures). A key naming no declared
+                // field throws the catchable TypeError — JS would ADD the
+                // property, which a monomorphic struct cannot (the SEMANTICS.md
+                // keyed-write-miss divergence). Mixed-type and accessor-carrying
+                // shapes keep the fence.
+                const common = shape.fields.length > 0 &&
+                    !shapeHasAccessorSlots(shape) &&
+                    shape.fields.every((f) => typeEquals(f.type, shape.fields[0].type))
+                    ? shape.fields[0].type
+                    : null;
+                if (!common) {
+                    L.unsupported("SC1090", target, "dynamic keyed writes to records without an index signature (declared fields of ONE shared type dispatch by key — spell the field name otherwise)");
+                }
+                const obj = L.lowerExpr(target.expression);
+                let key = litKey !== null
+                    ? { kind: "strLit", value: litKey, type: STRING, loc: locOf(target.argumentExpression) }
+                    : L.lowerExpr(target.argumentExpression);
+                // Runtime number/boolean/dyn keys stringify — ToPropertyKey,
+                // exactly the index-signature path's rule.
+                if (key.type.kind === "f64")
+                    key = L.ensureString(key, target.argumentExpression);
+                if (key.type.kind === "bool" || key.type.kind === "dyn") {
+                    key = { kind: "toString", operand: key, type: STRING, loc: locOf(target.argumentExpression) };
+                }
+                if (key.type.kind !== "string") {
+                    L.unsupported("SC1090", target.argumentExpression, "indexing records with non-string or non-number keys");
+                }
+                const value = L.coerceInto(expr.right, L.lowerExpr(expr.right), common);
+                if (!typeEquals(value.type, common))
+                    L.badType(expr.right, L.typeOf(expr.right));
+                return { kind: "recordKeySet", obj, shapeId: receiverIr.shapeId, key, value, loc: locOf(expr) };
             }
             // A LITERAL key naming no declared field is a pure overflow insert
             // — no collision to validate. Runtime keys must be able to collide
@@ -7028,6 +7437,27 @@ export function lowerInstanceOf(L, expr, loc) {
                 return { kind: "dynTest", test: "bytes", value: left, type: BOOL, loc };
             }
         }
+        // `x instanceof RegExp` over a union with a regex arm (the
+        // skip-utility `string | RegExp` dispatch): a union tag test — the
+        // socket-narrowing shape; the checker types the branches and
+        // maybeNarrow bridges the reads. A plain regex-typed LHS folds
+        // true; the fold keeps the operand-purity rule of the class folds
+        // (identifier reads only).
+        if (ts.isIdentifier(expr.right) &&
+            L.isStdlibGlobal(expr.right, "RegExp") &&
+            !L.caughtLocalOf(expr.left)) {
+            const left = L.lowerExpr(expr.left);
+            if (left.type.kind === "union") {
+                const def = L.unions.get(left.type.unionId);
+                const tag = def ? def.arms.findIndex((a) => a.kind === "regex") : -1;
+                if (tag >= 0) {
+                    return { kind: "unionIsTag", unionId: left.type.unionId, tag, negated: false, value: left, type: BOOL, loc };
+                }
+            }
+            if (left.type.kind === "regex" && left.kind === "varRef" && ts.isIdentifier(expr.left)) {
+                return { kind: "boolLit", value: true, type: BOOL, loc };
+            }
+        }
         // `x instanceof X` where X is a class VALUE (a classval-typed
         // binding): the target is DYNAMIC — a hierarchy target reads its
         // interval from the class object at runtime (instanceOfValue); a