@scriptc/compiler 0.4.8 → 0.4.9

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

@@ -1,21 +1,27 @@
 import { lowerStaticPrivateAssignment } from "./private-statics.js";
 import { keepsCheckedDynamicValue, keepsInitializerLayout, notePreservedLayout, } from "./structural-instances.js";
 import { partialFieldRead } from "./partial-assertions.js";
+import { answerLinkedCopies, registerLinkedHelper } from "./record-links.js";
+import { recordSourceTest } from "./record-sources.js";
+import { keyedHelperName } from "./stable-names.js";
+import { OBJECT_PROTOTYPE_KEYS } from "./expressions/relational.js";
 import { jsGlobalValueByName } from "./global-values.js";
 import { lowerTupleAliasDecl, stripTypeWrappers } from "./typed-arguments.js";
 import { islandHandleBinding, lowerIslandExpr, isIslandRequireSpec, lowerIslandRequireAtStatement, lowerIslandSubclass, } from "./lower-node-island.js";
 import { isIslandSubclassDecl } from "../../node-islands/boundary.js";
 import { allBytesArms, indexedUnionArms, lowerIndexedUnionMember, lowerIndexedUnionNumberRead, lowerIndexedUnionRead, } from "./indexed-unions.js";
-import { declaredMemberOf, fenceDatePrototypeWrite, isPromisePrototypeRead, lowerUnionKeyedRead, } from "./expressions/property-access.js";
-import { hostedStorageView, hostsAll, recordViewHosted } from "./expressions/hosted-narrowing.js";
+import { declaredMemberOf, fenceDatePrototypeWrite, isDataViewPrototypeRead, isPromisePrototypeRead, lowerUnionKeyedRead, } from "./expressions/property-access.js";
+import { assertedOptionalExtension, hostedStorageView, hostsAll, recordViewHosted, } from "./expressions/hosted-narrowing.js";
+import { assertedOnlyMemberWrite } from "./expressions/asserted-receiver.js";
 import { assertionViewCopy, bindingIdentityUse, bindingWrite } from "./divergences.js";
 import { requestGeneralStreamSurface } from "./general-streams.js";
 import { lowerForAwaitDynStream, nodeStreamInterfaceSide } from "./dyn-streams.js";
 import { lowerForAwaitValueStream } from "./builtins/hash-stream.js";
-import { lowerChildPropertyWrite } from "./handle-properties.js";
+import { TYPED_HANDLE_KINDS, boxedHandleReceiver, handleMemberGranted, lowerChildPropertyWrite, lowerHandlePropertyWrite, } from "./handle-properties.js";
 import { matchAllRowsReadByElements, storedMatchAllRowsReadByElements, } from "./containers/match-row-uses.js";
 import { dynUndefinedExpr, nodeThrowExpr, numLit, strLit, varRef } from "../../ir/build.js";
-import { literalFieldKeys, runtimeKeyPatternRead } from "./expressions/keyed-field-targets.js";
+import { runtimeKeyPatternRead } from "./expressions/keyed-field-targets.js";
+import { constantDeleteKey, erasedDeletePlan, lowerDeleteComputedKey, lowerDeleteKey, lowerRecordMemberDelete, } from "./expressions/erased-delete.js";
 import { declaresHoistedBinding, staticCondition } from "./static-typeof.js";
 import { lowerCollectionSpread } from "./containers/collection-methods.js";
 import { lowerEventObjectPropertyWrite } from "./lower-event-target.js";
@@ -42,27 +48,27 @@ import { isTimeValueDateDeclaration } from "./date-values.js";
 import { bindingSource } from "../binding-source.js";
 import { clearPendingPrimitiveReturn, lowerConstructorReturn } from "./constructor-returns.js";
 import { statementGroupKey } from "./type-failure.js";
-import { cjsExportValueByName, cjsNamespaceDestructureOf, cjsTableMethodEntry, inlineProgramRequireOf, requireNestedPatternsOf, splitRequireAssignmentOf, splitRequireBindingOf, splitRequireBindingOfIdent, splitRequireEarlyReadOf, wholeExportSymbolOfModule, } from "./cjs-inline-require.js";
+import { cjsExportValueByName, cjsNamespaceDestructureOf, cjsTableExportNamesInOrder, cjsTableMethodEntry, inlineProgramRequireOf, requireNestedPatternsOf, requireRestElementsOf, splitRequireAssignmentOf, splitRequireBindingOf, splitRequireBindingOfIdent, splitRequireEarlyReadOf, wholeExportSymbolOfModule, } from "./cjs-inline-require.js";
 import { cjsExportMemberWriteGlobalOf, isCjsExportsIdentifier, isCjsModuleExports, isFreshExportsReset, } from "./cjs-exports-object.js";
 import { isDeadTscHelperDecl, tscInteropBindingOfDecl } from "./cjs-tsc-interop.js";
 import { arrayValueRead, arrayValueStore, arrayValueType, unionArrayValueRead, lowerSafeIndexRead, } from "./array-values.js";
 import { lowerForAwaitGenerator, lowerForOfGenerator, lowerYieldStarStatement, } from "./lower-generators.js";
 import { classAsyncGeneratorIterator, isNodeReadableIteratorSource, isWebReadableIteratorSource, lowerForAwaitBuiltin, } from "./lower-async-iteration.js";
-import { BOOL, BYTES_U8, CAUGHT, DATE_T, DYN_HANDLE_KINDS, DYN, F64, SEARCH_PARAMS_T, STRING, UNDEFINED_T, VOID, arrayOf, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals, } from "../../ir/ir.js";
+import { BOOL, BYTES_U8, CAUGHT, DATE_T, DYN_HANDLE_KINDS, DYN, F64, SEARCH_PARAMS_T, STRING, UNDEFINED_T, VOID, arrayOf, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals, typeKey, } from "../../ir/ir.js";
 import { PoisonError, boundIdentifiersOf, dynFallbackType, neverTaintedJsType, staticImportNamespaceType, } from "./lowerer.js";
 import { enforceLibBoundary, lowerSurplusCalls } from "./lib-boundary.js";
 import { isBuiltinIdentityToken, isPrimitiveValueType, lowerPrimitiveBaseDelete, } from "./primitive-throws.js";
 import { cjsExportAssignmentOf, cjsExportChainOf, cjsVoidInitPreambleReals, cjsExportDiscardReason, cjsExportTargetLiteral, isCjsJsFile, isEsModuleStamp, isJsSourceFile, locOf, requireEarlyReference, requireSpecOf, } from "../program.js";
+import { callableDeleteKey } from "./callable-properties.js";
 import { isStrictCode } from "./strict-mode.js";
-import { markSloppyRecordWrites } from "./frozen-records.js";
 import { COMPOUND_ASSIGN_OPS, STR_METHODS, NARROW_FIRST, UNSUPPORTED_STMT, isStdlibMember, sideEffectFreeOptionValue, stdlibGlobalAliasDecl, stdlibGlobalAliasNameOf, bufferNamespaceMember, stdlibGlobalNameOf, } from "./surfaces.js";
 import { isNativeBuiltinValueInitializer } from "./lower-builtin-values.js";
 import { isProvenanceSourceFile } from "../provenance-registry.js";
 import { ambientUndefVarRootOf, lowerImportEquals, nsUndefRead, nsWritableTarget, trapDeclRootOf, } from "./lower-namespaces.js";
-import { expandoWritableTarget, lowerExpandoAssignStmt } from "./lower-expando.js";
+import { fenceReadonlyExpandoWrite } from "./lower-expando.js";
 import { lowerForOfArrayIter, lowerForOfMap, lowerForOfSearchParams, lowerForOfSet, } from "./containers/for-of.js";
 import { lowerForOfHelperChain } from "./containers/iterator-helpers.js";
-import { objectIterOverIndexShape } from "./containers/indexed-objects.js";
+import { lowerRecordRestCaptureHelper, objectIterOverIndexShape, } from "./containers/indexed-objects.js";
 import { strCharsCall } from "./containers/array-construction.js";
 import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, genericAliasPresenceStore, genericBindingPresenceStore, genericBindingStoredValue, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, genericLocalClassBinding, } from "./generic-functions.js";
 import { bindingNeverReassigned, deadUnmappableBinding, fileWritesBinding, nullishExprUnitOf, nullishGenericBindingUnitOf, } from "./binding-analysis.js";
@@ -78,11 +84,11 @@ import { classForInHasKey, classPropertiesHelper } from "./class-dynamic-dispatc
 import { genericIfaceBindingKeepsClass, lowerClassStaticRead, staticReceiverClass, superConditionLead, } from "./lower-classes.js";
 import { lowerStreamUnderscoreAssign, streamClassAliasDecl, streamSidesOf, } from "./lower-stream.js";
 import { staticAssertInstanceDecl } from "./assert-instances.js";
-import { lowerHttpResPropertyAssignment, lowerHttpServerTimeoutAssignment, lowerNetServerMaxConnectionsAssignment, lowerServerCloseOverrideAssignment, } from "./lower-server.js";
+import { lowerHttpClientFnBindingDecl, lowerHttpResPropertyAssignment, lowerHttpServerTimeoutAssignment, lowerNetServerMaxConnectionsAssignment, lowerServerCloseOverrideAssignment, } from "./lower-server.js";
 import { lowerUrlAssignment } from "./builtins/url.js";
 import { isFspGlobCall, lowerFspGlobForAwait } from "./builtins/fs-glob.js";
 import { isTimersPromisesIntervalCall } from "./builtins/timers.js";
-import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireCalleeFileOf, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireProgramModuleOf, } from "./builtins/module-bindings.js";
+import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireCalleeFileOf, createRequireEvaluatedBaseOf, createRequireFactoryDecl, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireProgramModuleOf, } from "./builtins/module-bindings.js";
 import { lowerNodeModuleCall } from "./builtins/module-resolution.js";
 import { registerBuiltinCallableAlias } from "./builtins/callable-aliases.js";
 import { builtinClassAliasOwnsNoSlot, registerBuiltinClassAlias } from "./builtins/class-values.js";
@@ -1199,6 +1205,10 @@ function varBindingType(lowerer, nameNode) {
         !nameNode.parent.type &&
         isPromisePrototypeRead(lowerer, nameNode.parent.initializer))
         return DYN;
+    if (ts.isVariableDeclaration(nameNode.parent) &&
+        !nameNode.parent.type &&
+        isDataViewPrototypeRead(lowerer, nameNode.parent.initializer))
+        return DYN;
     let type = lowerer.mapTypeOf(lowerer.typeOf(nameNode));
     if (type?.kind === "record" && isJsSourceFile(ts.getSourceFileOfNode(nameNode))) {
         const shape = lowerer.shapes.get(type.shapeId);
@@ -1993,6 +2003,44 @@ function lowerVarDeclarator(lowerer, stmt, decl, isConst, isLet) {
                 const value = lowerer.lowerExpr(key);
                 lowerer.lowerBindingPattern(element.name, () => lowerer.lowerExpr(key), value.type, isLet, out);
             }
+            // `const { a, ...rest } = require("./m")`: Node copies the module's
+            // remaining own enumerable exports into a fresh object at the
+            // require, in the exports object's own key order. The table's
+            // statically known members are exactly those properties, each read
+            // from its export global into a dynamic object (the binding's own
+            // checker type is `any`, so this is its represented form).
+            for (const element of requireRestElementsOf(decl)) {
+                const dep = lowerer.cjsRequireRestTableOf(decl);
+                const names = dep === null ? null : cjsTableExportNamesInOrder(lowerer, dep);
+                if (dep === null || names === null) {
+                    lowerer.unsupported("SC1090", element, `the exports object of '${spec}' as a value (its exports do not form a static table)`);
+                }
+                const consumed = new Set();
+                for (const sib of element.parent.elements.nodes) {
+                    if (sib === element || sib.dotDotDotToken !== undefined || sib.name === undefined)
+                        continue;
+                    const keyNode = sib.propertyName ?? sib.name;
+                    if (!(ts.isIdentifier(keyNode) || ts.isStringLiteralLike(keyNode))) {
+                        lowerer.unsupported("SC1090", element, "rest bindings beside computed keys (the copied set is a runtime fact)");
+                    }
+                    consumed.add(keyNode.text);
+                }
+                const loc = locOf(element);
+                const fields = [];
+                for (const name of names) {
+                    if (consumed.has(name))
+                        continue;
+                    const value = cjsExportValueByName(lowerer, dep, name, element);
+                    if (value === null) {
+                        lowerer.unsupported("SC1090", element, `the exports object of '${spec}' as a value (its export '${name}' has no static value)`);
+                    }
+                    fields.push({
+                        key: strLit(name, loc),
+                        value: lowerer.coerceToExpected(value, DYN),
+                    });
+                }
+                lowerer.bindPatternTarget(element.name, { kind: "dynObjLit", fields, type: DYN, loc }, isLet, out);
+            }
             return out;
         }
         // A nested BUILTIN require (`get inFreeBSDJail() { const { execSync }
@@ -3342,6 +3390,16 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
             continue;
         }
         if (!fieldType) {
+            // A property only an ASSERTED intersection declares
+            // (`{ icons } = item as T & { icons?: unknown }`): the assertion is
+            // erased to the bound layout, which does not carry it, but the value
+            // Node destructures may. The read binds what the record can answer
+            // for the property, the type's undefined otherwise.
+            const missing = assertedOnlyFieldRead(lowerer, propName, srcType, srcRef, patternBindingType(lowerer, el.name), locOf(el));
+            if (missing !== null) {
+                lowerer.bindPatternTarget(el.name, el.initializer ? applyBindingDefault(lowerer, el, missing) : missing, isLet, out);
+                continue;
+            }
             // The pattern names a field the source SHAPE does not carry —
             // `for (let {x = 1} of [{}])` (signature 08): tsc types the binding
             // from the DEFAULT, and under JS the read is always undefined, so
@@ -3451,6 +3509,101 @@ function patternBindingType(lowerer, name) {
     return (lowerer.mapTypeOf(type) ??
         (isJsSourceFile(ts.getSourceFileOfNode(name)) ? dynFallbackType(lowerer, name, type) : null));
 }
+/** The value one element reads from a record shape for a property the
+ * shape does NOT declare: an asserted intersection (`item as T & {icons?:
+ * unknown}`) declares properties the assertion erases back to the bound
+ * layout, so the static shape is narrower than the value Node reads from.
+ *
+ * The value can still answer for the property: a checked conversion keeps
+ * the source's undeclared own properties beside the record
+ * (record-sources.ts), and a narrowed copy links to the record it came from
+ * (record-links.ts). Both are settled only at finalization, so the read is
+ * one interned `%rec.qfield.<n>(r)` per (source shape, key, binding type):
+ * its body starts as the type's static undefined and gains one `return` per
+ * answering surface then. A site the two mechanisms cannot answer keeps the
+ * static undefined, which is what Node binds for a value without the
+ * property.
+ *
+ * Null where the site keeps its existing lowering: a hybrid source already
+ * reads its overflow (`indexValue`), a name on `Object.prototype` is never
+ * an own property (Node reads the inherited value, which the static form's
+ * undefined does not reproduce), and a binding type that cannot hold
+ * undefined is the required-asserted-field representation gap (a slot that
+ * cannot hold the value Node would bind). */
+export function assertedOnlyFieldRead(lowerer, propName, srcType, srcRef, bodyT, loc) {
+    if (OBJECT_PROTOTYPE_KEYS.has(propName))
+        return null;
+    if (bodyT === null || bodyT.kind === "void")
+        return null;
+    const undefinedArmed = bodyT.kind === "union" && lowerer.armTag(bodyT.unionId, UNDEFINED_T) >= 0;
+    if (bodyT.kind !== "dyn" && !undefinedArmed)
+        return null;
+    const key = `qfield:${srcType.shapeId}:${propName}:${typeKey(bodyT)}`;
+    let name = lowerer.valueHelpers.get(key);
+    if (name === undefined) {
+        name = keyedHelperName(lowerer, "%rec.qfield", key);
+        lowerer.valueHelpers.set(key, name);
+        const recT = srcType;
+        const statics = bodyT.kind === "dyn"
+            ? dynUndefinedExpr(loc)
+            : (lowerer.wrappedUndefined(bodyT, loc) ?? dynUndefinedExpr(loc));
+        const fn = {
+            name,
+            params: [{ localId: "r.0", name: "r", type: recT }],
+            returnType: bodyT,
+            locals: [{ id: "r.0", name: "r", type: recT, mutable: false }],
+            body: [{ kind: "return", value: statics, loc }],
+            loc,
+        };
+        // `r.<key>` through the record's live view: the capsule of a record
+        // that kept a source starts from that view (scr_dyn.h's
+        // scr_record_source_view), and a composed linked copy declares the key.
+        const viewRead = (value) => {
+            const got = {
+                kind: "dynKeyGet",
+                value: { kind: "dynFrom", value, liveRef: true, type: DYN, loc },
+                key: { kind: "strLit", value: propName, type: STRING, loc },
+                type: DYN,
+                loc,
+            };
+            return bodyT.kind === "dyn" ? got : { kind: "dynCheck", value: got, type: bodyT, loc };
+        };
+        const receiver = varRef("r.0", recT, loc);
+        lowerer.linkedHelperFinalizers.push((sourced) => {
+            // Links first: answerLinkedCopies prepends, and a kept source is
+            // tested on the record itself, before any composed copy.
+            answerLinkedCopies(lowerer, fn, srcType.shapeId, (composed) => [
+                { kind: "return", value: viewRead(composed), loc },
+            ]);
+            if (sourced.has(srcType.shapeId))
+                fn.body = [
+                    {
+                        kind: "if",
+                        cond: recordSourceTest(receiver, loc),
+                        then: [{ kind: "return", value: viewRead(receiver), loc }],
+                        else_: null,
+                        loc,
+                    },
+                    ...fn.body,
+                ];
+        });
+        registerLinkedHelper(lowerer, fn, srcType.shapeId, "custom");
+        lowerer.liftedFns.push(fn);
+    }
+    return { kind: "call", callee: name, args: [srcRef()], type: bodyT, loc };
+}
+const INTEGER_LIKE_KEY = /^(0|[1-9][0-9]{0,9})$/;
+/** A declared integer-like field name in a rest copy's own frame: JS orders
+ * integer-like own keys first, ACROSS the declared and overflow stores, so a
+ * reshape that walks the declared fields before the source's overflow cannot
+ * reproduce Node's key order (the rule Object.keys' index-shape lowering
+ * already fences on). Callers use it only where the site fenced before the
+ * rest capture existed. */
+function fenceIntegerKeyRest(lowerer, blame, fields) {
+    if (!fields.some((f) => INTEGER_LIKE_KEY.test(f.name) && Number(f.name) <= 4294967294))
+        return;
+    lowerer.unsupported("SC1031", blame, "rest bindings over index-signature sources that declare an integer-like field name (JS orders integer keys first, across the declared and overflow keys)");
+}
 /** `const { a, b: c } = ns` / `const { f } = await import("./m")` over
  * a program module's namespace: each element reads the export exactly
  * like `ns.a` does — the member resolves to the exporter's own binding
@@ -3593,7 +3746,7 @@ function unionObjectRestValue(lowerer, el, srcRef, srcType, arms) {
             fence(`rest bindings over union sources (${NARROW_FIRST})`);
         }
         const shape = lowerer.shapes.get(arm.shapeId);
-        if (!shape || shape.indexValue) {
+        if (!shape) {
             fence("rest bindings over index-signature shapes (the undeclared entries would need overflow packing)");
         }
         const rem = shape.fields.filter((f) => !consumed.has(f.name));
@@ -3608,25 +3761,46 @@ function unionObjectRestValue(lowerer, el, srcRef, srcType, arms) {
             type: arm,
             loc,
         };
-        const packed = lowerer.keyOrder.copy({
-            kind: "recordLit",
-            fields: rem.map((f) => ({
-                name: f.name,
-                value: lowerer.presenceKeepingCopy(armRef, arm.shapeId, f.name, {
-                    kind: "recordGet",
-                    obj: armRef,
-                    shapeId: arm.shapeId,
-                    field: f.name,
-                    type: f.type,
-                    loc,
-                }, loc),
-            })),
-            type: {
-                kind: "record",
-                shapeId: lowerer.shapes.intern(rem.map((f) => ({ name: f.name, type: f.type }))),
-            },
-            loc,
-        }, arm.shapeId);
+        // An INDEX-SIGNATURE arm packs through the same `%rec.rest` capture
+        // reshape the single-shape path uses, into the arm's source-derived
+        // hybrid (its remaining declared fields plus its own overflow slot).
+        let packed;
+        if (shape.indexValue !== undefined) {
+            fenceIntegerKeyRest(lowerer, el, rem);
+            const derivedId = lowerer.shapes.intern(rem.map((f) => ({ ...f })), false, shape.indexValue, (shape.declaredOrder ?? shape.fields.map((f) => f.name)).filter((n) => rem.some((f) => f.name === n)));
+            const helper = lowerRecordRestCaptureHelper(lowerer, arm.shapeId, derivedId, [...consumed], loc);
+            if (helper === null) {
+                fence("rest bindings over index-signature shapes (the undeclared entries would need overflow packing)");
+            }
+            packed = {
+                kind: "call",
+                callee: helper,
+                args: [armRef],
+                type: { kind: "record", shapeId: derivedId },
+                loc,
+            };
+        }
+        else {
+            packed = lowerer.keyOrder.copy({
+                kind: "recordLit",
+                fields: rem.map((f) => ({
+                    name: f.name,
+                    value: lowerer.presenceKeepingCopy(armRef, arm.shapeId, f.name, {
+                        kind: "recordGet",
+                        obj: armRef,
+                        shapeId: arm.shapeId,
+                        field: f.name,
+                        type: f.type,
+                        loc,
+                    }, loc, f),
+                })),
+                type: {
+                    kind: "record",
+                    shapeId: lowerer.shapes.intern(rem.map((f) => ({ ...f }))),
+                },
+                loc,
+            }, arm.shapeId);
+        }
         const coerced = lowerer.coerceInto(el, packed, restT);
         if (!typeEquals(coerced.type, restT)) {
             fence(`rest bindings over union sources (the remaining fields of an arm do not spell an arm of '${lowerer.fmt(restT)}')`);
@@ -4510,11 +4684,30 @@ function tupleTailValue(lowerer, blame, srcRef, srcType, shape, from, restT) {
  * copies out of the source at destructure time (JS's CopyDataProperties
  * is a fresh object of copied values too, so mutations through the rest
  * binding never reach the source — and records have no getters to make
- * the copy observable). Index-signature rest types keep a named fence:
- * their entries would need overflow packing, not field reads. */
+ * the copy observable). An INDEX-SIGNATURE source or rest type takes the
+ * interned `%rec.rest` capture reshape with the pattern's literal keys as
+ * its exclusion set (lowerRecordRestCaptureHelper), which enumerates the
+ * source's remaining declared fields and overflow entries exactly as the
+ * source's own Object.keys does. A rest type that is CLOSED over such a
+ * source keeps a named fence: the undeclared entries have no slot. */
 function objectRestValue(lowerer, el, srcRef, srcType, shape) {
     const loc = locOf(el);
     const restT = patternBindingType(lowerer, el.name); // callers skip nameless elisions
+    // The consumed set is the pattern's literal sibling keys: a computed
+    // sibling would make it a runtime fact and fences.
+    const consumed = new Set();
+    let computedSibling = false;
+    if (ts.isObjectBindingPattern(el.parent)) {
+        for (const sib of el.parent.elements.nodes) {
+            if (sib === el || sib.dotDotDotToken)
+                continue;
+            const key = sib.propertyName ?? sib.name;
+            if (key && ts.isComputedPropertyName(key))
+                computedSibling = true;
+            else if (key && (ts.isIdentifier(key) || ts.isStringLiteral(key) || ts.isNumericLiteral(key)))
+                consumed.add(key.text);
+        }
+    }
     // A DYN rest type is the top-type spelling (`const { ...rest } = src`
     // where the checker's rest type is `{}` — every field consumed, or the
     // empty-source `const { ...empty } = {}`): CopyDataProperties still
@@ -4523,27 +4716,30 @@ function objectRestValue(lowerer, el, srcRef, srcType, shape) {
     // binding. Computed sibling keys would make the consumed set a runtime
     // fact, and reserved accessor slots are closures, not data — both fence.
     if (restT?.kind === "dyn") {
-        const pattern = el.parent;
-        const consumed = new Set();
-        let computedSibling = false;
-        if (ts.isObjectBindingPattern(pattern)) {
-            for (const sib of pattern.elements.nodes) {
-                if (sib === el || sib.dotDotDotToken)
-                    continue;
-                const key = sib.propertyName ?? sib.name;
-                if (key && ts.isComputedPropertyName(key))
-                    computedSibling = true;
-                else if (key &&
-                    (ts.isIdentifier(key) || ts.isStringLiteral(key) || ts.isNumericLiteral(key)))
-                    consumed.add(key.text);
-            }
-        }
         const rem = shape.fields.filter((f) => !consumed.has(f.name));
-        if (computedSibling || shape.indexValue || rem.some((f) => f.name.startsWith("%"))) {
+        if (computedSibling || rem.some((f) => f.name.startsWith("%"))) {
             lowerer.unsupported("SC1031", el, computedSibling
                 ? "rest bindings beside computed keys (the consumed set is a runtime fact)"
                 : "rest bindings over index-signature or accessor shapes (the entries would need overflow packing)");
         }
+        // An INDEX-SIGNATURE source packs into the source-derived hybrid (the
+        // remaining declared fields plus the source's own overflow slot), so
+        // the undeclared entries survive the copy.
+        if (shape.indexValue !== undefined) {
+            fenceIntegerKeyRest(lowerer, el, rem);
+            const derivedId = lowerer.shapes.intern(rem.map((f) => ({ ...f })), false, shape.indexValue, (shape.declaredOrder ?? shape.fields.map((f) => f.name)).filter((n) => rem.some((f) => f.name === n)));
+            const helper = lowerRecordRestCaptureHelper(lowerer, srcType.shapeId, derivedId, [...consumed], loc);
+            if (helper !== null) {
+                return lowerer.coerceInto(el, {
+                    kind: "call",
+                    callee: helper,
+                    args: [srcRef()],
+                    type: { kind: "record", shapeId: derivedId },
+                    loc,
+                }, DYN);
+            }
+            lowerer.unsupported("SC1031", el, "rest bindings over index-signature or accessor shapes (the entries would need overflow packing)");
+        }
         const packed = {
             kind: "recordLit",
             fields: rem.map((f) => ({
@@ -4555,11 +4751,11 @@ function objectRestValue(lowerer, el, srcRef, srcType, shape) {
                     field: f.name,
                     type: f.type,
                     loc,
-                }, loc),
+                }, loc, f),
             })),
             type: {
                 kind: "record",
-                shapeId: lowerer.shapes.intern(rem.map((f) => ({ name: f.name, type: f.type }))),
+                shapeId: lowerer.shapes.intern(rem.map((f) => ({ ...f }))),
             },
             loc,
         };
@@ -4573,8 +4769,27 @@ function objectRestValue(lowerer, el, srcRef, srcType, shape) {
     const restShape = lowerer.shapes.get(restT.shapeId);
     if (!restShape)
         throw new InternalCompilerError(`lowerer bug: rest binding over unknown shape ${restT.shapeId}`);
-    if (restShape.indexValue || shape.indexValue) {
-        lowerer.unsupported("SC1031", el, "rest bindings over index-signature shapes (the undeclared entries would need overflow packing)");
+    if (restShape.indexValue !== undefined || shape.indexValue !== undefined) {
+        // An INDEX-SIGNATURE source or rest type: the capture reshape with the
+        // pattern's literal keys excluded. A CLOSED rest type over a source
+        // with an overflow slot has nowhere to put the undeclared entries.
+        if (computedSibling) {
+            lowerer.unsupported("SC1031", el, "rest bindings beside computed keys (the consumed set is a runtime fact)");
+        }
+        fenceIntegerKeyRest(lowerer, el, restShape.fields);
+        // Reserved accessor slots are closures, not data: the reshape copies
+        // declared values, and JS's copy would call the getters.
+        if (shape.fields.some((f) => f.name.startsWith("%"))) {
+            lowerer.unsupported("SC1031", el, "rest bindings over accessor shapes (the entries are closures, not data)");
+        }
+        if (restShape.indexValue === undefined) {
+            lowerer.unsupported("SC1031", el, `rest bindings packing an index-signature source into the closed rest type '${lowerer.fmt(restT)}' (its undeclared keys have no slot)`);
+        }
+        const helper = lowerRecordRestCaptureHelper(lowerer, srcType.shapeId, restT.shapeId, [...consumed], loc);
+        if (helper === null) {
+            lowerer.unsupported("SC1031", el, "rest bindings over index-signature shapes (the undeclared entries would need overflow packing)");
+        }
+        return { kind: "call", callee: helper, args: [srcRef()], type: restT, loc };
     }
     const fields = restShape.fields.map((f) => {
         const srcField = shape.fields.find((s) => s.name === f.name);
@@ -4591,7 +4806,7 @@ function objectRestValue(lowerer, el, srcRef, srcType, shape) {
         };
         return {
             name: f.name,
-            value: lowerer.presenceKeepingCopy(srcRef(), srcType.shapeId, srcField.name, lowerer.coerceInto(el, read, f.type), loc),
+            value: lowerer.presenceKeepingCopy(srcRef(), srcType.shapeId, srcField.name, lowerer.coerceInto(el, read, f.type), loc, f),
         };
     });
     return lowerer.keyOrder.copy({ kind: "recordLit", fields, type: restT, loc }, srcType.shapeId);
@@ -5302,6 +5517,12 @@ export function lowerVarDecl(lowerer, decl, isLet) {
                 ts.getModifiers(s)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) === true))) {
         lowerer.unsupported("SC1090", decl.name, `initializer-less top-level declarations named '${decl.name.text}' in an import/export-free file (Node hosts the file as CommonJS, where the wrapper's own binding keeps its value — the declaration reads as the module object there, which has no lowering; rename the variable or give it an initializer)`);
     }
+    // `const requestFn = cond ? https.request : http.request`: calls through
+    // the binding lower as the runtime-secure client. A condition that is not
+    // a stable identifier read is evaluated once, here, into a hidden bool.
+    const clientFnDecl = lowerHttpClientFnBindingDecl(lowerer, decl);
+    if (clientFnDecl !== false)
+        return clientFnDecl;
     // `const asyncFn = promisify(supportedBuiltin)`: the binding registers
     // a static callable projection; calls route to the target's promise
     // lowering and the declaration emits no runtime slot.
@@ -5316,8 +5537,20 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // `const require = createRequire(import.meta.url)` — compile-time
     // plumbing: each call through the binding resolves per site
     // (lowerCreateRequireCall); no storage, no code (collectGlobals
-    // skipped its global by the same test).
-    if (createRequireBindingDecl(lowerer, decl.name, decl.initializer))
+    // skipped its global by the same test). A RUN-TIME base is still
+    // evaluated here, as Node evaluates it at the declaration: its side
+    // effects happen and its throws unwind the module, even though the
+    // loader value stays the deferred fence.
+    if (createRequireBindingDecl(lowerer, decl.name, decl.initializer)) {
+        const base = createRequireEvaluatedBaseOf(lowerer, decl.initializer);
+        return base === null
+            ? null
+            : { kind: "exprStmt", expr: lowerer.lowerExpr(base), loc: locOf(base) };
+    }
+    // `const { createRequire: cr } = require("node:module")` — the factory
+    // binding is the same compile-time plumbing (its calls take the
+    // run-time-base fence; createRequireFactoryBinding).
+    if (createRequireFactoryDecl(lowerer, decl.name, decl.initializer))
         return null;
     // `const fs = require("node:fs")` through that binding — a builtin
     // namespace import in const clothing: alias plumbing, no storage
@@ -5682,6 +5915,13 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // Promise.prototype is an ordinary object the checker types Promise<any>.
     if (!decl.type && !hasJsTypeAnnotation(decl) && isPromisePrototypeRead(lowerer, decl.initializer))
         type = DYN;
+    // DataView.prototype (and its members) is likewise the prototype OBJECT,
+    // though the checker types it DataView, whose lowering is a bytes view:
+    // the binding holds the object the read lowered to.
+    if (!decl.type &&
+        !hasJsTypeAnnotation(decl) &&
+        isDataViewPrototypeRead(lowerer, decl.initializer))
+        type = DYN;
     // A web stream value in JavaScript keeps its checked-dynamic identity.
     if (init.type.kind === "dyn" &&
         !decl.type &&
@@ -6884,58 +7124,6 @@ export function lowerTry(lowerer, stmt) {
         loc: locOf(stmt),
     };
 }
-/** The refusal for `delete` of an optional `unknown`/`any` field, whose
- * slot is the checked-dynamic one and so has no ABSENT state to write. */
-const OPTIONAL_CHECKED_DYN_DELETE = "'delete' of optional 'unknown'/'any' fields (the checked-dynamic slot has no absent state yet — an omitted such field already reads as present)";
-/** TypeScript's declaration marks property `name` of `receiver` optional
- * (`?:`), in every union constituent. A mapped IR type cannot tell an
- * optional `unknown`/`any` field from a required one — both ride the
- * checked-dynamic slot — so a refused `delete`'s real reason comes from
- * the declaration. */
-function declaredOptionalProperty(lowerer, receiver, name) {
-    const receiverType = lowerer.typeOf(receiver);
-    const parts = receiverType.flags & ts.TypeFlags.Union ? constituentTypes(receiverType) : [receiverType];
-    return parts.every((part) => {
-        const property = lowerer.checker.getPropertyOfType(part, name);
-        return property !== undefined && (property.flags & ts.SymbolFlags.Optional) !== 0;
-    });
-}
-/** `type` — a record or a union whose every arm is a non-tuple record —
- * declares `name` in the checked-dynamic slot, which has no ABSENT state:
- * an optional such field cannot be removed by a `delete`. */
-function declaresCheckedDynField(lowerer, type, name) {
-    if (type.kind === "record") {
-        const shape = lowerer.shapes.get(type.shapeId);
-        if (!shape || shape.tuple)
-            return false;
-        return shape.fields.find((f) => f.name === name)?.type.kind === "dyn";
-    }
-    if (type.kind !== "union")
-        return false;
-    const arms = lowerer.unions.get(type.unionId)?.arms ?? [];
-    return arms.length > 0 && arms.every((arm) => declaresCheckedDynField(lowerer, arm, name));
-}
-/** The constant property key of a `delete` target: the name of a dot
- * access, or the one key of a bracket access spelled as a literal or
- * proved by a literal-typed binding (`const key = "a"`). A key of several
- * literals folds to nothing — deleting it would need per-key dispatch, so
- * the record branch refuses and names the keys. Consistent with keyed
- * record reads/writes (literalFieldKeys), the key expression is not
- * evaluated: only a literal or an identifier folds, and an identifier
- * read is pure. */
-function constantDeleteKey(lowerer, target) {
-    if (ts.isPropertyAccessExpression(target))
-        return target.name.text;
-    if (!ts.isElementAccessExpression(target))
-        return null;
-    const keyNode = target.argumentExpression;
-    if (ts.isStringLiteralLike(keyNode))
-        return keyNode.text;
-    if (!ts.isIdentifier(keyNode))
-        return null;
-    const keys = literalFieldKeys(lowerer, keyNode);
-    return keys?.length === 1 ? keys[0] : null;
-}
 /** Statement-position `delete`: process.env keys → process.envUnset
  * (unsetenv), pure `Record<string, T>` keys → recordKeyDelete (the
  * overflow Map delete), declared OPTIONAL fields → the field's ABSENT
@@ -6977,24 +7165,13 @@ function lowerDeleteStatement(lowerer, expr) {
             loc,
         };
     const lowerKey = () => {
-        if (ts.isPropertyAccessExpression(target)) {
-            return { kind: "strLit", value: target.name.text, type: STRING, loc: locOf(target.name) };
-        }
+        if (ts.isPropertyAccessExpression(target))
+            return lowerDeleteKey(lowerer, target);
         const keyNode = target.argumentExpression;
-        let key = lowerer.isProcessEnv(target.expression) ||
+        return lowerer.isProcessEnv(target.expression) ||
             heldEnvValueType(lowerer, target.expression) !== null
             ? lowerEnvironmentKey(lowerer, keyNode)
-            : lowerer.lowerExpr(keyNode);
-        if (key.type.kind === "dyn") {
-            key = { kind: "libCall", fn: "dyn.toStringCoerce", args: [key], type: STRING, loc: key.loc };
-        }
-        if (lowerer.runtimeOptionalWidening(key.type, STRING) !== null) {
-            key = lowerer.ensureString(key, keyNode);
-        }
-        if (key.type.kind !== "string") {
-            lowerer.unsupported("SC1090", keyNode, `'delete' with '${lowerer.fmt(key.type)}' keys (index-signature and env keys are strings)`);
-        }
-        return key;
+            : lowerDeleteComputedKey(lowerer, keyNode);
     };
     if (lowerer.isProcessEnv(target.expression) ||
         heldEnvValueType(lowerer, target.expression) !== null) {
@@ -7013,7 +7190,17 @@ function lowerDeleteStatement(lowerer, expr) {
         if (unionDelete)
             return unionDelete;
     }
-    let obj = lowerer.lowerExpr(target.expression);
+    // A delete through a chain of type assertions addresses the operand the
+    // assertions erase to (`(o as View).k` names `o`): the asserted view's
+    // conversion may build a copying width record, and the delete would land
+    // on that temporary. Delete in place from the operand when its own stored
+    // layout holds the member as a deletable slot; a view that names a member
+    // the layout does not hold has nothing to delete, so refuse by name.
+    const erased = erasedDeletePlan(lowerer, target);
+    if (erased !== null && "refuse" in erased) {
+        lowerer.unsupported("SC1090", target, erased.refuse);
+    }
+    let obj = lowerer.lowerExpr(erased !== null && "operand" in erased ? erased.operand : target.expression);
     // A PRIMITIVE receiver: `delete` runs ToObject on the base AFTER the key,
     // and the base's type decides the answer — null and undefined throw
     // Node's TypeError, `?.` on a nullish base short-circuits to `true`
@@ -7068,11 +7255,43 @@ function lowerDeleteStatement(lowerer, expr) {
             };
         }
     }
-    if (isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
-        obj.type.kind === "func" &&
-        lowerer.dynConvertible(obj.type)) {
+    if (obj.type.kind === "func" &&
+        lowerer.dynConvertible(obj.type) &&
+        (isJsSourceFile(ts.getSourceFileOfNode(expr)) || callableDeleteKey(lowerer, target))) {
         obj = lowerer.coerceToExpected(obj, DYN);
     }
+    // A typed handle in a program that adds properties to handles: the
+    // delete removes an entry of its property table (scr_dyn_handle_props.c).
+    {
+        const boxed = boxedHandleReceiver(lowerer, obj);
+        if (boxed) {
+            const strict = { kind: "boolLit", value: isStrictCode(expr), type: BOOL, loc };
+            if (ts.isElementAccessExpression(target)) {
+                return {
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "libCall",
+                        fn: "dyn.keyDeleteComputed",
+                        args: [boxed, lowerer.lowerExprExpecting(target.argumentExpression, DYN), strict],
+                        type: VOID,
+                        loc,
+                    },
+                    loc,
+                };
+            }
+            return {
+                kind: "exprStmt",
+                expr: {
+                    kind: "libCall",
+                    fn: "dyn.keyDelete",
+                    args: [boxed, lowerKey(), strict],
+                    type: VOID,
+                    loc,
+                },
+                loc,
+            };
+        }
+    }
     if (obj.type.kind === "dyn") {
         const strict = { kind: "boolLit", value: isStrictCode(expr), type: BOOL, loc };
         if (ts.isElementAccessExpression(target)) {
@@ -7107,59 +7326,8 @@ function lowerDeleteStatement(lowerer, expr) {
     // read/write takes (literalFieldKeys): identifier evaluation is pure, so
     // skipping it matches JavaScript.
     const constantKey = constantDeleteKey(lowerer, target);
-    // An OPTIONAL `unknown`/`any` field rides the checked-dynamic slot,
-    // which has no ABSENT state yet (an omitted such field already reads as
-    // present), so it cannot delete. Name that reason instead of calling
-    // the field required or blaming the receiver.
-    const optionalCheckedDynDelete = constantKey !== null &&
-        declaresCheckedDynField(lowerer, obj.type, constantKey) &&
-        declaredOptionalProperty(lowerer, target.expression, constantKey);
     if (obj.type.kind === "record") {
-        const shape = lowerer.shapes.get(obj.type.shapeId);
-        if (shape?.indexValue && shape.fields.length === 0 && !shape.tuple) {
-            return markSloppyRecordWrites(lowerer, { kind: "recordKeyDelete", obj, shapeId: obj.type.shapeId, key: lowerKey(), loc }, expr);
-        }
-        // `delete r.f` of a declared OPTIONAL field (undefined-armed slot)
-        // writes the field's ABSENT state: a monomorphic shape cannot remove
-        // its slot, but the slot remembers that no property exists, so `in`
-        // answers false, Object.keys skips it, and JSON.stringify drops it,
-        // while a later write makes it present again. Constant keys only
-        // (dot access or a literal bracket); required fields keep the honest
-        // fence below.
-        const field = constantKey !== null && !shape?.tuple
-            ? shape?.fields.find((f) => f.name === constantKey)
-            : undefined;
-        if (field) {
-            const absent = lowerer.absentFieldValue(field.type, loc);
-            if (absent) {
-                return markSloppyRecordWrites(lowerer, {
-                    kind: "recordSet",
-                    obj,
-                    shapeId: obj.type.shapeId,
-                    field: field.name,
-                    value: absent,
-                    loc,
-                }, expr, true);
-            }
-        }
-        if (shape?.indexValue) {
-            lowerer.unsupported("SC1090", expr, "'delete' of hybrid index-signature keys (declared struct slots and overflow entries answer differently — model deletable dynamic keys with a pure Record<string, T>)");
-        }
-        if (optionalCheckedDynDelete) {
-            lowerer.unsupported("SC1090", expr, OPTIONAL_CHECKED_DYN_DELETE);
-        }
-        // A key of SEVERAL literals names no single slot: say that instead of
-        // blaming a field the caller never named.
-        const keyNames = constantKey === null && ts.isElementAccessExpression(target)
-            ? literalFieldKeys(lowerer, target.argumentExpression)
-            : null;
-        if (keyNames !== null && keyNames.length > 1) {
-            lowerer.unsupported("SC1090", expr, `'delete' through keys of ${keyNames.length} literals (${keyNames.map((k) => `'${k}'`).join(", ")}; delete one constant key at a time, or switch over the key)`);
-        }
-        lowerer.unsupported("SC1090", expr, "'delete' of required record fields (the shape's slot cannot be removed — only an optional field (`f?: T`) has an absent state, which Object.keys, 'in', and JSON.stringify follow; make the field optional if the program must remove it)");
-    }
-    if (optionalCheckedDynDelete) {
-        lowerer.unsupported("SC1090", expr, OPTIONAL_CHECKED_DYN_DELETE);
+        return lowerRecordMemberDelete(lowerer, expr, target, obj, lowerKey);
     }
     // A class field lives in the instance's fixed layout: there is no
     // per-field presence state for a delete to write, so Object.keys,
@@ -7857,14 +8025,11 @@ export function lowerExprStatement(lowerer, expr) {
             if (callableWrite)
                 return { kind: "exprStmt", expr: callableWrite, loc: locOf(expr) };
             // Expando function members (`foo.bar = 12`, `foo[SYM] = v` on a
-            // module-level function/callable const): the member's module
-            // global (lower-expando.ts) — claimed by symbol identity before
-            // any receiver-shape path.
-            {
-                const ex = lowerExpandoAssignStmt(lowerer, expr);
-                if (ex)
-                    return ex;
-            }
+            // module-level function/callable const): the write is the closure's
+            // own-property table store, like any other callable member; the
+            // read-only function members keep their fault fence.
+            if (ts.isPropertyAccessExpression(expr.left) || ts.isElementAccessExpression(expr.left))
+                fenceReadonlyExpandoWrite(lowerer, expr.left);
             {
                 const dereferenced = lowerDereferencedElementWrite(lowerer, expr);
                 if (dereferenced)
@@ -8210,6 +8375,12 @@ export function lowerExprStatement(lowerer, expr) {
                 const unionWrite = lowerUnionFieldWrite(lowerer, expr.left, expr.right);
                 if (unionWrite)
                     return { kind: "exprStmt", expr: unionWrite, loc: locOf(expr) };
+                // A member only the asserted type declares is refused before any
+                // field target: the checker's type names a slot the stored record
+                // does not have, so a target built from it addresses a field the
+                // receiver's shape lacks. `(view).member` and `view!.member` reach
+                // the same refusal as `view.member`.
+                assertedOnlyMemberWrite(lowerer, expr.left.expression, expr.left.name.text, expr.left);
                 const target = lowerer.fieldTarget(expr.left);
                 if (target) {
                     const value = lowerer.lowerExprExpecting(expr.right, target.fieldType);
@@ -8250,6 +8421,18 @@ export function lowerExprStatement(lowerer, expr) {
                     }
                     if (recv?.type.kind === "child" && isJsSourceFile(ts.getSourceFileOfNode(expr)))
                         return lowerChildPropertyWrite(lowerer, recv, expr.left, expr.right, locOf(expr));
+                    // `m.label = 1` over a typed handle in JavaScript: an undeclared
+                    // member name is a property table entry, and so is a member name
+                    // the program shadows (scr_dyn_handle_props.c). The grant query
+                    // (a whole-program census) waits for a handle-typed receiver.
+                    if (!lowerer.checker.getPropertyOfType(lowerer.typeOf(expr.left.expression), expr.left.name.text) ||
+                        (recv !== null &&
+                            TYPED_HANDLE_KINDS.has(recv.type.kind) &&
+                            handleMemberGranted(lowerer, expr.left.expression, expr.left.name.text))) {
+                        const boxed = boxedHandleReceiver(lowerer, recv);
+                        if (boxed)
+                            return lowerHandlePropertyWrite(lowerer, boxed, { kind: "strLit", value: expr.left.name.text, type: STRING, loc: locOf(expr) }, expr.right, locOf(expr));
+                    }
                     // `err.code = v` on an Error value (`err as Error & { code?:
                     // string }`): typed reads come from the runtime error's code
                     // slot, so the write lands there. A value that is not statically
@@ -8454,12 +8637,10 @@ export function lowerExprStatement(lowerer, expr) {
             if (ts.isPropertyAccessExpression(expr.left)) {
                 // `N.x += v` — the namespace-qualified spelling of a module-
                 // global compound assign (nsWritableTarget resolves the member's
-                // global; everything else keeps the field path). Expando
-                // function members (`foo.count += 1`) are module globals too.
+                // global; everything else keeps the field path). Expando function
+                // members (`foo.count += 1`) are callable-member table data.
                 if (!expr.left.questionDotToken) {
-                    const exT = expandoWritableTarget(lowerer, expr.left);
-                    if (exT)
-                        return lowerCompoundToTarget(lowerer, expr, compound, exT);
+                    fenceReadonlyExpandoWrite(lowerer, expr.left);
                     const nsT = nsWritableTarget(lowerer, expr.left);
                     if (nsT)
                         return lowerCompoundToTarget(lowerer, expr, compound, nsT);
@@ -8485,9 +8666,11 @@ export function lowerExprStatement(lowerer, expr) {
         if (ts.isPropertyAccessExpression(expr.operand) || ts.isElementAccessExpression(expr.operand)) {
             fenceDatePrototypeWrite(lowerer, expr.operand);
             // Statement and value positions share ToNumeric and reference order.
-            // Namespace/expando globals retain their direct binding path below.
+            // Namespace globals retain their direct binding path below.
+            if (ts.isPropertyAccessExpression(expr.operand))
+                fenceReadonlyExpandoWrite(lowerer, expr.operand);
             const binding = ts.isPropertyAccessExpression(expr.operand)
-                ? (expandoWritableTarget(lowerer, expr.operand) ?? nsWritableTarget(lowerer, expr.operand))
+                ? nsWritableTarget(lowerer, expr.operand)
                 : null;
             if (binding)
                 return lowerIncDecToTarget(lowerer, expr, binding);
@@ -9196,51 +9379,102 @@ function destructuringAssignInto(lowerer, target, init, rhs, blame, loc) {
             let restTo = prop.expression;
             while (ts.isParenthesizedExpression(restTo))
                 restTo = restTo.expression;
-            if (shape.indexValue) {
-                lowerer.unsupported("SC1031", prop, "rest bindings over index-signature shapes (the undeclared entries would need overflow packing)");
-            }
             const consumed = new Set();
+            let computedSibling = false;
             for (const p of target.properties.nodes) {
+                if (p === prop)
+                    continue;
                 if (ts.isShorthandPropertyAssignment(p))
                     consumed.add(p.name.text);
                 else if (ts.isPropertyAssignment(p)) {
                     const n = patternKeyNameOf(lowerer, p.name);
                     if (n !== null)
                         consumed.add(n);
+                    else if (ts.isComputedPropertyName(p.name))
+                        computedSibling = true;
                 }
             }
             const remaining = shape.fields.filter((f) => !consumed.has(f.name));
             const restOrder = shape.declaredOrder?.filter((n) => !consumed.has(n));
-            const restShapeId = lowerer.shapes.intern(remaining.map((f) => ({ name: f.name, type: f.type })), false, undefined, restOrder);
-            if (restOrder !== undefined) {
-                lowerer.shapeOrderMetadataFinalizers.push(lowerer.shapes.declaredOrderFinalizer(restShapeId, restOrder, () => lowerer.shapes.get(srcType.shapeId)?.declaredOrder?.filter((n) => !consumed.has(n))));
+            let packed;
+            if (shape.indexValue !== undefined) {
+                // An INDEX-SIGNATURE source: the `%rec.rest` capture reshape into
+                // the source-derived hybrid (its remaining declared fields plus its
+                // own overflow slot), exactly the destructuring form's copy.
+                if (computedSibling) {
+                    lowerer.unsupported("SC1031", prop, "rest bindings beside computed keys (the consumed set is a runtime fact)");
+                }
+                if (remaining.some((f) => f.name.startsWith("%"))) {
+                    lowerer.unsupported("SC1031", prop, "rest bindings over accessor shapes (the entries are closures, not data)");
+                }
+                fenceIntegerKeyRest(lowerer, prop, remaining);
+                const derivedId = lowerer.shapes.intern(remaining.map((f) => ({ ...f })), false, shape.indexValue, restOrder);
+                if (restOrder !== undefined) {
+                    lowerer.shapeOrderMetadataFinalizers.push(lowerer.shapes.declaredOrderFinalizer(derivedId, restOrder, () => lowerer.shapes
+                        .get(srcType.shapeId)
+                        ?.declaredOrder?.filter((n) => !consumed.has(n) && remaining.some((f) => f.name === n))));
+                }
+                const helper = lowerRecordRestCaptureHelper(lowerer, srcType.shapeId, derivedId, [...consumed], locOf(prop));
+                if (helper === null) {
+                    lowerer.unsupported("SC1031", prop, "rest bindings over index-signature shapes (the undeclared entries would need overflow packing)");
+                }
+                packed = {
+                    kind: "call",
+                    callee: helper,
+                    args: [{ kind: "varRef", localId: tmp.id, type: srcType, loc: locOf(prop) }],
+                    type: { kind: "record", shapeId: derivedId },
+                    loc: locOf(prop),
+                };
             }
-            const packed = lowerer.keyOrder.copy({
-                kind: "recordLit",
-                fields: remaining.map((f) => ({
-                    name: f.name,
-                    value: {
-                        kind: "recordGet",
-                        obj: { kind: "varRef", localId: tmp.id, type: srcType, loc: locOf(prop) },
-                        shapeId: srcType.shapeId,
-                        field: f.name,
-                        type: f.type,
-                        loc: locOf(prop),
-                    },
-                })),
-                type: { kind: "record", shapeId: restShapeId },
-                loc: locOf(prop),
-            }, srcType.shapeId);
+            else {
+                const restShapeId = lowerer.shapes.intern(remaining.map((f) => ({ ...f })), false, undefined, restOrder);
+                if (restOrder !== undefined) {
+                    lowerer.shapeOrderMetadataFinalizers.push(lowerer.shapes.declaredOrderFinalizer(restShapeId, restOrder, () => lowerer.shapes.get(srcType.shapeId)?.declaredOrder?.filter((n) => !consumed.has(n))));
+                }
+                packed = lowerer.keyOrder.copy({
+                    kind: "recordLit",
+                    fields: remaining.map((f) => ({
+                        name: f.name,
+                        // A field the source lacks keeps the rest copy absent too.
+                        value: lowerer.presenceKeepingCopy({ kind: "varRef", localId: tmp.id, type: srcType, loc: locOf(prop) }, srcType.shapeId, f.name, {
+                            kind: "recordGet",
+                            obj: { kind: "varRef", localId: tmp.id, type: srcType, loc: locOf(prop) },
+                            shapeId: srcType.shapeId,
+                            field: f.name,
+                            type: f.type,
+                            loc: locOf(prop),
+                        }, locOf(prop), f),
+                    })),
+                    type: { kind: "record", shapeId: restShapeId },
+                    loc: locOf(prop),
+                }, srcType.shapeId);
+            }
+            /** A CLOSED rest target has nowhere to put the source's undeclared
+             * entries; refuse rather than let the coercion drop them. */
+            const checkRestTarget = (targetT) => {
+                if (shape.indexValue === undefined || targetT === null)
+                    return;
+                if (targetT.kind === "dyn")
+                    return;
+                if (targetT.kind === "record" &&
+                    lowerer.shapes.get(targetT.shapeId)?.indexValue !== undefined)
+                    return;
+                lowerer.unsupported("SC1031", prop, `rest assignments packing an index-signature source into '${lowerer.fmt(targetT)}' (its undeclared keys have no slot)`);
+            };
             if (!ts.isIdentifier(restTo)) {
                 // `({ a, ...box.rest } = src)` — the rest packs identically and
                 // lands through the property/element write machinery.
-                lowerAssignTargetInto(lowerer, out, restTo, prop, null, () => packed);
+                lowerAssignTargetInto(lowerer, out, restTo, prop, null, (targetT) => {
+                    checkRestTarget(targetT);
+                    return packed;
+                });
                 continue;
             }
             const targetBinding = lowerer.resolveWritable(restTo);
             if (!targetBinding) {
                 lowerer.rejectUnresolved(restTo, `assignment to '${restTo.text}' (not a writable local or module global)`);
             }
+            checkRestTarget(targetBinding.type);
             out.push({
                 kind: "assign",
                 localId: targetBinding.id,
@@ -12505,6 +12739,13 @@ function assertionKeepsStorageLayout(lowerer, decl, init, settled) {
         return false;
     if (hostsAll(lowerer, init, settled))
         return true;
+    // An assertion that only ADDS optional members (`item as Base & { icons?:
+    // unknown }`) keeps the value too: Node erases it, and the added members
+    // have no slot in the stored layout, so reads answer them through the
+    // layout's kept source (assertedOnlyFieldRead) instead of a width copy's
+    // absent slot.
+    if (assertedOptionalExtension(lowerer, init, settled))
+        return true;
     // A projection (`{ text: string }` over `TextBlock`) keeps the stored
     // record only when the binding's identity is observable through it
     // (a write, an identity comparison). A read-only view is equal either
@@ -12524,9 +12765,11 @@ function assertionKeepsStorageLayout(lowerer, decl, init, settled) {
  * child object in both), so only a write to the copy's own field is
  * refused, by name. Where the layouts agree the binding keeps the value's
  * storage instead (assertionKeepsStorageLayout), narrowing.ts and
- * lowerVarDecl record that in layoutKeptNodes, and nothing here fires.
- * Runs for file-scope and local bindings alike, after the declaration has
- * been lowered (so the keep is known). */
+ * lowerVarDecl record that in layoutKeptNodes, and nothing here fires: an
+ * assertion that only adds optional members keeps the layout its reads
+ * answer from, and a write to an added member is refused where it happens
+ * (assertedOnlyMemberWrite). Runs for file-scope and local bindings alike,
+ * after the declaration has been lowered (so the keep is known). */
 function refuseAssertionViewWrite(lowerer, decl) {
     if (decl.initializer === undefined || !isAssertionInitializer(decl.initializer))
         return;