@scriptc/compiler 0.4.2 → 0.4.4

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

@@ -28,7 +28,7 @@ import { ClassConstructionDispatch } from "./class-construction.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",
@@ -252,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,
@@ -295,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) {
@@ -549,6 +580,111 @@ export function classForInHasKey(lowerer, value, key, loc) {
     }
     return { kind: "call", callee: name, args: [value, key], type: BOOL, loc };
 }
+/** Box class instances at their exact class. `%dyn.class.normalize` turns a
+ * capsule of a class with subclasses into a capsule of the instance's own
+ * class before any member table reads it, so every such box was followed
+ * by a second capsule. Each conversion of a value whose static class has a
+ * normalization branch now selects the exact class at the conversion, with
+ * the same tests in the same order (%dyn.class.boxExact:C), and the
+ * normalization of the resulting capsule falls through. Only JavaScript
+ * class hierarchies, whose instances live in untyped code, take the exact
+ * box. */
+export function boxClassInstancesExactly(lowerer, functions) {
+    const normalize = lowerer.liftedFnNamed("%dyn.class.normalize");
+    if (!normalize)
+        return;
+    // Static class → its constructible descendants in normalization order.
+    const branches = new Map();
+    for (const stmt of normalize.body) {
+        if (stmt.kind !== "if" || stmt.cond.kind !== "libCall" || stmt.cond.fn !== "dyn.typedRefIs")
+            continue;
+        const key = stmt.cond.args[1];
+        if (key?.kind !== "strLit" || !key.value.startsWith("object:"))
+            continue;
+        const children = [];
+        for (const inner of stmt.then) {
+            if (inner.kind !== "if" || inner.cond.kind !== "instanceOf")
+                continue;
+            children.push(inner.cond.className);
+        }
+        // TypeScript hierarchies keep their static-class capsules: their boxes
+        // are rarer, and an exact box would emit each subclass's checked view.
+        const className = key.value.slice("object:".length);
+        const decl = lowerer.classes.get(className)?.decl;
+        if (!decl || !isJsSourceFile(ts.getSourceFileOfNode(decl)))
+            continue;
+        if (children.length)
+            branches.set(className, children);
+    }
+    if (branches.size === 0)
+        return;
+    const loc = normalize.loc;
+    const helpers = new Map();
+    const helperFor = (className) => {
+        const known = helpers.get(className);
+        if (known !== undefined)
+            return known;
+        const name = `%dyn.class.boxExact:${className}`;
+        helpers.set(className, name);
+        const type = { kind: "object", className };
+        const value = varRef("value", type, loc);
+        functions.push({
+            name,
+            params: [{ localId: "value", name: "value", type }],
+            returnType: DYN,
+            locals: [{ id: "value", name: "value", type, mutable: false }],
+            body: [
+                ...branches.get(className).map((child) => ({
+                    kind: "if",
+                    cond: { kind: "instanceOf", value, className: child, type: BOOL, loc },
+                    then: [
+                        {
+                            kind: "return",
+                            value: {
+                                kind: "dynFrom",
+                                value: {
+                                    kind: "downcast",
+                                    value,
+                                    type: { kind: "object", className: child },
+                                    loc,
+                                },
+                                type: DYN,
+                                loc,
+                            },
+                            loc,
+                        },
+                    ],
+                    else_: null,
+                    loc,
+                })),
+                { kind: "return", value: { kind: "dynFrom", value, type: DYN, loc }, loc },
+            ],
+            loc,
+        });
+        return name;
+    };
+    const rewrite = (fn) => {
+        fn.body = transformStmtList(fn.body, {
+            stmt: (statement) => statement,
+            expr: (expression) => expression.kind === "dynFrom" &&
+                expression.value.type.kind === "object" &&
+                branches.has(expression.value.type.className)
+                ? {
+                    kind: "call",
+                    callee: helperFor(expression.value.type.className),
+                    args: [expression.value],
+                    type: DYN,
+                    loc: expression.loc,
+                }
+                : expression,
+        });
+    };
+    for (const fn of [...functions]) {
+        if (fn === normalize || fn.name.startsWith("%dyn.class.boxExact:"))
+            continue;
+        rewrite(fn);
+    }
+}
 /** Record field creation after the dispatch worklist closes, including writes
  * in generated member tables. Native values stay in their slots; the bag
  * owns only their property presence, attributes, and insertion position. */
@@ -557,15 +693,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),
             ],
@@ -633,77 +905,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
@@ -724,6 +1020,9 @@ export class ClassDynamicDispatch {
     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();
@@ -755,8 +1054,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). */
@@ -797,6 +1105,7 @@ export class ClassDynamicDispatch {
                 return;
             seenTypes.add(key);
             if (type.kind === "object") {
+                this.boxedStatic.add(type.className);
                 if (isDynTypedRefType(type))
                     this.boxed.add(type.className);
             }
@@ -947,9 +1256,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, {
@@ -959,7 +1270,7 @@ export class ClassDynamicDispatch {
                     loc,
                 });
                 if (prototype)
-                    this.prototypeIdentityHelper.body.unshift({
+                    this.errorPrototypeHelper.body.unshift({
                         kind: "if",
                         cond: {
                             kind: "libCall",
@@ -968,7 +1279,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,
                     });
@@ -1033,6 +1356,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;
@@ -1102,7 +1520,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) {
@@ -1113,6 +1535,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;
                     }
                 }
@@ -1137,6 +1567,15 @@ export class ClassDynamicDispatch {
                     this.deletedNames = deletedPropertyNames(lowerer.moduleOrder);
                 if (!root.base?.def.runtime && !fixedFieldFamily(root, this.deletedNames))
                     track(root);
+                // An Error family's bag records where `name` and `message` were
+                // created, which the error slots do not.
+                if (root.base?.def.name === "%Error") {
+                    const order = (current) => {
+                        current.def.errorBagOrder = true;
+                        current.subclasses.forEach(order);
+                    };
+                    order(info);
+                }
             }
             const loc = this.propertyBag.loc;
             const { receiver, condition } = this.propertyReceiver(plan, loc);
@@ -1358,29 +1797,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,
@@ -2152,7 +2627,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);
@@ -3273,6 +3769,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);
@@ -4086,6 +4615,34 @@ export class ClassDynamicDispatch {
      * 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
             ? {
@@ -4159,6 +4716,8 @@ export class ClassDynamicDispatch {
         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) && !orEmpty)
@@ -4175,6 +4734,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 [
@@ -4246,10 +4969,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",
@@ -4290,6 +5018,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 });
         }
@@ -5254,13 +5991,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":
@@ -5268,21 +6008,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"))
@@ -5530,4 +6294,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