@scriptc/compiler 0.4.1 → 0.4.3

package/dist/frontend/lowering/class-dynamic-dispatch.js

@@ -1,8 +1,11 @@
 import { primitiveConstructorOr } from "./lower-exprs.js";
+import { InternalCompilerError } from "../../errors.js";
 import { dynUndefinedExpr, helperLoc, nodeThrowExpr, varRef } from "../../ir/build.js";
 import { constructedValue } from "./constructor-returns.js";
 import { eventTargetApiMembers, eventTargetInheritedMember } from "./lower-event-target.js";
-import { BOOL, DYN, F64, DYN_CLASS_PROPERTIES as PROPERTY_BAG, STRING, VOID, canConvertToDyn, canDynCheckTo, isClassOwnEnumerableFieldName, isDynTypedRefType, isUnitType, typeEquals, typeKey, } from "../../ir/ir.js";
+import { DATE_PROTOTYPE_METHOD_NAMES, DATE_TIME_FIELD, dateInheritedMember, dateRootOf, programDeclaresDateClass, } from "./builtins/date-classes.js";
+import { dateValueMethod } from "./builtins/dates.js";
+import { BOOL, DATE_T, DYN, F64, DYN_CLASS_PROPERTIES as PROPERTY_BAG, STRING, VOID, canConvertToDyn, canDynCheckTo, isClassOwnEnumerableFieldName, isDynTypedRefType, isUnitType, typeEquals, typeKey, } from "../../ir/ir.js";
 import { streamTypedRefEligible } from "../../ir/analysis.js";
 import { everyStmtList, transformExpr, transformStmtList } from "../../ir/traverse.js";
 import { PoisonError } from "./lowerer.js";
@@ -22,9 +25,10 @@ import { isClassCallback } from "./class-callbacks.js";
 import { CaughtValueDispatch } from "./caught-value-dispatch.js";
 import { refreshDescriptorGuards } from "./class-descriptors.js";
 import { ClassConstructionDispatch } from "./class-construction.js";
-import { emitterRooted } from "./lower-event-emitter.js";
+import { DispatchSites } from "./dispatch-sites.js";
+import { emitterRooted, lowerDynamicEmitterEmit, lowerDynamicEmitterOn, } from "./lower-event-emitter.js";
 import { protocolArm, protocolFieldArm } from "./class-protocol-dispatch.js";
-import { STREAM_OPERATORS } from "./lower-stream.js";
+import { STREAM_OPERATORS, operatorSignalOptions, reduceSignalSetup } from "./lower-stream.js";
 import { deletedPropertyNames, fixedFieldFamily } from "./js-class-fields.js";
 const STREAM_METHODS = new Set([
     "on",
@@ -50,6 +54,25 @@ const EMITTER_METHODS = new Set([
     "off",
     "removeListener",
 ]);
+/** The rest of EventEmitter.prototype, answered through an untyped value
+ * on emitters that are not streams (streams keep their own surface). */
+const EMITTER_INTROSPECTION_METHODS = new Set([
+    "listenerCount",
+    "eventNames",
+    "removeAllListeners",
+    "listeners",
+    "rawListeners",
+    "setMaxListeners",
+    "getMaxListeners",
+]);
+/** True when the class is or extends one of the runtime stream classes. */
+function streamRooted(info) {
+    for (let c = info; c; c = c.base) {
+        if (c.builtinStream !== undefined)
+            return true;
+    }
+    return false;
+}
 const STREAM_BOOL_PROPERTIES = new Set([
     "readable",
     "readableEnded",
@@ -128,7 +151,7 @@ const KEY_CALLS = new Map([
     ["dyn.keyDeleteComputed", "value"],
     ["dyn.keySetComputed", "value"],
 ]);
-function toPrimitiveHint(expr) {
+export function toPrimitiveHint(expr) {
     if (expr.kind === "toString")
         return expr.operand.type.kind === "dyn" ? "string" : null;
     if (expr.kind === "dynKeyGet")
@@ -176,6 +199,7 @@ function isPrimitive(value, loc) {
 }
 export function classInstanceOf(lowerer, value, info, loc, classValue) {
     const name = `%dyn.class.${classValue ? "valueInstanceof" : "instanceof"}:${info.def.name}`;
+    lowerer.shareHelper(name);
     const params = [
         { localId: "value", name: "value", type: DYN },
         ...(classValue ? [{ localId: "class", name: "class", type: classValue.type }] : []),
@@ -185,6 +209,32 @@ export function classInstanceOf(lowerer, value, info, loc, classValue) {
         const prototype = classPrototypeData(lowerer, info, loc, classValue ? varRef("class", classValue.type, loc) : undefined);
         const body = prototype
             ? [
+                // In a program that declares a class extending Date, a Date can
+                // meet a class test (`date instanceof Moment`): its prototype
+                // chain holds no class prototype.
+                ...(programDeclaresDateClass(lowerer)
+                    ? [
+                        {
+                            kind: "if",
+                            cond: {
+                                kind: "libCall",
+                                fn: "dyn.nativeDateHandleIs",
+                                args: [varRef("value", DYN, loc)],
+                                type: BOOL,
+                                loc,
+                            },
+                            then: [
+                                {
+                                    kind: "return",
+                                    value: { kind: "boolLit", value: false, type: BOOL, loc },
+                                    loc,
+                                },
+                            ],
+                            else_: null,
+                            loc,
+                        },
+                    ]
+                    : []),
                 { kind: "varDecl", localId: "candidate", init: varRef("value", DYN, loc), loc },
                 {
                     kind: "while",
@@ -202,7 +252,7 @@ export function classInstanceOf(lowerer, value, info, loc, classValue) {
                             localId: "candidate",
                             value: {
                                 kind: "libCall",
-                                fn: "dyn.getPrototype",
+                                fn: "dyn.getPrototypeForIdentity",
                                 args: [candidate],
                                 type: DYN,
                                 loc,
@@ -245,6 +295,37 @@ export function classInstanceOf(lowerer, value, info, loc, classValue) {
         loc,
     };
 }
+/** `value` is the parameter itself, possibly through js.fromDyn. */
+function returnsParam(value, param) {
+    if (value.kind === "varRef")
+        return value.localId === param;
+    return (value.kind === "libCall" &&
+        value.fn === "js.fromDyn" &&
+        value.args.length === 1 &&
+        value.args[0].kind === "varRef" &&
+        value.args[0].localId === param);
+}
+/** The kind a class-table branch requires of `param`: a capsule-key test
+ * (alone or guarding a conjunction) needs a capsule, a class-key test a
+ * function value; null for any other condition. */
+function branchKind(cond, param) {
+    if (cond.kind === "libCall" &&
+        (cond.fn === "dyn.typedRefIs" ||
+            cond.fn === "dyn.typedRefKeyIs" ||
+            cond.fn === "dyn.classIs") &&
+        cond.args[0]?.kind === "varRef" &&
+        cond.args[0].localId === param) {
+        if (cond.fn === "dyn.classIs")
+            return "funcKind";
+        const key = cond.args[1];
+        return key?.kind === "strLit" && key.value.startsWith("object:") ? "classCapsule" : null;
+    }
+    if (cond.kind === "ternary" && cond.else_.kind === "boolLit" && cond.else_.value === false)
+        return branchKind(cond.cond, param);
+    if (cond.kind === "logical" && cond.op === "&&")
+        return branchKind(cond.left, param);
+    return null;
+}
 const READ_PROPERTIES = "%dyn.class.readProperties";
 const READ_PROPERTIES_OR_EMPTY = "%dyn.class.readPropertiesOrEmpty";
 function isEmptyBag(value) {
@@ -273,9 +354,106 @@ function readOnlyBagBody(body, orEmpty = false) {
     }
     return body;
 }
+/** `value` with the class branch's checked receiver (`p.0` as a dynamic
+ * value, possibly cast to the branch's class) replaced by `receiver`, the
+ * typed receiver of a per-class helper. */
+function withTypedReceiver(value, receiver) {
+    const checked = (e) => e.kind === "dynCheck" && e.value.kind === "varRef" && e.value.localId === "p.0";
+    return transformExpr(value, {
+        stmt: (stmt) => stmt,
+        expr: (expr) => (expr.kind === "downcast" &&
+            checked(expr.value) &&
+            expr.type.kind === "object" &&
+            receiver.type.kind === "object" &&
+            expr.type.className === receiver.type.className) ||
+            checked(expr)
+            ? receiver
+            : expr,
+    });
+}
+/** Re-adds the classes of `set` after the first `from` in a fixed order:
+ * the program's classes by name, then the classes the runtime implements by
+ * name. The dispatch helpers add each class's branch in front of the
+ * earlier ones, so a runtime class's branch, which answers its methods for
+ * instances of the program's subclasses too, is tested before the
+ * subclasses' own branches. */
+function sortAdded(lowerer, set, from) {
+    const runtime = (name) => {
+        const info = lowerer.classes.get(name);
+        return !!(info &&
+            (info.def.runtime || info.builtinEmitter || info.builtinStream || info.builtinError));
+    };
+    const added = [...set]
+        .slice(from)
+        .sort((left, right) => Number(runtime(left)) - Number(runtime(right)) ||
+        (left < right ? -1 : left > right ? 1 : 0));
+    for (const name of added)
+        set.delete(name);
+    for (const name of added)
+        set.add(name);
+}
+function receiverIndex(lowerer, plans) {
+    const methods = new Map();
+    const members = new Map();
+    const rooted = [];
+    const add = (table, name, position) => {
+        const positions = table.get(name);
+        if (positions === undefined)
+            table.set(name, [position]);
+        else if (positions[positions.length - 1] !== position)
+            positions.push(position);
+    };
+    plans.forEach(({ info }, position) => {
+        if (emitterRooted(lowerer, info) ||
+            info.builtinStream !== undefined ||
+            eventTargetApiMembers(info) !== null ||
+            dateRootOf(info) !== null) {
+            rooted.push(position);
+            return;
+        }
+        for (let c = info; c; c = c.base) {
+            for (const name of c.methods.keys()) {
+                add(methods, name, position);
+                // A `get:`/`set:` key is an accessor of the property after the
+                // prefix, or a method whose quoted name has that prefix; the test
+                // looks up both.
+                add(members, name, position);
+                if (name.startsWith("get:") || name.startsWith("set:"))
+                    add(members, name.slice(4), position);
+            }
+            if (c.genericMethods)
+                for (const name of c.genericMethods.keys()) {
+                    add(methods, name, position);
+                    add(members, name, position);
+                }
+        }
+        for (const name of info.fields.keys())
+            add(members, name, position);
+    });
+    for (const table of [methods, members])
+        for (const positions of table.values())
+            positions.sort((a, b) => a - b);
+    return { plans, methods, members, rooted };
+}
+/** The ascending union of two ascending position lists. */
+function mergePositions(left, right) {
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < left.length || j < right.length) {
+        const next = j >= right.length || (i < left.length && left[i] <= right[j]) ? left[i++] : right[j++];
+        if (out[out.length - 1] !== next)
+            out.push(next);
+    }
+    return out;
+}
+/** SCRIPTC_CHECK_DISPATCH_CANDIDATES=1 checks every indexed receiver selection
+ * against a test of every receiver. */
+const CHECK_CANDIDATES = process.env["SCRIPTC_CHECK_DISPATCH_CANDIDATES"] === "1";
 export function classPropertiesHelper(lowerer, loc, readOnly = false) {
     const name = readOnly ? READ_PROPERTIES : "%dyn.class.properties";
-    const existing = lowerer.liftedFns.find((fn) => fn.name === name);
+    lowerer.shareHelper(name);
+    const existing = lowerer.liftedFnNamed(name);
     if (existing)
         return existing;
     const helper = {
@@ -309,6 +487,8 @@ export function classPropertiesHelper(lowerer, loc, readOnly = false) {
  * than that table, so a miss rechecks the instance itself. */
 export function classForInHasKey(lowerer, value, key, loc) {
     const name = "%dyn.class.forInHasKey";
+    lowerer.shareHelper(name);
+    lowerer.shareHelper("%dyn.class.forInBagHas");
     if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
         // The read-only table: a recheck never creates an instance's table, which
         // is undefined while the instance has no own dynamic properties.
@@ -408,15 +588,151 @@ export function trackClassFieldCreation(lowerer, functions) {
         return;
     const loc = functions[0].loc;
     const name = "%dyn.class.fieldCreated";
-    const value = varRef("value", DYN, loc), key = varRef("key", DYN, loc);
-    const bag = varRef("bag", DYN, loc);
-    const created = (receiver, className, field, loc) => ({
+    const key = varRef("key", DYN, loc);
+    // One helper per class: the instance's bag is its own hidden field, so a
+    // creation reads it directly instead of boxing the instance and testing
+    // it against every class's capsule (%dyn.class.properties), which runs
+    // only to create the bag, once per instance.
+    const perClass = new Map();
+    const helperFor = (className) => {
+        const known = perClass.get(className);
+        if (known !== undefined)
+            return known;
+        const helperName = `${name}:${className}`;
+        perClass.set(className, helperName);
+        const self = varRef("this", { kind: "object", className }, loc);
+        const bagRef = varRef("bag", DYN, loc);
+        functions.push({
+            name: helperName,
+            params: [
+                { localId: "this", name: "this", type: { kind: "object", className } },
+                { localId: "key", name: "key", type: DYN },
+            ],
+            returnType: VOID,
+            locals: [
+                { id: "this", name: "this", type: { kind: "object", className }, mutable: false },
+                { id: "key", name: "key", type: DYN, mutable: false },
+                { id: "bag", name: "bag", type: DYN, mutable: true },
+            ],
+            body: [
+                {
+                    kind: "varDecl",
+                    localId: "bag",
+                    init: { kind: "fieldGet", obj: self, className, field: PROPERTY_BAG, type: DYN, loc },
+                    loc,
+                },
+                {
+                    kind: "if",
+                    cond: { kind: "dynTest", test: "undefined", value: bagRef, type: BOOL, loc },
+                    then: initializeBag(lowerer, className, self, loc),
+                    else_: null,
+                    loc,
+                },
+                ...defineIfAbsent(lowerer, bagRef, key, loc),
+            ],
+            loc,
+        });
+        return helperName;
+    };
+    // String-keyed fields take the runtime's direct insert for an ordinary
+    // bag; the general path stays for any other bag and for symbol keys.
+    const stringHelperFor = (className) => {
+        const known = perClass.get(`str:${className}`);
+        if (known !== undefined)
+            return known;
+        const general = helperFor(className);
+        const helperName = `${name}.string:${className}`;
+        perClass.set(`str:${className}`, helperName);
+        const type = { kind: "object", className };
+        const self = varRef("this", type, loc);
+        const bagRef = varRef("bag", DYN, loc);
+        const field = varRef("field", STRING, loc);
+        functions.push({
+            name: helperName,
+            params: [
+                { localId: "this", name: "this", type },
+                { localId: "field", name: "field", type: STRING },
+            ],
+            returnType: VOID,
+            locals: [
+                { id: "this", name: "this", type, mutable: false },
+                { id: "field", name: "field", type: STRING, mutable: false },
+                { id: "bag", name: "bag", type: DYN, mutable: true },
+            ],
+            body: [
+                {
+                    kind: "varDecl",
+                    localId: "bag",
+                    init: { kind: "fieldGet", obj: self, className, field: PROPERTY_BAG, type: DYN, loc },
+                    loc,
+                },
+                {
+                    kind: "if",
+                    cond: { kind: "dynTest", test: "undefined", value: bagRef, type: BOOL, loc },
+                    then: initializeBag(lowerer, className, self, loc),
+                    else_: null,
+                    loc,
+                },
+                {
+                    kind: "if",
+                    cond: {
+                        kind: "libCall",
+                        fn: "dyn.bagCreateField",
+                        args: [bagRef, field],
+                        type: BOOL,
+                        loc,
+                    },
+                    then: [{ kind: "return", value: null, loc }],
+                    else_: null,
+                    loc,
+                },
+                {
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "call",
+                        callee: general,
+                        args: [self, lowerer.coerceToExpected(field, DYN)],
+                        type: VOID,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            loc,
+        });
+        return helperName;
+    };
+    const created = (receiver, className, field, loc) => {
+        const symbolKey = symbolMemberKey(lowerer, lowerer.classes.get(className), field, loc);
+        if (symbolKey === null) {
+            return {
+                kind: "exprStmt",
+                expr: {
+                    kind: "call",
+                    callee: stringHelperFor(className),
+                    args: [
+                        receiver.type.kind === "object" && receiver.type.className !== className
+                            ? { kind: "upcast", value: receiver, type: { kind: "object", className }, loc }
+                            : receiver,
+                        { kind: "strLit", value: field, type: STRING, loc },
+                    ],
+                    type: VOID,
+                    loc,
+                },
+                loc,
+            };
+        }
+        return createdGeneral(receiver, className, field, loc);
+    };
+    const createdGeneral = (receiver, className, field, loc) => ({
         kind: "exprStmt",
         expr: {
             kind: "call",
-            callee: name,
+            callee: helperFor(className),
             args: [
-                lowerer.coerceToExpected(receiver, DYN),
+                receiver.type.kind === "object" && receiver.type.className !== className
+                    ? { kind: "upcast", value: receiver, type: { kind: "object", className }, loc }
+                    : receiver,
                 symbolMemberKey(lowerer, lowerer.classes.get(className), field, loc) ??
                     lowerer.coerceToExpected({ kind: "strLit", value: field, type: STRING, loc }, DYN),
             ],
@@ -484,77 +800,101 @@ export function trackClassFieldCreation(lowerer, functions) {
             },
         });
     }
-    functions.push({
-        name,
-        params: [
-            { localId: "value", name: "value", type: DYN },
-            { localId: "key", name: "key", type: DYN },
-        ],
-        returnType: VOID,
-        locals: [
-            { id: "value", name: "value", type: DYN, mutable: false },
-            { id: "key", name: "key", type: DYN, mutable: false },
-            { id: "bag", name: "bag", type: DYN, mutable: false },
-        ],
-        body: [
+}
+/** `bag = <the class's new bag>`, stored in the instance's hidden field:
+ * the class's own initializer when recorded, else the class-table
+ * dispatch, which creates it. */
+function initializeBag(lowerer, className, self, loc) {
+    const init = lowerer.classBagInitializers?.get(className);
+    if (init === undefined) {
+        return [
             {
-                kind: "varDecl",
+                kind: "assign",
                 localId: "bag",
-                init: {
+                value: {
                     kind: "call",
                     callee: classPropertiesHelper(lowerer, loc).name,
-                    args: [value],
+                    args: [lowerer.coerceToExpected(self, DYN)],
                     type: DYN,
                     loc,
                 },
                 loc,
             },
-            {
-                kind: "if",
-                cond: {
-                    kind: "unary",
-                    op: "!",
-                    operand: { kind: "libCall", fn: "dyn.hasOwnComputed", args: [bag, key], type: BOOL, loc },
-                    type: BOOL,
-                    loc,
-                },
-                then: [
-                    {
-                        kind: "exprStmt",
-                        expr: {
-                            kind: "libCall",
-                            fn: "dyn.defineProperty",
-                            args: [
-                                bag,
-                                lowerer.coerceToExpected(key, DYN),
-                                {
-                                    kind: "dynObjLit",
-                                    fields: [
-                                        {
-                                            key: { kind: "strLit", value: "value", type: STRING, loc },
-                                            value: dynUndefinedExpr(loc),
-                                        },
-                                        ...["writable", "enumerable", "configurable"].map((key) => ({
-                                            key: { kind: "strLit", value: key, type: STRING, loc },
-                                            value: lowerer.coerceToExpected({ kind: "boolLit", value: true, type: BOOL, loc }, DYN),
-                                        })),
-                                    ],
-                                    type: DYN,
-                                    loc,
-                                },
-                            ],
-                            type: DYN,
-                            loc,
-                        },
-                        loc,
-                    },
-                ],
-                else_: null,
+        ];
+    }
+    return [
+        {
+            kind: "fieldSet",
+            obj: self,
+            className,
+            field: PROPERTY_BAG,
+            value: structuredClone(init),
+            loc,
+        },
+        {
+            kind: "assign",
+            localId: "bag",
+            value: { kind: "fieldGet", obj: self, className, field: PROPERTY_BAG, type: DYN, loc },
+            loc,
+        },
+    ];
+}
+/** `value` as JSON without its source locations. */
+function withoutLocations(value) {
+    return JSON.stringify(value, (key, field) => (key === "loc" ? undefined : field));
+}
+/** Whether `value` reads local `id`. */
+function mentionsLocal(value, id) {
+    return JSON.stringify(value).includes(`"localId":${JSON.stringify(id)}`);
+}
+/** `if (!hasOwn(bag, key)) defineProperty(bag, key, <undefined data field>)`:
+ * a field's creation in its instance's property bag. */
+function defineIfAbsent(lowerer, bag, key, loc) {
+    return [
+        {
+            kind: "if",
+            cond: {
+                kind: "unary",
+                op: "!",
+                operand: { kind: "libCall", fn: "dyn.hasOwnComputed", args: [bag, key], type: BOOL, loc },
+                type: BOOL,
                 loc,
             },
-        ],
-        loc,
-    });
+            then: [
+                {
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "libCall",
+                        fn: "dyn.defineProperty",
+                        args: [
+                            bag,
+                            lowerer.coerceToExpected(key, DYN),
+                            {
+                                kind: "dynObjLit",
+                                fields: [
+                                    {
+                                        key: { kind: "strLit", value: "value", type: STRING, loc },
+                                        value: dynUndefinedExpr(loc),
+                                    },
+                                    ...["writable", "enumerable", "configurable"].map((key) => ({
+                                        key: { kind: "strLit", value: key, type: STRING, loc },
+                                        value: lowerer.coerceToExpected({ kind: "boolLit", value: true, type: BOOL, loc }, DYN),
+                                    })),
+                                ],
+                                type: DYN,
+                                loc,
+                            },
+                        ],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                },
+            ],
+            else_: null,
+            loc,
+        },
+    ];
 }
 /** Calls on native class capsules keep the instance's compiled methods. The
  * reachable-body fixed point discovers both the boxed classes and method
@@ -568,11 +908,16 @@ export class ClassDynamicDispatch {
     generatorDispatch = new GeneratorDynamicDispatch();
     caughtDispatch = new CaughtValueDispatch();
     constructionDispatch = new ClassConstructionDispatch();
+    /** What each function's body holds for this pass and its sub-passes. */
+    sites = new DispatchSites();
     /** Property names a delete can remove (null: any name), for the field
      * creation tracking decision. */
     deletedNames;
     boxed = new Set();
     boxedConstructors = new Set();
+    /** Every class a boxed value was statically typed as, runtime error
+     * classes included: the value's capsule can be any of its subclasses. */
+    boxedStatic = new Set();
     dispatches = new Map();
     properties = new Map();
     computed = new Map();
@@ -589,6 +934,9 @@ export class ClassDynamicDispatch {
     /** Per-class prototype selection for new property bags (bagPrototypeHelper). */
     bagPrototypeHelpers = new Map();
     readPropertyBags = [];
+    /** Read-only bags of exactly one class (exactPropertyBag), by class and
+     * whether an absent bag reads as a fresh empty object. */
+    exactPropertyBags = new Map();
     generated = new Set();
     /** Protocol dispatch helpers and callee reads whose receivers normalize. */
     protocols = [];
@@ -601,8 +949,17 @@ export class ClassDynamicDispatch {
     descriptorHelper = null;
     prototypeHelper = null;
     prototypeClasses = new Set();
-    prototypeIdentityHelper = null;
-    prototypeIdentityClasses = new Set();
+    /** The stand-in prototype object of each class without prototype data
+     * (prototypeStandIn), by class name. */
+    prototypeStandIns = new Set();
+    /** The prototype reads of identity walks, by libCall, and the classes
+     * each one answers for boxed instances. */
+    prototypeIdentityHelpers = new Map();
+    /** `value instanceof Error` through Error.prototype: boxed instances of
+     * classes with a heritage evaluated at run time test their prototype
+     * data's chain. */
+    errorPrototypeHelper = null;
+    errorPrototypeClasses = new Set();
     instancePrototypes = new Map();
     checkedCasts = new Map();
     /** The for-in key helpers, by libCall (dyn and native string[] keys). */
@@ -625,22 +982,25 @@ export class ClassDynamicDispatch {
                 first.value.callee === this.normalization?.name)
                 fn.body.shift();
         }
-        let changed = this.caughtDispatch.process(lowerer, functions);
+        let changed = this.caughtDispatch.process(lowerer, functions, this.sites);
         changed = refreshErrorMethodDispatch(lowerer, functions) || changed;
         changed = refreshClassMethodValueSelections(lowerer) || changed;
         changed = refreshErrorPropertyDispatch(lowerer, functions) || changed;
-        changed = this.generatorDispatch.process(lowerer, functions, this.generated) || changed;
-        changed = this.constructionDispatch.process(lowerer, functions) || changed;
+        changed =
+            this.generatorDispatch.process(lowerer, functions, this.generated, this.sites) || changed;
+        changed = this.constructionDispatch.process(lowerer, functions, this.sites) || changed;
         const seenTypes = new Set();
         const rewrite = new Set();
         const toPrimitiveSites = new Set();
         const hasKeySites = new Set();
+        const caughtSites = new Set();
         const discover = (type) => {
             const key = typeKey(type);
             if (seenTypes.has(key))
                 return;
             seenTypes.add(key);
             if (type.kind === "object") {
+                this.boxedStatic.add(type.className);
                 if (isDynTypedRefType(type))
                     this.boxed.add(type.className);
             }
@@ -661,83 +1021,30 @@ export class ClassDynamicDispatch {
             else if (type.kind === "promise")
                 discover(type.inner);
         };
-        for (const fn of functions)
-            everyStmtList(fn.body, {
-                stmt: (statement) => {
-                    // Field-creation instrumentation can box a base-constructor receiver
-                    // even when only its derived instances otherwise cross the boundary.
-                    if (statement.kind === "fieldSet" &&
-                        lowerer.classes.get(statement.className)?.def.tracksOwnFields &&
-                        isClassOwnEnumerableFieldName(statement.field))
-                        discover(statement.obj.type);
-                    return true;
-                },
-                expr: (expr) => {
-                    if (expr.kind === "jsonStringify" ||
-                        (expr.kind === "libCall" &&
-                            (expr.fn === "json.stringifyValue" || expr.fn === "json.stringifyReplacer"))) {
-                        this.serializesClasses = true;
-                    }
-                    if (toPrimitiveHint(expr) !== null ||
-                        (expr.kind === "libCall" && (expr.fn === "dyn.valueOf" || expr.fn === "dyn.toString")))
-                        toPrimitiveSites.add(fn);
-                    switch (expr.kind) {
-                        case "dynFrom":
-                            discover(expr.value.type);
-                            break;
-                        case "fieldIncDec":
-                            if (lowerer.classes.get(expr.className)?.def.tracksOwnFields &&
-                                isClassOwnEnumerableFieldName(expr.field))
-                                discover(expr.obj.type);
-                            break;
-                        case "call":
-                            if ((expr.callee === "%dyn.class.properties" ||
-                                expr.callee === "%dyn.class.readProperties") &&
-                                expr.args[0]?.kind === "dynFrom" &&
-                                isDynTypedRefType(expr.args[0].value.type))
-                                rewrite.add(fn);
-                            break;
-                        case "dynHasKey":
-                            hasKeySites.add(fn);
-                            break;
-                        case "dynKeyGet":
-                        case "dynInvoke":
-                            rewrite.add(fn);
-                            break;
-                        case "dynCheck":
-                            if (isDynTypedRefType(expr.type))
-                                rewrite.add(fn);
-                            // A dynamic function checked into a native function type
-                            // receives its arguments as dynamic values: class instances
-                            // passed to it cross the boundary when it is called (a JS
-                            // `list.map((rec) => rec.match(x))` callback with an untyped
-                            // parameter).
-                            if (expr.type.kind === "func")
-                                expr.type.params.forEach(discover);
-                            break;
-                        case "libCall":
-                            if (expr.fn === "bytes.construct" ||
-                                expr.fn === "dyn.keySet" ||
-                                expr.fn === "dyn.keySetComputed" ||
-                                expr.fn === "dyn.iterator" ||
-                                expr.fn === "dyn.arrayFromIterator" ||
-                                expr.fn === "dyn.toString" ||
-                                expr.fn === "dyn.stringConstructor" ||
-                                expr.fn === "dyn.forInKeys" ||
-                                expr.fn === "dyn.forInKeyStrings" ||
-                                expr.fn === "dyn.hasKeyComputed" ||
-                                expr.fn === "dyn.hasOwnComputed" ||
-                                expr.fn === "dyn.propertyIsEnumerableComputed" ||
-                                expr.fn === "dyn.defineProperty" ||
-                                expr.fn === "dyn.getPrototype" ||
-                                expr.fn === "dyn.reflectGet" ||
-                                expr.fn === "dyn.reflectSet")
-                                rewrite.add(fn);
-                            break;
-                    }
-                    return true;
-                },
-            });
+        const boxedBefore = this.boxed.size;
+        const boxedConstructorsBefore = this.boxedConstructors.size;
+        for (const fn of functions) {
+            const found = this.sites.of(fn);
+            // A class starts tracking its own fields during this pass.
+            for (const { type, fieldClass } of found.boxing)
+                if (fieldClass === undefined || lowerer.classes.get(fieldClass)?.def.tracksOwnFields)
+                    discover(type);
+            if (found.serializes)
+                this.serializesClasses = true;
+            if (found.conversions)
+                toPrimitiveSites.add(fn);
+            if (found.dispatches)
+                rewrite.add(fn);
+            if (found.keyTests)
+                hasKeySites.add(fn);
+            if (found.caughtClassTests)
+                caughtSites.add(fn);
+        }
+        // The classes this pass found join the tables in a fixed order, not in
+        // the order the scan met them.
+        sortAdded(lowerer, this.boxed, boxedBefore);
+        sortAdded(lowerer, this.boxedConstructors, boxedConstructorsBefore);
+        changed = this.caughtDispatch.dynamicPayloads(lowerer, caughtSites, this.boxed) || changed;
         if (this.boxed.size === 0 && rewrite.size === 0)
             return changed;
         const converting = this.convertingHints(lowerer);
@@ -844,9 +1151,11 @@ export class ClassDynamicDispatch {
                     });
                 changed = true;
             }
-            if (this.prototypeIdentityHelper && !this.prototypeIdentityClasses.has(className)) {
-                this.prototypeIdentityClasses.add(className);
-                const loc = this.prototypeIdentityHelper.loc;
+            if (this.errorPrototypeHelper &&
+                !this.errorPrototypeClasses.has(className) &&
+                hasRuntimeHeritage(info)) {
+                this.errorPrototypeClasses.add(className);
+                const loc = this.errorPrototypeHelper.loc;
                 const type = { kind: "object", className };
                 const value = varRef("value", DYN, loc);
                 const prototype = classPrototypeData(lowerer, info, loc, {
@@ -856,7 +1165,7 @@ export class ClassDynamicDispatch {
                     loc,
                 });
                 if (prototype)
-                    this.prototypeIdentityHelper.body.unshift({
+                    this.errorPrototypeHelper.body.unshift({
                         kind: "if",
                         cond: {
                             kind: "libCall",
@@ -865,7 +1174,19 @@ export class ClassDynamicDispatch {
                             type: BOOL,
                             loc,
                         },
-                        then: [{ kind: "return", value: prototype, loc }],
+                        then: [
+                            {
+                                kind: "return",
+                                value: {
+                                    kind: "libCall",
+                                    fn: "dyn.inheritsErrorPrototype",
+                                    args: [prototype],
+                                    type: BOOL,
+                                    loc,
+                                },
+                                loc,
+                            },
+                        ],
                         else_: null,
                         loc,
                     });
@@ -879,7 +1200,7 @@ export class ClassDynamicDispatch {
                 const loc = this.propertyBag.loc;
                 const method = classMethodValue(lowerer, info.decl, info, "toJSON", loc);
                 const prototype = method ? classPrototypeData(lowerer, info, loc) : null;
-                const helper = lowerer.liftedFns.find((fn) => fn.name === info.def.prototypeDataHelper);
+                const helper = lowerer.liftedFnNamed(info.def.prototypeDataHelper);
                 const init = helper?.body[0];
                 if (!info.prototypeReflectionReady &&
                     method &&
@@ -930,6 +1251,101 @@ export class ClassDynamicDispatch {
                 }
             }
         }
+        // The runtime boxes a class instance as its exact class, so a value
+        // boxed at a base (or Error) static type reaches the identity views as
+        // any subclass's capsule.
+        for (const helper of this.prototypeIdentityHelpers.values())
+            for (const [className, info] of lowerer.classes) {
+                if (helper.classes.has(className))
+                    continue;
+                if (info.builtinEmitter || info.builtinStream || info.builtinError)
+                    continue;
+                if (!isDynTypedRefType({ kind: "object", className }))
+                    continue;
+                if (!this.boxed.has(className) &&
+                    ![...this.boxedStatic].some((base) => lowerer.isSubclassOf(className, base)))
+                    continue;
+                helper.classes.add(className);
+                const loc = helper.fn.loc;
+                const type = { kind: "object", className };
+                const value = varRef("value", DYN, loc);
+                // A class with no prototype data in its chain (one extending
+                // Error, or with no methods) has no prototype a program can name:
+                // an object of the class's own stands in, so instances of one class
+                // share it (`Object.getPrototypeOf(a) === Object.getPrototypeOf(b)`),
+                // other prototypes differ from it, and an instanceof walk (through
+                // Object.prototype to null) answers false instead of reaching the
+                // reflection refusal. A function-local class is a new class at
+                // each evaluation of its declaration, so its instances answer with
+                // the prototype of their own class value instead.
+                const answer = (name) => {
+                    const of = lowerer.classes.get(name);
+                    const prototype = hasClassPrototypeData(of) || of.localClass
+                        ? classPrototypeData(lowerer, of, loc, {
+                            kind: "dynCheck",
+                            value,
+                            type: { kind: "object", className: name },
+                            loc,
+                        })
+                        : null;
+                    if (prototype)
+                        return [{ kind: "return", value: prototype, loc }];
+                    return hasClassPrototypeData(of) ? null : this.prototypeStandIn(lowerer, name, loc);
+                };
+                const own = answer(className);
+                if (!own) {
+                    changed = true;
+                    continue;
+                }
+                // A capsule boxed at this class can hold a subclass instance: the
+                // most derived subclass the instance belongs to answers.
+                const depth = (name) => {
+                    let n = 0;
+                    for (let at = lowerer.classes.get(name)?.base; at; at = at.base)
+                        n++;
+                    return n;
+                };
+                const subclasses = [...lowerer.classes.keys()]
+                    .filter((name) => name !== className &&
+                    lowerer.isSubclassOf(name, className) &&
+                    isDynTypedRefType({ kind: "object", className: name }))
+                    .sort((a, b) => depth(b) - depth(a));
+                const then = [];
+                for (const name of subclasses) {
+                    const sub = answer(name);
+                    if (!sub)
+                        continue;
+                    then.push({
+                        kind: "if",
+                        cond: {
+                            kind: "instanceOf",
+                            value: { kind: "dynCheck", value, type, loc },
+                            className: name,
+                            type: BOOL,
+                            loc,
+                        },
+                        then: sub,
+                        else_: null,
+                        loc,
+                    });
+                }
+                then.push(...own);
+                helper.fn.body.unshift({
+                    kind: "if",
+                    cond: {
+                        kind: "libCall",
+                        fn: "dyn.typedRefIs",
+                        args: [value, { kind: "strLit", value: typeKey(type), type: STRING, loc }],
+                        type: BOOL,
+                        loc,
+                    },
+                    then,
+                    else_: null,
+                    loc,
+                });
+                changed = true;
+            }
+        let live = null;
         for (const plan of this.propertyReceivers(lowerer, false, false)) {
             const info = plan.info;
             const className = info.def.name;
@@ -999,7 +1415,11 @@ export class ClassDynamicDispatch {
             const needsPrototype = (current) => hasClassPrototypeData(current) ||
                 current.subclasses.some((child) => lowerer.classCanBeConstructed(child) && needsPrototype(child));
             const prototypeFor = (current, receiver, loc) => this.bagPrototype(lowerer, current, receiver, loc);
-            for (const existingInit of this.bagInitializers.get(className) ?? []) {
+            live ??= this.liveBagInitializers();
+            for (const existingInit of [
+                ...(this.bagInitializers.get(className) ?? []),
+                ...(live.get(className) ?? []),
+            ]) {
                 if (existingInit.value.kind === "dynObjLit" && needsPrototype(info)) {
                     const prototype = prototypeFor(info, existingInit.obj, existingInit.loc);
                     if (prototype) {
@@ -1010,6 +1430,14 @@ export class ClassDynamicDispatch {
                             type: DYN,
                             loc: existingInit.loc,
                         };
+                        // The initializer is a statement of the property bag helpers;
+                        // their reused site summaries do not see an edit inside it.
+                        if (this.propertyBag)
+                            this.sites.forget(this.propertyBag);
+                        for (const fn of this.typedPropertyBags.values())
+                            this.sites.forget(fn);
+                        for (const fn of this.exactPropertyBags.values())
+                            this.sites.forget(fn);
                         changed = true;
                     }
                 }
@@ -1079,15 +1507,36 @@ export class ClassDynamicDispatch {
         }
         refreshDescriptorGuards(lowerer);
         const byMethod = new Map();
+        // A query asks every receiver about one name, and the program's dispatch
+        // sites ask about thousands: index the receivers by name once per list.
+        let index = null;
+        const indexOf = (plans) => index?.plans === plans ? index : (index = receiverIndex(lowerer, plans));
+        /** The receivers of `plans` that can answer `name`, in list order: those
+         * `table` lists under it and the rooted ones. Emit-override
+         * specializations (`emit:<event>`) join a class's methods while bodies
+         * lower, so they keep every receiver. */
+        const receiversFor = (plans, name, table) => {
+            if (name.startsWith("emit:"))
+                return plans;
+            const found = indexOf(plans);
+            const positions = (table === "methods" ? found.methods : found.members).get(name);
+            return mergePositions(positions ?? [], found.rooted).map((position) => plans[position]);
+        };
         const candidates = (method) => {
             const found = byMethod.get(method);
             if (found)
                 return found;
-            const matching = this.propertyReceivers(lowerer, true).flatMap(({ info }) => {
+            const plans = this.propertyReceivers(lowerer, true);
+            const test = ({ info }) => {
                 if (!info || info.fields.has(method) || info.builtinError)
                     return [];
                 if (emitterRooted(lowerer, info) && EMITTER_METHODS.has(method))
                     return [info];
+                if (emitterRooted(lowerer, info) &&
+                    !streamRooted(info) &&
+                    EMITTER_INTROSPECTION_METHODS.has(method) &&
+                    !findMethodOn(lowerer, info, method))
+                    return [info];
                 if (info.builtinStream) {
                     return STREAM_METHODS.has(method) ||
                         (STREAM_OPERATORS.has(method) && info.builtinStream !== "w")
@@ -1097,10 +1546,25 @@ export class ClassDynamicDispatch {
                 return findMethodOn(lowerer, info, method) || findGenericMethodOn(lowerer, info, method)
                     ? [info]
                     : [];
-            });
+            };
+            const matching = receiversFor(plans, method, "methods").flatMap(test);
+            if (CHECK_CANDIDATES) {
+                const every = plans.flatMap(test);
+                if (every.length !== matching.length || every.some((info, i) => info !== matching[i]))
+                    throw new InternalCompilerError(`indexed candidates for ${method} differ`);
+            }
             byMethod.set(method, matching);
             return matching;
         };
+        const candidateSets = new Map();
+        const candidateSet = (method) => {
+            let set = candidateSets.get(method);
+            if (!set) {
+                set = new Set(candidates(method));
+                candidateSets.set(method, set);
+            }
+            return set;
+        };
         for (const fn of functions) {
             // Discovery already visits every expression. Preserve bodies without
             // dispatch sites instead of rebuilding their entire typed IR tree on
@@ -1219,29 +1683,65 @@ export class ClassDynamicDispatch {
                         }
                         return { kind: "call", callee: cast.fn.name, args: [expr.value], type, loc: expr.loc };
                     }
+                    if (expr.kind === "libCall" && expr.fn === "dyn.inheritsErrorPrototype") {
+                        if (!this.errorPrototypeHelper) {
+                            const loc = expr.loc;
+                            this.errorPrototypeHelper = {
+                                name: "%dyn.class.inheritsErrorPrototype",
+                                params: [{ localId: "value", name: "value", type: DYN }],
+                                locals: [{ id: "value", name: "value", type: DYN, mutable: false }],
+                                returnType: BOOL,
+                                loc,
+                                body: [
+                                    { kind: "return", value: { ...expr, args: [varRef("value", DYN, loc)] }, loc },
+                                ],
+                            };
+                            lowerer.liftedFns.push(this.errorPrototypeHelper);
+                            this.generated.add(this.errorPrototypeHelper);
+                            changed = true;
+                        }
+                        return {
+                            kind: "call",
+                            callee: this.errorPrototypeHelper.name,
+                            args: expr.args,
+                            type: BOOL,
+                            loc: expr.loc,
+                        };
+                    }
                     if (expr.kind === "libCall" &&
-                        expr.fn === "dyn.getPrototype" &&
+                        (expr.fn === "dyn.getPrototype" || expr.fn === "dyn.getPrototypeForIdentity") &&
                         expr.args[0]?.kind !== "dynObjLit") {
                         if (expr.prototypeIdentityOnly) {
-                            if (!this.prototypeIdentityHelper) {
+                            let helper = this.prototypeIdentityHelpers.get(expr.fn);
+                            if (!helper) {
                                 const loc = expr.loc;
-                                this.prototypeIdentityHelper = {
-                                    name: "%dyn.class.prototypeIdentity",
-                                    params: [{ localId: "value", name: "value", type: DYN }],
-                                    locals: [{ id: "value", name: "value", type: DYN, mutable: false }],
-                                    returnType: DYN,
-                                    loc,
-                                    body: [
-                                        { kind: "return", value: { ...expr, args: [varRef("value", DYN, loc)] }, loc },
-                                    ],
+                                helper = {
+                                    fn: {
+                                        name: expr.fn === "dyn.getPrototype"
+                                            ? "%dyn.class.prototypeIdentity"
+                                            : "%dyn.class.prototypeChainIdentity",
+                                        params: [{ localId: "value", name: "value", type: DYN }],
+                                        locals: [{ id: "value", name: "value", type: DYN, mutable: false }],
+                                        returnType: DYN,
+                                        loc,
+                                        body: [
+                                            {
+                                                kind: "return",
+                                                value: { ...expr, args: [varRef("value", DYN, loc)] },
+                                                loc,
+                                            },
+                                        ],
+                                    },
+                                    classes: new Set(),
                                 };
-                                lowerer.liftedFns.push(this.prototypeIdentityHelper);
-                                this.generated.add(this.prototypeIdentityHelper);
+                                this.prototypeIdentityHelpers.set(expr.fn, helper);
+                                lowerer.liftedFns.push(helper.fn);
+                                this.generated.add(helper.fn);
                                 changed = true;
                             }
                             return {
                                 kind: "call",
-                                callee: this.prototypeIdentityHelper.name,
+                                callee: helper.fn.name,
                                 args: expr.args,
                                 type: DYN,
                                 loc: expr.loc,
@@ -2013,7 +2513,28 @@ export class ClassDynamicDispatch {
                                     loc,
                                 });
                             }
-                            dispatch = { name, write: !!write, fn: helper, classes: new Set() };
+                            const receiverAccess = read
+                                ? [{ kind: "return", value: { ...read, value: varRef("p.0", DYN, loc) }, loc }]
+                                : [
+                                    {
+                                        kind: "exprStmt",
+                                        expr: {
+                                            ...write,
+                                            args: [varRef("p.0", DYN, loc), write.args[1], varRef("p.1", DYN, loc)],
+                                        },
+                                        loc,
+                                    },
+                                    { kind: "return", value: null, loc },
+                                ];
+                            dispatch = {
+                                name,
+                                write: !!write,
+                                fn: helper,
+                                classes: new Set(),
+                                ...(name !== "constructor" && name !== "toString"
+                                    ? { plain: { tail: [...helper.body], access: receiverAccess } }
+                                    : {}),
+                            };
                             this.properties.set(key, dispatch);
                             this.generated.add(helper);
                             lowerer.liftedFns.push(helper);
@@ -2044,14 +2565,14 @@ export class ClassDynamicDispatch {
                         : expr.kind === "dynInvoke"
                             ? expr
                             : null;
-                    const staticCandidates = invoke &&
-                        [...this.boxedConstructors].some((name) => {
-                            const info = lowerer.classes.get(name);
-                            return info && findStaticOn(lowerer, info, invoke.method)?.method;
-                        });
+                    // Static methods matter only for methods no instance answers.
+                    const staticCandidates = (method) => [...this.boxedConstructors].some((name) => {
+                        const info = lowerer.classes.get(name);
+                        return info && findStaticOn(lowerer, info, method)?.method;
+                    });
                     if (!invoke ||
                         (candidates(invoke.method).length === 0 &&
-                            !staticCandidates &&
+                            !staticCandidates(invoke.method) &&
                             !(invoke.method === "toString" && lowerer.classes.has("%Error"))))
                         return expr;
                     const key = JSON.stringify([
@@ -2316,17 +2837,41 @@ export class ClassDynamicDispatch {
                 });
                 changed = true;
             }
-            for (const plan of this.propertyReceivers(lowerer, true)) {
+            // Compute the candidates where the first plan would have, so the
+            // memoized set is the same whichever plans are already answered.
+            const plans = this.propertyReceivers(lowerer, true);
+            const matching = plans.length ? candidateSet(dispatch.source.method) : null;
+            for (const plan of plans) {
                 const { info } = plan;
-                if (!candidates(dispatch.source.method).includes(info) || dispatch.classes.has(plan.key))
+                if (dispatch.classes.has(plan.key) || !matching.has(info))
                     continue;
                 dispatch.classes.add(plan.key);
                 const loc = dispatch.source.loc;
-                const value = varRef("p.0", DYN, loc);
                 const { receiver, condition } = this.propertyReceiver(plan, loc);
                 if (isClassCallback(lowerer, info, dispatch.source.method)) {
                     const prototypeMethod = observedPrototypeMethod(lowerer, info, dispatch.source.method, loc, receiver);
-                    const bag = this.readPropertyBagOrEmpty(lowerer, value, loc);
+                    const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
+                    const methodKey = {
+                        kind: "strLit",
+                        value: dispatch.source.method,
+                        type: STRING,
+                        loc,
+                    };
+                    const bagHas = {
+                        kind: "libCall",
+                        fn: "dyn.hasKey",
+                        args: [bag, methodKey],
+                        type: BOOL,
+                        loc,
+                    };
+                    // An observed prototype slot answers through the bag when the bag
+                    // holds the name (own or through its prototype). A bag read as a
+                    // fresh empty object (an instance with no own dynamic properties
+                    // whose bag initializer predates the class's prototype data) does
+                    // not, so the method then comes from the class's prototype data.
+                    const prototype = prototypeMethod
+                        ? classPrototypeData(lowerer, info, loc, receiver)
+                        : null;
                     dispatch.callback.body.unshift({
                         kind: "if",
                         cond: condition,
@@ -2335,18 +2880,7 @@ export class ClassDynamicDispatch {
                                 kind: "return",
                                 value: {
                                     kind: "ternary",
-                                    cond: prototypeMethod
-                                        ? { kind: "boolLit", value: true, type: BOOL, loc }
-                                        : {
-                                            kind: "libCall",
-                                            fn: "dyn.hasKey",
-                                            args: [
-                                                bag,
-                                                { kind: "strLit", value: dispatch.source.method, type: STRING, loc },
-                                            ],
-                                            type: BOOL,
-                                            loc,
-                                        },
+                                    cond: prototype ? { kind: "boolLit", value: true, type: BOOL, loc } : bagHas,
                                     then: {
                                         kind: "dynObjLit",
                                         fields: [
@@ -2354,8 +2888,17 @@ export class ClassDynamicDispatch {
                                                 key: { kind: "strLit", value: "value", type: STRING, loc },
                                                 value: {
                                                     kind: "dynKeyGet",
-                                                    value: bag,
-                                                    key: { kind: "strLit", value: dispatch.source.method, type: STRING, loc },
+                                                    value: prototype
+                                                        ? {
+                                                            kind: "ternary",
+                                                            cond: bagHas,
+                                                            then: bag,
+                                                            else_: prototype,
+                                                            type: DYN,
+                                                            loc,
+                                                        }
+                                                        : bag,
+                                                    key: methodKey,
                                                     type: DYN,
                                                     loc,
                                                 },
@@ -2462,7 +3005,7 @@ export class ClassDynamicDispatch {
             for (const plan of this.propertyReceivers(lowerer)) {
                 if (plan.info !== plan.capsule ||
                     dispatch.classes.has(plan.key) ||
-                    (!dispatch.field && !candidates(dispatch.method).includes(plan.info)))
+                    (!dispatch.field && !candidateSet(dispatch.method).has(plan.info)))
                     continue;
                 dispatch.classes.add(plan.key);
                 const loc = dispatch.fn.loc;
@@ -2545,28 +3088,52 @@ export class ClassDynamicDispatch {
                     });
                     changed = true;
                 }
-            for (const plan of this.propertyReceivers(lowerer, true)) {
+            // Only the receivers that declare or hold the name, and the rooted
+            // ones, can pass the test, except for names it decides on every
+            // receiver. Fields added while bodies lower (the property bag and the
+            // attribute words) have compiler names, which take every receiver.
+            const plans = this.propertyReceivers(lowerer, true);
+            const anyReceiver = !isClassOwnEnumerableFieldName(dispatch.name) ||
+                dispatch.name === "constructor" ||
+                dispatch.name === "stack";
+            const skips = (plan) => !isClassOwnEnumerableFieldName(dispatch.name) ||
+                (!(plan.info.builtinStream !== undefined && streamProperty(dispatch.name)) &&
+                    !eventTargetInheritedMember(plan.info, dispatch.name) &&
+                    !dateInheritedMember(lowerer, plan.info, dispatch.name) &&
+                    !findMethodOn(lowerer, plan.info, dispatch.name) &&
+                    !findGenericMethodOn(lowerer, plan.info, dispatch.name) &&
+                    dispatch.name !== "constructor" &&
+                    !plan.info.fields.has(dispatch.name) &&
+                    !(dispatch.name === "stack" && lowerer.isSubclassOf(plan.info.def.name, "%Error")) &&
+                    !findMethodOn(lowerer, plan.info, `get:${dispatch.name}`) &&
+                    !findMethodOn(lowerer, plan.info, `set:${dispatch.name}`));
+            const selected = anyReceiver ? plans : receiversFor(plans, dispatch.name, "members");
+            if (CHECK_CANDIDATES &&
+                plans.some((plan) => !dispatch.classes.has(plan.key) && !skips(plan) && !selected.includes(plan)))
+                throw new InternalCompilerError(`indexed receivers for ${dispatch.name} differ`);
+            for (const plan of selected) {
                 const { info } = plan;
-                if (!isClassOwnEnumerableFieldName(dispatch.name) ||
-                    (!(info.builtinStream !== undefined && streamProperty(dispatch.name)) &&
-                        !eventTargetInheritedMember(info, dispatch.name) &&
-                        !findMethodOn(lowerer, info, dispatch.name) &&
-                        !findGenericMethodOn(lowerer, info, dispatch.name) &&
-                        dispatch.name !== "constructor" &&
-                        !info.fields.has(dispatch.name) &&
-                        !(dispatch.name === "stack" && lowerer.isSubclassOf(info.def.name, "%Error")) &&
-                        !findMethodOn(lowerer, info, `get:${dispatch.name}`) &&
-                        !findMethodOn(lowerer, info, `set:${dispatch.name}`)))
-                    continue;
+                // Classes answered in an earlier pass skip the member lookups.
                 if (dispatch.classes.has(plan.key))
                     continue;
+                if (skips(plan))
+                    continue;
                 dispatch.classes.add(plan.key);
                 const loc = dispatch.fn.loc;
                 const { receiver, condition } = this.propertyReceiver(plan, loc);
+                // The branch checks its receiver once: each use of the checked
+                // receiver would repeat the check.
+                const local = `receiver.${dispatch.fn.locals.length}`;
+                dispatch.fn.locals.push({
+                    id: local,
+                    name: "receiver",
+                    type: receiver.type,
+                    mutable: false,
+                });
                 const before = lowerer.diags.length;
                 let branch;
                 try {
-                    branch = this.propertyBody(lowerer, dispatch, info, receiver);
+                    branch = this.propertyBody(lowerer, dispatch, info, varRef(local, receiver.type, loc));
                 }
                 catch (error) {
                     if (!(error instanceof PoisonError) || !info.decl)
@@ -2579,7 +3146,7 @@ export class ClassDynamicDispatch {
                 dispatch.fn.body.unshift({
                     kind: "if",
                     cond: condition,
-                    then: branch,
+                    then: [{ kind: "varDecl", localId: local, init: receiver, loc }, ...branch],
                     else_: null,
                     loc,
                 });
@@ -2655,7 +3222,8 @@ export class ClassDynamicDispatch {
                             },
                         ];
                     if (((info.builtinStream !== undefined && streamProperty(name)) ||
-                        eventTargetInheritedMember(info, name)) &&
+                        eventTargetInheritedMember(info, name) ||
+                        dateInheritedMember(lowerer, info, name)) &&
                         dispatch.probe)
                         return [
                             {
@@ -2671,7 +3239,7 @@ export class ClassDynamicDispatch {
                     const prototypeMethod = !info.fields.has(name) && observedPrototypeMethod(lowerer, info, name, loc, receiver);
                     if (info.fields.has(name) || (dispatch.probe === "in" && !prototypeMethod)) {
                         if (info.fields.has(name) && info.def.tracksOwnFields) {
-                            const bag = this.readPropertyBagOrEmpty(lowerer, lowerer.coerceToExpected(receiver, DYN), loc);
+                            const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
                             const symbol = symbolMemberKey(lowerer, info, name, loc);
                             const fn = dispatch.probe === "in"
                                 ? "dyn.hasKey"
@@ -2696,7 +3264,7 @@ export class ClassDynamicDispatch {
                             { kind: "return", value: { kind: "boolLit", value: true, type: BOOL, loc }, loc },
                         ];
                     }
-                    const bag = this.readPropertyBagOrEmpty(lowerer, lowerer.coerceToExpected(receiver, DYN), loc);
+                    const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
                     const symbol = name.startsWith("sym:") || name.startsWith("%symbol:");
                     const fn = dispatch.probe === "in"
                         ? "dyn.hasKey"
@@ -2762,9 +3330,8 @@ export class ClassDynamicDispatch {
                     }
                     const branches = [];
                     if (!dispatch.write && !dispatch.reflect && !info.def.tracksOwnFields) {
-                        const value = varRef("p.0", DYN, loc);
                         const key = varRef("p.key", DYN, loc);
-                        const bag = this.readPropertyBagOrEmpty(lowerer, value, loc);
+                        const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
                         branches.push({
                             kind: "if",
                             cond: {
@@ -2866,6 +3433,10 @@ export class ClassDynamicDispatch {
                 if (inherited)
                     for (const name of inherited)
                         names.add(name);
+                if (dateRootOf(info))
+                    for (const name of DATE_PROTOTYPE_METHOD_NAMES)
+                        if (dateInheritedMember(lowerer, info, name))
+                            names.add(name);
                 for (let owner = info; owner; owner = owner.base) {
                     const methodNames = [...owner.methods.keys()];
                     if (owner.genericMethods)
@@ -3084,6 +3655,39 @@ export class ClassDynamicDispatch {
     }
     /** The receiver's own dynamic properties for a read: undefined while it has
      * none, and never stored, so reads stay valid on published objects. */
+    /** Statements that return `className`'s stand-in prototype: one empty
+     * object per class, created on first use and kept in a module global. */
+    prototypeStandIn(lowerer, className, loc) {
+        const globalId = `%g.%prototype.standIn.${className}`;
+        const readyId = `${globalId}.ready`;
+        if (!this.prototypeStandIns.has(className)) {
+            this.prototypeStandIns.add(className);
+            lowerer.globalsList.push({ id: globalId, name: `${className}.prototype`, type: DYN, mutable: true }, { id: readyId, name: `${className}.prototype.ready`, type: BOOL, mutable: true });
+        }
+        return [
+            {
+                kind: "if",
+                cond: { kind: "unary", op: "!", operand: varRef(readyId, BOOL, loc), type: BOOL, loc },
+                then: [
+                    {
+                        kind: "assign",
+                        localId: globalId,
+                        value: { kind: "dynObjLit", fields: [], type: DYN, loc },
+                        loc,
+                    },
+                    {
+                        kind: "assign",
+                        localId: readyId,
+                        value: { kind: "boolLit", value: true, type: BOOL, loc },
+                        loc,
+                    },
+                ],
+                else_: null,
+                loc,
+            },
+            { kind: "return", value: varRef(globalId, DYN, loc), loc },
+        ];
+    }
     readPropertyBag(lowerer, receiver, loc) {
         const helper = classPropertiesHelper(lowerer, loc, true);
         this.generated.add(helper);
@@ -3105,7 +3709,7 @@ export class ClassDynamicDispatch {
      * each class branch as small as the storing form. */
     readBagHas(lowerer, fn, bag, key, loc) {
         const name = fn === "dyn.hasKey" ? "%dyn.class.bagHas" : "%dyn.class.bagHasComputed";
-        let helper = lowerer.liftedFns.find((item) => item.name === name);
+        let helper = lowerer.liftedFnNamed(name);
         if (!helper) {
             const keyType = fn === "dyn.hasKey" ? STRING : DYN;
             const value = varRef("p.0", DYN, loc);
@@ -3498,6 +4102,66 @@ export class ClassDynamicDispatch {
             ];
             return { kind: "if", cond: condition, then: body, else_: null, loc };
         }
+        // Date.prototype[Symbol.toPrimitive] takes "default" as "string", and a
+        // class declared `extends Date` inherits Date's toString and valueOf,
+        // which answer primitives from the time value.
+        const dateRoot = dateRootOf(info);
+        if (dateRoot) {
+            const dateOrder = hint === "number" ? ["valueOf", "toString"] : ["toString", "valueOf"];
+            const { receiver } = this.propertyReceiver(plan, loc);
+            const body = [];
+            for (const method of dateOrder) {
+                if (!conversionMethod(lowerer, info, method)) {
+                    const time = {
+                        kind: "fieldGet",
+                        obj: upcastTo(lowerer, receiver, dateRoot.def.name),
+                        className: dateRoot.def.name,
+                        field: DATE_TIME_FIELD,
+                        type: DATE_T,
+                        loc,
+                    };
+                    body.push({
+                        kind: "return",
+                        value: lowerer.coerceToExpected(dateValueMethod(method, time, loc), DYN),
+                        loc,
+                    });
+                    break;
+                }
+                const result = `%toPrimitive.${method}.${helper.locals.length}`;
+                helper.locals.push({ id: result, name: method, type: DYN, mutable: false });
+                body.push({
+                    kind: "varDecl",
+                    localId: result,
+                    init: {
+                        kind: "call",
+                        callee: this.toPrimitiveCall(lowerer, plan, method, 0, loc),
+                        args: [varRef("p.0", DYN, loc)],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                }, {
+                    kind: "if",
+                    cond: isPrimitive(varRef(result, DYN, loc), loc),
+                    then: [{ kind: "return", value: varRef(result, DYN, loc), loc }],
+                    else_: null,
+                    loc,
+                });
+            }
+            if (body.at(-1)?.kind !== "return")
+                body.push({
+                    kind: "return",
+                    value: nodeThrowExpr(1, "", "Cannot convert object to primitive value", DYN, loc),
+                    loc,
+                });
+            return {
+                kind: "if",
+                cond: this.propertyReceiver(plan, loc).condition,
+                then: body,
+                else_: null,
+                loc,
+            };
+        }
         const order = hint === "string" ? ["toString", "valueOf"] : ["valueOf", "toString"];
         if (!order.some((method) => conversionMethod(lowerer, info, method)))
             return null;
@@ -3665,7 +4329,7 @@ export class ClassDynamicDispatch {
     readPropertyBagOrEmpty(lowerer, receiver, loc) {
         // One call per read site: large JS programs have a branch per class and
         // property, so the absent-bag handling lives in the shared helper.
-        let helper = lowerer.liftedFns.find((fn) => fn.name === READ_PROPERTIES_OR_EMPTY);
+        let helper = lowerer.liftedFnNamed(READ_PROPERTIES_OR_EMPTY);
         if (!helper) {
             // Settled by finalize; until then, the read-only bag's own dispatch.
             helper = {
@@ -3752,11 +4416,119 @@ export class ClassDynamicDispatch {
         lowerer.liftedFns.push(helper);
         return helper;
     }
+    /** The read-only bag a class branch reads for its receiver: the
+     * receiver's own field when the branch selected the receiver's exact
+     * class, otherwise the dispatch over every class (readPropertyBag, or
+     * readPropertyBagOrEmpty with `orEmpty`). */
+    branchPropertyBag(lowerer, info, receiver, orEmpty, loc) {
+        const helper = this.exactPropertyBag(lowerer, info, receiver, orEmpty, loc);
+        if (helper)
+            return { kind: "call", callee: helper.name, args: [receiver], type: DYN, loc };
+        return orEmpty
+            ? this.readPropertyBagOrEmpty(lowerer, lowerer.coerceToExpected(receiver, DYN), loc)
+            : this.readPropertyBag(lowerer, receiver, loc);
+    }
+    /** `%class.branchProperties[OrEmpty]:<class>(receiver)`: the read-only bag of
+     * an instance of exactly `info`. A class branch of the dispatch helpers
+     * selects a canonical receiver (normalizeDispatches gives an instance its
+     * actual class's capsule), so its branch for `info` sees only instances
+     * of `info`; instances of its subclasses take their own branches. Such a
+     * receiver needs neither the dispatch over every class nor a boxed copy of
+     * itself. Null
+     * when `receiver` is not typed as `info`, when a runtime or builtin class
+     * in the family keeps its own property contract, or before the class has
+     * a bag. */
+    exactPropertyBag(lowerer, info, receiver, orEmpty, loc) {
+        const type = receiver.type;
+        if (type.kind !== "object" || type.className !== info.def.name)
+            return null;
+        for (let current = info; current; current = current.base)
+            if (current.def.runtime ||
+                current.builtinEmitter ||
+                current.builtinStream ||
+                current.builtinError)
+                return null;
+        const key = `${type.className}:${orEmpty}`;
+        const existing = this.exactPropertyBags.get(key);
+        if (existing)
+            return existing;
+        const initializers = this.bagInitializers.get(type.className);
+        if (!initializers)
+            return null;
+        const self = varRef("p.0", type, loc);
+        const bag = {
+            kind: "fieldGet",
+            obj: self,
+            className: type.className,
+            field: PROPERTY_BAG,
+            type: DYN,
+            loc,
+        };
+        const initialize = {
+            ...initializers[0],
+            obj: self,
+            value: withTypedReceiver(initializers[0].value, self),
+            loc,
+        };
+        const helper = {
+            name: `%class.branchProperties${orEmpty ? "OrEmpty" : ""}:${type.className}`,
+            params: [{ localId: "p.0", name: "value", type }],
+            returnType: DYN,
+            locals: [{ id: "p.0", name: "value", type, mutable: false }],
+            loc,
+            body: [
+                {
+                    kind: "if",
+                    cond: { kind: "dynTest", test: "undefined", value: bag, type: BOOL, loc },
+                    then: [initialize],
+                    else_: null,
+                    loc,
+                },
+                { kind: "return", value: bag, loc },
+            ],
+        };
+        // Initializers gain their prototype as subclasses become constructible;
+        // finalize then turns the lazy store into the read's result.
+        initializers.push(initialize);
+        this.exactPropertyBags.set(key, helper);
+        this.readPropertyBags.push({ helper, initialize, orEmpty });
+        this.generated.add(helper);
+        lowerer.liftedFns.push(helper);
+        return helper;
+    }
     /** The prototype a new property bag of `current` (or of the subclass the
      * receiver is) starts from, or null when `current` has no prototype data.
      * A class with constructible subclasses that have prototype data selects
      * it through its `%class.bagPrototype` helper; any other class reads its
      * own prototype data. */
+    /** The lazy bag stores as they stand in the generated bodies, by class.
+     * Worklist passes that transform every function rebuild statement
+     * objects, so a recorded initializer can be a detached copy; a store that
+     * gains its prototype must be updated where it runs. */
+    liveBagInitializers() {
+        const live = new Map();
+        const add = (stmt) => {
+            if (stmt?.kind !== "if")
+                return;
+            const store = stmt.then[0];
+            if (store?.kind !== "fieldSet" || store.field !== PROPERTY_BAG)
+                return;
+            const list = live.get(store.className);
+            if (list)
+                list.push(store);
+            else
+                live.set(store.className, [store]);
+        };
+        // The complete dispatch guards each class's lazy store by its receiver.
+        for (const stmt of this.propertyBag?.body ?? [])
+            if (stmt.kind === "if")
+                add(stmt.then[0]);
+        for (const helper of this.typedPropertyBags.values())
+            add(helper.body[0]);
+        for (const helper of this.exactPropertyBags.values())
+            add(helper.body[0]);
+        return live;
+    }
     bagPrototype(lowerer, current, receiver, loc) {
         const arg = receiver.type.kind === "object" && receiver.type.className !== current.def.name
             ? {
@@ -3826,9 +4598,15 @@ export class ClassDynamicDispatch {
      * prototype-backed bag is produced for this read only. A published object
      * cannot take the store, and Node's reads never write. */
     finalize(lowerer) {
-        for (const { helper, initialize } of this.readPropertyBags) {
+        // Each table serves every site that reaches it.
+        if (lowerer)
+            for (const fn of this.generated)
+                lowerer.shareHelper(fn);
+        if (lowerer)
+            this.recordBagInitializers(lowerer);
+        for (const { helper, initialize, orEmpty } of this.readPropertyBags) {
             const absent = helper.body[0];
-            if (isEmptyBag(initialize.value))
+            if (isEmptyBag(initialize.value) && !orEmpty)
                 helper.body.shift();
             else if (absent?.kind === "if")
                 absent.then = [{ kind: "return", value: initialize.value, loc: initialize.loc }];
@@ -3842,6 +4620,170 @@ export class ClassDynamicDispatch {
             fn.locals = structuredClone(this.propertyBag.locals);
             fn.body = readOnlyBagBody(structuredClone(this.propertyBag.body), fn.name === READ_PROPERTIES_OR_EMPTY);
         }
+        if (lowerer)
+            this.guardClassTables(lowerer);
+        if (lowerer)
+            this.guardPropertyHelpers(lowerer);
+    }
+    /** Each tracked class's bag initializer over a typed receiver (`this`),
+     * for the per-class field-creation helpers (trackClassFieldCreation),
+     * which create an instance's bag without the class-table dispatch. */
+    recordBagInitializers(lowerer) {
+        for (const [className, initializers] of this.bagInitializers) {
+            const init = initializers[0];
+            if (!init || !lowerer.classes.get(className)?.def.tracksOwnFields)
+                continue;
+            const self = varRef("this", { kind: "object", className }, init.loc);
+            const value = withTypedReceiver(structuredClone(init.value), self);
+            if (mentionsLocal(value, "p.0"))
+                continue;
+            // The class-table branches can give the class's instances different
+            // bags (a base class's own prototype for its instances, the
+            // instance's class prototype for subclass instances); only a class
+            // whose branches all agree has one initializer for every instance.
+            const shape = withoutLocations(value);
+            if (initializers.some((other) => withoutLocations(withTypedReceiver(structuredClone(other.value), self)) !== shape))
+                continue;
+            // Lowerer stand-ins in unit tests may not carry the table.
+            lowerer.classBagInitializers?.set(className, value);
+        }
+    }
+    /** Fast exits for the generated class tables: every class branch of
+     * the property-bag, normalization and static-bag helpers tests the
+     * value's capsule key (or class key), so a value of another kind (a
+     * plain object, the common case in untyped code) skips straight to the
+     * table's fallthrough instead of testing every class in the program. */
+    guardClassTables(lowerer) {
+        const names = new Set([
+            "%dyn.class.properties",
+            READ_PROPERTIES,
+            READ_PROPERTIES_OR_EMPTY,
+            "%dyn.class.normalize",
+            "%dyn.class.staticProperties",
+        ]);
+        for (const fn of lowerer.liftedFns) {
+            if (!names.has(fn.name) || fn.body.length < 2)
+                continue;
+            const param = fn.params[0]?.localId;
+            if (param === undefined)
+                continue;
+            const last = fn.body[fn.body.length - 1];
+            if (last.kind !== "return" || last.value === null || !returnsParam(last.value, param))
+                continue;
+            let test = null;
+            let ok = true;
+            for (const stmt of fn.body.slice(0, -1)) {
+                if (stmt.kind === "assign" &&
+                    stmt.localId === param &&
+                    stmt.value.kind === "call" &&
+                    stmt.value.callee === "%dyn.class.normalize")
+                    continue;
+                const kind = stmt.kind === "if" && stmt.else_ === null ? branchKind(stmt.cond, param) : null;
+                if (kind === null || (test !== null && kind !== test)) {
+                    ok = false;
+                    break;
+                }
+                test = kind;
+            }
+            if (!ok || test === null)
+                continue;
+            const first = fn.body[0];
+            if (first.kind === "if" && first.cond.kind === "dynTest" && first.cond.test === test)
+                continue;
+            const loc = fn.loc;
+            fn.body.unshift({
+                kind: "if",
+                cond: {
+                    kind: "dynTest",
+                    test,
+                    negated: true,
+                    value: varRef(param, DYN, loc),
+                    type: BOOL,
+                    loc,
+                },
+                then: [structuredClone(last)],
+                else_: null,
+                loc,
+            });
+        }
+    }
+    /** Fast exits for the generated property helpers: when every class
+     * branch tests a capsule key or a class key and the fallthrough is still
+     * the bag access the helper was created with, a value of another kind
+     * (a plain object, array or primitive) normalizes to itself, has itself
+     * as its bag, and so gets the plain access directly, without the
+     * normalization, bag and static-bag calls. */
+    guardPropertyHelpers(lowerer) {
+        // Every class table the fallthrough or normalization calls must answer
+        // a plain value with the value itself: its kind exit is in place.
+        const exits = (name) => {
+            const helper = lowerer.liftedFnNamed(name);
+            const first = helper?.body[0];
+            const param = helper?.params[0]?.localId;
+            return (param !== undefined &&
+                first?.kind === "if" &&
+                first.cond.kind === "dynTest" &&
+                first.cond.negated === true &&
+                first.then.length === 1 &&
+                first.then[0].kind === "return" &&
+                first.then[0].value !== null &&
+                returnsParam(first.then[0].value, param));
+        };
+        const tables = new Set([
+            "%dyn.class.properties",
+            READ_PROPERTIES,
+            READ_PROPERTIES_OR_EMPTY,
+            "%dyn.class.normalize",
+            "%dyn.class.staticProperties",
+        ]);
+        const callsOnlyGuardedTables = (statements) => everyStmtList(statements, {
+            stmt: () => true,
+            expr: (expression) => expression.kind !== "call" || (tables.has(expression.callee) && exits(expression.callee)),
+        });
+        for (const dispatch of this.properties.values()) {
+            const plain = dispatch.plain;
+            if (!plain)
+                continue;
+            const fn = dispatch.fn;
+            const param = fn.params[0]?.localId;
+            if (param === undefined)
+                continue;
+            const head = fn.body.length - plain.tail.length;
+            if (head < 0 || plain.tail.some((stmt, i) => fn.body[head + i] !== stmt))
+                continue;
+            let ok = true;
+            for (const stmt of fn.body.slice(0, head)) {
+                if (stmt.kind === "assign" &&
+                    stmt.localId === param &&
+                    stmt.value.kind === "call" &&
+                    stmt.value.callee === "%dyn.class.normalize")
+                    continue;
+                if (stmt.kind === "if" && stmt.else_ === null && branchKind(stmt.cond, param) !== null)
+                    continue;
+                ok = false;
+                break;
+            }
+            // Class branches never run for a plain value; the rest always does.
+            if (!ok || !callsOnlyGuardedTables(fn.body.filter((stmt) => stmt.kind !== "if")))
+                continue;
+            const loc = fn.loc;
+            const not = (test) => ({
+                kind: "dynTest",
+                test,
+                negated: true,
+                value: varRef(param, DYN, loc),
+                type: BOOL,
+                loc,
+            });
+            fn.body.unshift({
+                kind: "if",
+                cond: not("classCapsule"),
+                then: [{ kind: "if", cond: not("funcKind"), then: plain.access, else_: null, loc }],
+                else_: null,
+                loc,
+            });
+            delete dispatch.plain;
+        }
     }
     normalizedDispatches() {
         return [
@@ -3913,10 +4855,15 @@ export class ClassDynamicDispatch {
             this.normalizationKey = key;
             const loc = this.normalization.loc;
             const value = varRef("value", DYN, loc);
-            this.normalization.body = entries.map(({ capsule, children }) => {
+            // The checked receiver is unboxed once per capsule branch, not once
+            // per subclass test.
+            this.normalization.locals = this.normalization.locals.filter((local) => !local.id.startsWith("%normalized."));
+            this.normalization.body = entries.map(({ capsule, children }, index) => {
                 const type = { kind: "object", className: capsule.def.name };
-                const receiver = { kind: "dynCheck", value, type, loc };
-                return {
+                const id = `%normalized.${index}`;
+                this.normalization.locals.push({ id, name: id, type, mutable: false });
+                const receiver = varRef(id, type, loc);
+                const branch = {
                     kind: "if",
                     cond: {
                         kind: "libCall",
@@ -3957,6 +4904,15 @@ export class ClassDynamicDispatch {
                     else_: null,
                     loc,
                 };
+                // The capsule test stays the branch condition; its body unboxes.
+                if (branch.kind === "if")
+                    branch.then.unshift({
+                        kind: "varDecl",
+                        localId: id,
+                        init: { kind: "dynCheck", value, type, loc },
+                        loc,
+                    });
+                return branch;
             });
             this.normalization.body.push({ kind: "return", value, loc });
         }
@@ -3997,21 +4953,43 @@ export class ClassDynamicDispatch {
         };
         add(root);
     }
+    /** propertyReceivers results by mode, with the class graph they were
+     * computed from: the boxed classes, the registered classes, the subclass
+     * links and the constructed classes only grow, so equal counts and the
+     * same capsules give the same plans. */
+    receiverPlans = new Map();
     /** A capsule retains its static type, while its object may be a subclass.
      * Preorder insertion lets later branches test the most derived layout first. */
     propertyReceivers(lowerer, streams = false, normalize = true) {
+        const mode = `${streams}:${normalize}`;
+        const revision = `${this.boxed.size}:${lowerer.classes.size}:${lowerer.subclassLinks}:${lowerer.constructedClassCount()}`;
+        const cached = this.receiverPlans.get(mode);
+        if (cached?.revision === revision) {
+            let i = 0;
+            let same = true;
+            for (const name of this.boxed)
+                if (lowerer.classes.get(name) !== cached.capsules[i++])
+                    same = false;
+            if (same)
+                return cached.plans;
+        }
+        const capsules = [];
         const plans = [];
         const seen = new Set();
         for (const name of this.boxed) {
             const capsule = lowerer.classes.get(name);
+            capsules.push(capsule);
             if (!capsule ||
                 ((capsule.builtinEmitter || capsule.builtinStream) && !streams) ||
                 capsule.builtinError)
                 continue;
             const canonical = normalize && !capsule.builtinStream && !capsule.builtinEmitter;
             const visit = (info) => {
-                if ((!canonical || !seen.has(info.def.name)) &&
-                    (info === capsule || lowerer.classCanBeConstructed(info))) {
+                // A seen class was visited with its whole subtree, and a canonical
+                // visit adds no plan for a seen class.
+                if (canonical && seen.has(info.def.name))
+                    return;
+                if (info === capsule || lowerer.classCanBeConstructed(info)) {
                     seen.add(info.def.name);
                     plans.push({
                         info,
@@ -4024,6 +5002,7 @@ export class ClassDynamicDispatch {
             };
             visit(capsule);
         }
+        this.receiverPlans.set(mode, { revision, capsules, plans });
         return plans;
     }
     propertyReceiver(plan, loc) {
@@ -4204,9 +5183,11 @@ export class ClassDynamicDispatch {
     propertyBody(lowerer, dispatch, info, receiver) {
         const { name, write } = dispatch;
         const loc = dispatch.fn.loc;
-        // The inherited EventTarget/Event members of a subclass instance: the
-        // runtime's capsule view answers the accessors and method values.
-        if (eventTargetInheritedMember(info, name)) {
+        // The inherited EventTarget/Event members of a subclass instance, and
+        // the inherited Date methods of an instance of a class declared
+        // `extends Date`: the runtime's capsule view answers the accessors and
+        // method values.
+        if (eventTargetInheritedMember(info, name) || dateInheritedMember(lowerer, info, name)) {
             const key = { kind: "strLit", value: name, type: STRING, loc };
             if (!write)
                 return [
@@ -4348,7 +5329,7 @@ export class ClassDynamicDispatch {
                             },
                             {
                                 kind: "if",
-                                cond: this.readBagHas(lowerer, "dyn.hasKey", this.readPropertyBag(lowerer, receiver, loc), key, loc),
+                                cond: this.readBagHas(lowerer, "dyn.hasKey", this.branchPropertyBag(lowerer, info, receiver, false, loc), key, loc),
                                 then: [store],
                                 else_: null,
                                 loc,
@@ -4360,7 +5341,7 @@ export class ClassDynamicDispatch {
                     { kind: "return", value: null, loc },
                 ];
             }
-            const bag = this.readPropertyBag(lowerer, receiver, loc);
+            const bag = this.branchPropertyBag(lowerer, info, receiver, false, loc);
             return [
                 {
                     kind: "return",
@@ -4418,7 +5399,7 @@ export class ClassDynamicDispatch {
                 !info.classDecorators) {
                 this.constructors.set(info.def.name, info);
                 const cls = lowerer.coerceToExpected(classValueRef(lowerer, info, info.decl), DYN);
-                const bag = this.readPropertyBag(lowerer, receiver, loc);
+                const bag = this.branchPropertyBag(lowerer, info, receiver, false, loc);
                 const key = { kind: "strLit", value: name, type: STRING, loc };
                 return [
                     {
@@ -4489,7 +5470,7 @@ export class ClassDynamicDispatch {
                     if (symbol || (isClassOwnEnumerableFieldName(name) && !name.startsWith("sym:"))) {
                         const prototypeMethod = observedPrototypeMethod(lowerer, info, name, loc, receiver);
                         // Selecting the method must not give the object own storage.
-                        const bag = this.readPropertyBag(lowerer, receiver, loc);
+                        const bag = this.branchPropertyBag(lowerer, info, receiver, false, loc);
                         const key = symbol ?? { kind: "strLit", value: name, type: STRING, loc };
                         body.push({
                             kind: "if",
@@ -4550,7 +5531,7 @@ export class ClassDynamicDispatch {
             }
             if (!field && !accessor) {
                 const instance = lowerer.coerceToExpected(receiver, DYN);
-                const bag = this.readPropertyBagOrEmpty(lowerer, instance, loc);
+                const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
                 const key = { kind: "strLit", value: name, type: STRING, loc };
                 const own = {
                     kind: "libCall",
@@ -4598,7 +5579,7 @@ export class ClassDynamicDispatch {
             if (boxed.kind === "dynFrom" && mutable(boxed.value.type))
                 boxed.liveRef = true;
             if (accessor) {
-                const bag = this.readPropertyBagOrEmpty(lowerer, lowerer.coerceToExpected(receiver, DYN), loc);
+                const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
                 const key = { kind: "strLit", value: name, type: STRING, loc };
                 return [
                     {
@@ -4625,7 +5606,7 @@ export class ClassDynamicDispatch {
             }
             if (field && info.def.tracksOwnFields) {
                 const instance = lowerer.coerceToExpected(receiver, DYN);
-                const bag = this.readPropertyBagOrEmpty(lowerer, instance, loc);
+                const bag = this.branchPropertyBag(lowerer, info, receiver, true, loc);
                 const symbol = symbolMemberKey(lowerer, info, name, loc);
                 const key = symbol ?? { kind: "strLit", value: name, type: STRING, loc };
                 return [
@@ -4730,6 +5711,50 @@ export class ClassDynamicDispatch {
             };
         return [store, { kind: "return", value: null, loc }];
     }
+    /** EventEmitter.prototype's introspection and bookkeeping members on an
+     * emitter seen through an untyped value: Node's results over the native
+     * listener registry. */
+    emitterIntrospection(lowerer, dispatch, receiver) {
+        const { method, loc } = dispatch.source;
+        const incoming = dispatch.source.args.map((_, i) => varRef(`p.${i + 1}`, DYN, loc));
+        const ret = (value) => [
+            { kind: "return", value: lowerer.coerceToExpected(value, DYN), loc },
+        ];
+        const call = (fn, args, type) => ({
+            kind: "libCall",
+            fn,
+            args: [receiver, ...args],
+            type,
+            loc,
+        });
+        // Node indexes _events with the argument itself: an omitted name is
+        // the key "undefined".
+        const eventName = () => incoming.length
+            ? lowerer.coerceToExpected(incoming[0], STRING)
+            : { kind: "strLit", value: "undefined", type: STRING, loc };
+        switch (method) {
+            case "listenerCount":
+                return ret(incoming.length >= 2
+                    ? call("emitter.countDyn", [eventName(), incoming[1]], F64)
+                    : call("emitter.count", [eventName()], F64));
+            case "eventNames":
+                return ret(call("emitter.names", [], { kind: "array", elem: STRING }));
+            case "removeAllListeners":
+                return ret(incoming.length
+                    ? call("emitter.removeAll", [eventName(), { kind: "boolLit", value: false, type: BOOL, loc }], receiver.type)
+                    : call("emitter.removeAll", [
+                        { kind: "strLit", value: "", type: STRING, loc },
+                        { kind: "boolLit", value: true, type: BOOL, loc },
+                    ], receiver.type));
+            case "listeners":
+            case "rawListeners":
+                return ret(call("emitter.listenersDyn", [eventName()], DYN));
+            case "setMaxListeners":
+                return ret(call("emitter.setMaxChk", [incoming[0] ?? dynUndefinedExpr(loc)], receiver.type));
+            default:
+                return ret(call("emitter.getMax", [], F64));
+        }
+    }
     methodBody(lowerer, dispatch, info, receiver) {
         const { method, loc } = dispatch.source;
         const fence = () => [
@@ -4740,6 +5765,12 @@ export class ClassDynamicDispatch {
                 loc,
             },
         ];
+        if (emitterRooted(lowerer, info) &&
+            !streamRooted(info) &&
+            EMITTER_INTROSPECTION_METHODS.has(method) &&
+            !findMethodOn(lowerer, info, method)) {
+            return this.emitterIntrospection(lowerer, dispatch, receiver);
+        }
         if (info.builtinStream ||
             (emitterRooted(lowerer, info) &&
                 EMITTER_METHODS.has(method) &&
@@ -4759,10 +5790,14 @@ export class ClassDynamicDispatch {
             if (method === "emit") {
                 if (!incoming.length)
                     return fence();
-                return ret({
+                const event = lowerer.coerceToExpected(incoming[0], STRING);
+                const bridged = streamRooted(info)
+                    ? null
+                    : lowerDynamicEmitterEmit(lowerer, receiver, event, incoming.slice(1), loc);
+                return ret(bridged ?? {
                     kind: "libCall",
-                    fn: "emitter.emitFlex",
-                    args: [receiver, lowerer.coerceToExpected(incoming[0], STRING), ...incoming.slice(1)],
+                    fn: "emitter.emitAny",
+                    args: [receiver, event, ...incoming.slice(1)],
                     type: BOOL,
                     loc,
                 });
@@ -4772,6 +5807,11 @@ export class ClassDynamicDispatch {
                     return fence();
                 const event = lowerer.coerceToExpected(incoming[0], STRING);
                 const cb = incoming[1];
+                const bridged = registering && !streamRooted(info)
+                    ? lowerDynamicEmitterOn(lowerer, receiver, event, cb, method === "once" || method === "prependOnceListener", method.startsWith("prepend"), loc)
+                    : null;
+                if (bridged)
+                    return ret(bridged);
                 return [
                     {
                         kind: "exprStmt",
@@ -4783,7 +5823,7 @@ export class ClassDynamicDispatch {
                         fn: registering
                             ? info.builtinStream
                                 ? "stream.onDyn"
-                                : "emitter.onFlex"
+                                : "emitter.onAny"
                             : "emitter.offDyn",
                         args: [
                             receiver,
@@ -4837,13 +5877,16 @@ export class ClassDynamicDispatch {
                 const arg = (i) => incoming[i] ?? dynUndefinedExpr(loc);
                 const readableT = { kind: "object", className: "%Readable" };
                 const op = (fn, args, type) => ret({ kind: "libCall", fn: fn, args: [receiver, ...args], type, loc });
+                // Node passes every callback its { signal }; the callback's
+                // declared parameters are not known here.
+                const sig = () => operatorSignalOptions(lowerer, arg(1), loc);
                 switch (method) {
                     case "map":
-                        return op("readable.opMap", [arg(0), arg(1)], readableT);
+                        return op("readable.opMap", [arg(0), arg(1), sig()], readableT);
                     case "filter":
-                        return op("readable.opFilter", [arg(0), arg(1)], readableT);
+                        return op("readable.opFilter", [arg(0), arg(1), sig()], readableT);
                     case "flatMap":
-                        return op("readable.opFlatMap", [arg(0), arg(1)], readableT);
+                        return op("readable.opFlatMap", [arg(0), arg(1), sig()], readableT);
                     case "drop":
                         return op("readable.opDrop", [arg(0), arg(1)], readableT);
                     case "take":
@@ -4851,21 +5894,45 @@ export class ClassDynamicDispatch {
                     case "toArray":
                         return op("readable.opToArray", [arg(0)], { kind: "promise", inner: DYN });
                     case "forEach":
-                        return op("readable.opForEach", [arg(0), arg(1)], { kind: "promise", inner: VOID });
+                        return op("readable.opForEach", [arg(0), arg(1), sig()], {
+                            kind: "promise",
+                            inner: VOID,
+                        });
                     case "some":
-                        return op("readable.opSome", [arg(0), arg(1)], { kind: "promise", inner: BOOL });
+                        return op("readable.opSome", [arg(0), arg(1), sig()], { kind: "promise", inner: BOOL });
                     case "every":
-                        return op("readable.opEvery", [arg(0), arg(1)], { kind: "promise", inner: BOOL });
+                        return op("readable.opEvery", [arg(0), arg(1), sig()], {
+                            kind: "promise",
+                            inner: BOOL,
+                        });
                     case "find":
-                        return op("readable.opFind", [arg(0), arg(1)], { kind: "promise", inner: DYN });
-                    case "reduce":
-                        return op("readable.opReduce", [
-                            arg(0),
-                            arg(1),
-                            { kind: "boolLit", value: dispatch.source.args.length >= 2, type: BOOL, loc },
-                            arg(2),
-                            { kind: "numLit", value: 0, type: F64, loc },
-                        ], { kind: "promise", inner: DYN });
+                        return op("readable.opFind", [arg(0), arg(1), sig()], { kind: "promise", inner: DYN });
+                    case "reduce": {
+                        // the dispatch function's locals: there is no function
+                        // context while dispatch bodies are built
+                        const setup = reduceSignalSetup(lowerer, arg(2), loc, (name, type) => {
+                            const local = {
+                                id: `${name}.${dispatch.fn.locals.length}`,
+                                name,
+                                type,
+                                mutable: false,
+                            };
+                            dispatch.fn.locals.push(local);
+                            return local;
+                        });
+                        return [
+                            ...setup.stmts,
+                            ...op("readable.opReduceSignal", [
+                                arg(0),
+                                arg(1),
+                                { kind: "boolLit", value: dispatch.source.args.length >= 2, type: BOOL, loc },
+                                arg(2),
+                                { kind: "numLit", value: 0, type: F64, loc },
+                                setup.abort,
+                                setup.cbOpts,
+                            ], { kind: "promise", inner: DYN }),
+                        ];
+                    }
                 }
             }
             if (method === "destroy" && (!incoming.length || incoming[0]?.kind === "unitLit"))
@@ -5113,4 +6180,12 @@ const INHERITED_OBJECT_METHODS = new Set([
     "hasOwnProperty",
     "propertyIsEnumerable",
 ]);
+/** Whether a class or one of its bases has a heritage evaluated at run
+ * time, whose prototype chain may reach Error.prototype. */
+function hasRuntimeHeritage(info) {
+    for (let current = info; current; current = current.base)
+        if (current.callableBase)
+            return true;
+    return false;
+}
 //# sourceMappingURL=class-dynamic-dispatch.js.map