@swf2es/runtime 0.1.15 → 0.1.17

package/dist/avm2/runtime.js

@@ -21,18 +21,18 @@ import { NAMED } from "./dictionary-keys.js";
 import { compileUnit, Domain, definitionNames, findScript } from "./domain.js";
 import { isViewRangeError, SharedMemoryView } from "./domain-memory.js";
 import { continues, dictionaryAt, elementsAt, enumerated, INT_ATOM_LIMIT, nextIndex, ownNames, pairIndex, pairOf, walkless, } from "./enumeration.js";
-import { AsError, describe, errorMessage, stackOf } from "./errors.js";
+import { AsError, describe, detailOf, errorMessage, stackOf, UnsupportedError } from "./errors.js";
 import { FloatValue, floatValue } from "./float.js";
 import { hookedBinding } from "./hooks.js";
 import { installMethod, nativeFactory, noBodyFactory, unverifiedFactory, verifyErrorFactory, } from "./method-factories.js";
 import { Modules } from "./modules.js";
-import { arrayIndex, CONSTANT_Multiname, CONSTANT_MultinameA, CONSTANT_MultinameL, CONSTANT_MultinameLA, CONSTANT_Qname, CONSTANT_RTQname, CONSTANT_RTQnameA, CONSTANT_RTQnameL, CONSTANT_RTQnameLA, Multiname, Namespace, NS_Private, NS_Public, namespace, prefixedNamespace, prefixOf, publicNs, publicQname, qname, TypeName, } from "./names.js";
+import { arrayIndex, CONSTANT_Multiname, CONSTANT_MultinameA, CONSTANT_MultinameL, CONSTANT_MultinameLA, CONSTANT_Qname, CONSTANT_RTQname, CONSTANT_RTQnameA, CONSTANT_RTQnameL, CONSTANT_RTQnameLA, MADE_Number, MADE_Value, Multiname, Namespace, NS_Private, NS_Public, namespace, prefixedNamespace, prefixOf, publicNs, publicQname, qname, TypeName, } from "./names.js";
 import { FloatVector, setFloatElement } from "./natives/float-vector.js";
 import { storeDouble, storeInt, storeObject, } from "./natives/vector-elements.js";
 import { escapeAttributeValue, escapeElementValue } from "./natives/xml/escape.js";
 import { numberToString, stringToNumber } from "./number-strings.js";
 import { defaultPrint, memoryFiles, } from "./options.js";
-import { cached, epoch, IC_Call, IC_Const, IC_Dynamic, IC_Get, IC_GetSet, IC_Method, IC_Set, IC_Slot, invalidate, NO_CACHE, REPLACEMENTS, UNFILLED, } from "./property-cache.js";
+import { cached, epoch, IC_Call, IC_Const, IC_Dynamic, IC_Get, IC_GetSet, IC_Method, IC_Set, IC_Slot, invalidate, NO_CACHE, ScopeFinds, UNFILLED, } from "./property-cache.js";
 import { BIND_Const, BIND_Get, BIND_GetSet, BIND_Method, BIND_Set, BIND_Var, boundKey, ClassRef, methodKey, slotKey, Traits, untypedSetKey, VectorRef, } from "./traits.js";
 export { NOT_FOUND } from "./descriptors.js";
 /**
@@ -54,7 +54,27 @@ class ScopePack {
         this.w = w;
     }
 }
+/** Whether a chain or a pack, `scopes` with bits `w`, has a with scope, in a pack in it too. */
+function hasWith(scopes, w) {
+    for (let i = 0; i < scopes.length; i++) {
+        const o = scopes[i];
+        if (o instanceof ScopePack ? hasWith(o.scopes, o.w) : (w >> i) & 1) {
+            return true;
+        }
+    }
+    return false;
+}
 /** The value of `o`'s dynamic property `name`, or NOT_FOUND. */
+/** Whether k is an int atom avmplus can take as a uint: an integer of 0 to 2^32-1, -0 not, as it is a double's. */
+function uintAtom(k) {
+    return typeof k === "number" && k >>> 0 === k && (k !== 0 || 1 / k > 0);
+}
+/** Whether v is an object's atom to avmplus: not null, nor a Namespace or float, whose atoms are their own. */
+function isScriptObject(v) {
+    return (typeof v === "object" && v !== null && !(v instanceof Namespace) && !(v instanceof FloatValue));
+}
+/** The name avmplus' getUintProperty looks a number up by: public, at every version. */
+const ELEMENT_NAME = new Multiname(CONSTANT_MultinameL, [publicNs], [255], null, false);
 function dynamicValue(o, name) {
     const d = o.$d;
     if (!d) {
@@ -67,6 +87,7 @@ export class Runtime {
     classHooks;
     print;
     debugger;
+    onUnsupported;
     compileAbc;
     files;
     /** See RuntimeOptions.workers and worker. */
@@ -127,6 +148,13 @@ export class Runtime {
     /** The builtin classes' traits, made before their classes so the bootstrap can refer to them. */
     objectTraits;
     classTraits;
+    /**
+     * What the super operations of a script's methods and of a class's
+     * static ones look in, as avmplus' script traits extend Object and a
+     * class object's traits Class: their `super` is that class's instance.
+     */
+    scriptSuper;
+    staticSuper;
     functionTraits;
     /**
      * Method closures, by receiver and method, so that o.f === o.f; by the
@@ -147,7 +175,7 @@ export class Runtime {
     /** Special traits: an activation's or a catch scope's, by descriptor. */
     scopeTraits = new WeakMap();
     specialized = new Map();
-    empty = Object.assign([], { w: 0 });
+    empty = Object.assign([], { w: 0, found: undefined });
     /**
      * `natives` are the natives by name, or a provider that makes them for
      * this runtime, so that a natives module can close over its runtime (as a
@@ -158,6 +186,7 @@ export class Runtime {
         this.classHooks = classHooks;
         this.print = options.print ?? defaultPrint;
         this.debugger = options.debugger ?? false;
+        this.onUnsupported = options.onUnsupported;
         this.compileAbc = options.compileAbc ?? null;
         this.files = options.files ?? memoryFiles();
         this.workerHost = options.workers ?? null;
@@ -177,6 +206,8 @@ export class Runtime {
         this.objectTraits.dynamic = true;
         this.objectTraits.testsValues = true;
         this.classTraits = new Traits("Class", this.objectTraits);
+        this.scriptSuper = { $it: this.objectTraits };
+        this.staticSuper = { $it: this.classTraits };
         this.functionTraits = new Traits("Function", this.objectTraits);
         this.functionTraits.dynamic = true;
         this.natives = typeof natives === "function" ? natives(this) : natives;
@@ -289,6 +320,7 @@ export class Runtime {
                 // Its string only once a lookup needs it: a Dictionary does not.
                 const keyed = Multiname.keyed(kind, namespaces, versions, part, mn.attribute, this.keyName);
                 keyed.domain = mn.domain;
+                keyed.made = MADE_Value;
                 return keyed;
             }
             else {
@@ -297,6 +329,37 @@ export class Runtime {
         }
         const named = new Multiname(kind, namespaces, versions, name, mn.attribute);
         named.domain = mn.domain;
+        // A number here is one no element access made: a Proxy tells it by its string.
+        if (mn.runtimeName && typeof last !== "number") {
+            named.made = MADE_Value;
+        }
+        return named;
+    }
+    /**
+     * The name runtimeName makes of `mn`, a MultinameL, and a string the
+     * code itself holds, `obj["name"]`: a module makes it once as it loads
+     * and keeps it as it keeps `mn`, so it has a cache as a module's own
+     * names have, however many such names the module has and however long
+     * the string is.
+     */
+    literalName(mn, name) {
+        const named = new Multiname(mn.kind, mn.namespaces, mn.versions, name, mn.attribute);
+        named.domain = mn.domain;
+        named.made = MADE_Value;
+        named.cache = UNFILLED;
+        return named;
+    }
+    /**
+     * The name number `i` makes of `mn` in an element's read or write, which
+     * avmplus' JIT hands an object as a number (getpropertylate_i and _d), a
+     * Proxy as its string: where the name has no public namespace, it is a
+     * name as any other.
+     */
+    indexName(mn, i) {
+        const named = this.runtimeName(mn, i);
+        if (mn.kind === CONSTANT_MultinameL && mn.elementName) {
+            named.made = MADE_Number;
+        }
         return named;
     }
     stringNames = new WeakMap();
@@ -318,6 +381,7 @@ export class Runtime {
         }
         const named = new Multiname(base.kind, base.namespaces, base.versions, name, base.attribute);
         named.domain = base.domain;
+        named.made = MADE_Value;
         if (!cache) {
             cache = { names: new Map(), misses: 0 };
             this.stringNames.set(base, cache);
@@ -417,6 +481,7 @@ export class Runtime {
             const traits = new Traits("global", this.objectTraits);
             traits.dynamic = true;
             traits.isGlobal = true;
+            traits.abc = script.abc;
             traits.describe(script.desc.traits);
             const g = traits.instance();
             // As the script's initializer, its methods run in an empty scope chain,
@@ -424,7 +489,9 @@ export class Runtime {
             // indexes the scopes their closures capture: the global object is
             // only what they push.
             for (const [d, factory, id, , params] of script.desc.traits.methods) {
-                installMethod(this, traits.methodHome(3), d, withId(factory(this.empty, null), id), factory, params);
+                const method = withId(factory(this.empty, this.scriptSuper), id);
+                this.keepStatic(factory, method);
+                installMethod(this, traits.methodHome(3), d, method, factory, params);
             }
             // Caches keep the methods.
             invalidate();
@@ -449,7 +516,7 @@ export class Runtime {
         if (script.state === 0 || (retry && script.state === 3)) {
             script.state = 1;
             try {
-                script.desc.init(this.empty, null).call(g);
+                script.desc.init(this.empty, this.scriptSuper).call(g);
             }
             catch (e) {
                 script.state = 3;
@@ -490,6 +557,7 @@ export class Runtime {
     scope(outer, locals, withs) {
         const chain = outer.concat(locals);
         chain.w = outer.w | (withs << outer.length);
+        chain.found = undefined;
         return chain;
     }
     /**
@@ -504,6 +572,7 @@ export class Runtime {
         const packed = chain.slice(0, at);
         packed.push(new ScopePack(chain.slice(at), chain.w >>> at));
         packed.w = (chain.w & ((1 << at) - 1)) | (1 << at);
+        packed.found = undefined;
         return packed;
     }
     /**
@@ -532,6 +601,40 @@ export class Runtime {
                 return locals[i];
             }
         }
+        const found = this.outerScopeOf(outer, mn);
+        if (found !== null) {
+            return found;
+        }
+        return this.global(mn, outer.length ? outer[0] : locals[0], strict);
+    }
+    /**
+     * The innermost object of a captured chain that has `mn`, or null: kept
+     * on a chain without a with scope (ScopeFinds), as a function whose
+     * chain the compiler could not type, such as one made where chains of
+     * different lengths meet, looks its names up each time it runs.
+     */
+    outerScopeOf(outer, mn) {
+        let finds = outer.found;
+        if (finds === undefined) {
+            finds = hasWith(outer, outer.w) ? null : new ScopeFinds();
+            outer.found = finds;
+        }
+        // A name made at run time is a new one each time: keeping it would only grow the map.
+        if (finds === null || mn.cache === NO_CACHE) {
+            return this.searchOuter(outer, mn);
+        }
+        if (finds.epoch !== epoch()) {
+            finds.clear();
+            finds.epoch = epoch();
+        }
+        let o = finds.get(mn);
+        if (o === undefined) {
+            o = this.searchOuter(outer, mn);
+            finds.set(mn, o);
+        }
+        return o;
+    }
+    searchOuter(outer, mn) {
         for (let i = outer.length - 1; i >= 0; i--) {
             const o = outer[i];
             if (o instanceof ScopePack) {
@@ -544,7 +647,7 @@ export class Runtime {
                 return o;
             }
         }
-        return this.global(mn, outer.length ? outer[0] : locals[0], strict);
+        return null;
     }
     findPropertyStrict(mn, outer, locals, withs) {
         return this.findProperty(mn, outer, locals, withs, true);
@@ -669,15 +772,22 @@ export class Runtime {
     traitsOf(v) {
         switch (typeof v) {
             case "object":
-            case "function":
+            case "function": {
                 if (v === null) {
                     throw this.error("TypeError", 1009);
                 }
+                // An object's own first: instanceof walks the whole prototype
+                // chain of an object, and a class's is as deep as its bases.
+                const traits = v.$traits;
+                if (traits !== undefined) {
+                    return traits;
+                }
                 return v instanceof FloatValue
                     ? this.builtinTraits("float")
                     : v instanceof Namespace
                         ? this.builtinTraits("Namespace")
-                        : v.$traits;
+                        : traits;
+            }
             // As avmplus' toVTable: every number is a Number at run time, int or
             // not; int's and uint's traits only bind early, from static types.
             case "number":
@@ -698,12 +808,17 @@ export class Runtime {
     receiverTraits(v) {
         switch (typeof v) {
             case "object":
-            case "function":
-                return v instanceof FloatValue
-                    ? this.builtinTraits("float")
-                    : v === null
-                        ? undefined
-                        : v.$traits;
+            case "function": {
+                if (v === null) {
+                    return undefined;
+                }
+                // A float and a Namespace have none of their own (see traitsOf).
+                const traits = v.$traits;
+                if (traits !== undefined) {
+                    return traits;
+                }
+                return v instanceof FloatValue ? this.builtinTraits("float") : undefined;
+            }
             case "string":
                 return this.stringTraits;
             case "number":
@@ -840,7 +955,7 @@ export class Runtime {
                 mn.kind === CONSTANT_MultinameA ||
                 mn.kind === CONSTANT_MultinameL ||
                 mn.kind === CONSTANT_MultinameLA);
-        throw this.error("ReferenceError", name === null && nsset ? 1081 : 1069, mn.name ?? "*", traits.name);
+        throw this.error("ReferenceError", name === null && nsset ? 1081 : 1069, mn.name ?? "*", traits.errorName);
     }
     /**
      * obj[i] for a number i, as avmplus' getUintProperty: a Vector's,
@@ -877,7 +992,7 @@ export class Runtime {
                 }
             }
         }
-        return this.getProperty(o, this.runtimeName(mn, i));
+        return this.getProperty(o, this.indexName(mn, i));
     }
     /** obj[i] = v for a number i, as avmplus' setUintProperty. */
     setIndexed(o, mn, i, v) {
@@ -889,12 +1004,114 @@ export class Runtime {
                 traits.setIndex(o, i, v, this);
                 return;
             }
-            if (o.$a !== undefined && o.$a !== SEALED_ELEMENTS && i !== 0xffffffff) {
-                o.$a[i] = v;
-                return;
+            const a = o.$a;
+            if (a !== undefined) {
+                if (a !== SEALED_ELEMENTS && i !== 0xffffffff) {
+                    a[i] = v;
+                    return;
+                }
+            }
+            else if (traits?.dynamic && traits.properties === null && !traits.refusesNames) {
+                // As ScriptObject::setUintProperty: an object with no elements of its own keeps the
+                // number among its dynamic properties, with no binding asked for.
+                const d = o.$d;
+                if (d) {
+                    d.set(`${i}`, v);
+                    return;
+                }
+            }
+        }
+        this.setProperty(o, this.indexName(mn, i), v);
+    }
+    /**
+     * obj[k] by a runtime name with no public namespace, or an attribute's,
+     * in a script's or a class's initializer, which avmplus interprets: its
+     * getproperty reads an int key of at least 0 off an object by
+     * getUintProperty, whatever namespaces the name has, where its JIT asks
+     * for a public one (getIndexed). Any other key makes a name.
+     */
+    getInterpreted(o, mn, k) {
+        if (uintAtom(k) && isScriptObject(o)) {
+            return this.getIndexed(o, ELEMENT_NAME, k);
+        }
+        return this.getProperty(o, this.runtimeName(mn, k));
+    }
+    /** obj[k] = v as getInterpreted reads it, as avmplus' interpreter's setproperty. */
+    setInterpreted(o, mn, k, v) {
+        if (uintAtom(k) && isScriptObject(o)) {
+            this.setIndexed(o, ELEMENT_NAME, k, v);
+            return;
+        }
+        this.setProperty(o, this.runtimeName(mn, k), v);
+    }
+    /**
+     * obj[k] for a key whose type the compiler does not know, by a name with
+     * no namespace from the stack, as avmplus' getprop_index and
+     * getpropertyHelper: a number is an index (getIndexed), an object a
+     * Dictionary has as a key is read by itself, and anything else, a QName
+     * and a Dictionary's absent key among them, is looked up by the name it
+     * makes.
+     */
+    getKeyed(o, mn, k) {
+        let r;
+        if (typeof k === "number") {
+            r = this.getIndexed(o, mn, k);
+            return r;
+        }
+        if (typeof k === "object" && k !== null) {
+            const keys = o?.$keys;
+            if (keys !== undefined) {
+                if (!mn.elementName) {
+                    r = this.getProperty(o, this.runtimeName(mn, this.unkeyed(k)));
+                    return r;
+                }
+                // What is there was put there by a name with the object as its key, which a QName's is not.
+                const v = keys.get(k);
+                if (v !== undefined) {
+                    return v;
+                }
             }
         }
-        this.setProperty(o, this.runtimeName(mn, i), v);
+        r = this.getProperty(o, this.runtimeName(mn, k));
+        return r;
+    }
+    /**
+     * An object given as the key of a Dictionary by a name with no public
+     * namespace, as the name is made of it: avmplus' JIT asks a Dictionary
+     * for an object only through getprop_index and setprop_index, which such
+     * a name does not reach, so the object is its string, as on any other
+     * receiver (initMultinameLate); a QName names what it names. Its
+     * interpreter asks the Dictionary by any name, as a name made without
+     * this does: the compiler leaves script and class initializers to that.
+     */
+    unkeyed(k) {
+        return k.$traits !== undefined && k.$local === undefined ? this.toString(k) : k;
+    }
+    /** obj[k] = v for a key whose type the compiler does not know, as avmplus' setprop_index and setpropertyHelper. */
+    setKeyed(o, mn, k, v) {
+        if (typeof k === "number") {
+            this.setIndexed(o, mn, k, v);
+            return;
+        }
+        if (typeof k === "object" && k !== null) {
+            const keys = o?.$keys;
+            if (keys !== undefined) {
+                if (!mn.elementName) {
+                    this.setProperty(o, this.runtimeName(mn, this.unkeyed(k)), v);
+                    return;
+                }
+                if (keys.replace(k, v)) {
+                    return;
+                }
+                // A new key: an object of traits, which a float and a Namespace are not, and no QName,
+                // which names what it names. Those are added, or not, by the name they make.
+                if (k.$traits !== undefined && k.$local === undefined) {
+                    keys.add(k, v);
+                    return;
+                }
+            }
+        }
+        this.setProperty(o, this.runtimeName(mn, k), v);
     }
     /**
      * Element i of Vector o set to x, already converted, as
@@ -1084,18 +1301,16 @@ export class Runtime {
                 if (slot !== undefined) {
                     return o[slot];
                 }
-                throw this.error("ReferenceError", 1077, mn.name ?? "*", traits.name);
+                throw this.error("ReferenceError", 1077, mn.name ?? "*", traits.errorName);
             }
             default:
-                throw this.error("ReferenceError", 1077, mn.name ?? "*", traits.name);
+                throw this.error("ReferenceError", 1077, mn.name ?? "*", traits.errorName);
         }
     }
     /** fillCache (cache-fill.ts), for a name that caches on traits a cache knows `o` by. */
     fill(o, traits, b, mn) {
         const head = mn.cache;
-        if (head === NO_CACHE ||
-            (head.replaced === REPLACEMENTS && head.epoch === epoch()) ||
-            this.receiverTraits(o) !== traits) {
+        if (head === NO_CACHE || this.receiverTraits(o) !== traits) {
             return;
         }
         fillCache(head, o, traits, b, mn);
@@ -1124,6 +1339,8 @@ export class Runtime {
             f.$length = method.$length ?? method.length;
             f.$id = method.$id ?? 0;
             f.$closure = true;
+            // Whose method it is, for moduleOf.
+            f.$of = traits;
             if (typeof o === "object") {
                 byMethod.set(method, f);
             }
@@ -1176,7 +1393,7 @@ export class Runtime {
             switch (b & 7) {
                 case BIND_Const:
                     if (!init) {
-                        throw this.error("ReferenceError", 1074, mn.name ?? "*", traits.name);
+                        throw this.error("ReferenceError", 1074, mn.name ?? "*", traits.errorName);
                     }
                     o[slotKey(id)] = this.coerce(v, traits.slotType(id));
                     return;
@@ -1188,9 +1405,9 @@ export class Runtime {
                     (traits.proto[untypedSetKey(id + 1)] ?? traits.proto[methodKey(id + 1)]).call(o, v);
                     return;
                 case BIND_Method:
-                    throw this.error("ReferenceError", 1037, mn.name ?? "*", traits.name);
+                    throw this.error("ReferenceError", 1037, mn.name ?? "*", traits.errorName);
                 default:
-                    throw this.error("ReferenceError", 1074, mn.name ?? "*", traits.name);
+                    throw this.error("ReferenceError", 1074, mn.name ?? "*", traits.errorName);
             }
         }
         const name = mn.dynamicName();
@@ -1212,7 +1429,7 @@ export class Runtime {
                 return;
             }
         }
-        throw this.error("ReferenceError", 1056, mn.name ?? "*", traits.name);
+        throw this.error("ReferenceError", 1056, mn.name ?? "*", traits.errorName);
     }
     initProperty(o, mn, v) {
         this.setProperty(o, mn, v, true);
@@ -1227,7 +1444,7 @@ export class Runtime {
         }
         // A primitive's property cannot be deleted, as MethodEnv's delproperty has it.
         if (typeof o !== "object" || o instanceof Namespace) {
-            throw this.error("ReferenceError", 1120, mn.name ?? "*", this.traitsOf(o).name);
+            throw this.error("ReferenceError", 1120, mn.name ?? "*", this.traitsOf(o).errorName);
         }
         // E4X 11.3.1: delete x[list] is a TypeError, as in delete x.a.(b == 1).
         if (mn.key?.$nodes !== undefined) {
@@ -1388,8 +1605,7 @@ export class Runtime {
         // A namespace is the runtime's own object: its prototype is its class's.
         if (typeof o === "object" &&
             o !== null &&
-            !(o instanceof Namespace) &&
-            !(o instanceof FloatValue)) {
+            (o.$traits !== undefined || !(o instanceof Namespace || o instanceof FloatValue))) {
             return o.$p;
         }
         return this.traitsOf(o).proto.$p;
@@ -1402,6 +1618,28 @@ export class Runtime {
     publicName(name) {
         return qname(publicNs, this.nameString(name));
     }
+    // Natives' typed reach into AS3 objects (as3-types.ts): getProperty,
+    // setProperty and callProperty of the public name, the lookup natives
+    // made before, with the name checked against the class's declarations
+    // when compiled.
+    /** `o`'s public property `name`: a variable, constant or accessor its class declares. */
+    prop(o, name) {
+        // biome-ignore lint/style/useConst: a const is folded into a tail call (see getProperty)
+        let r;
+        r = this.getProperty(o, this.publicName(name));
+        return r;
+    }
+    /** Sets `o`'s public property `name`, which its class declares writable. */
+    setProp(o, name, v) {
+        this.setProperty(o, this.publicName(name), v);
+    }
+    /** Calls `o`'s public method `name` with `args`. */
+    callProp(o, name, ...args) {
+        // biome-ignore lint/style/useConst: a const is folded into a tail call (see getProperty)
+        let r;
+        r = this.callProperty(o, this.publicName(name), ...args);
+        return r;
+    }
     /** A property name as a string, as ToString makes one. */
     nameString(name) {
         return typeof name === "string" ? name : this.toString(name);
@@ -1615,8 +1853,30 @@ export class Runtime {
         }
         return key;
     }
-    callStatic(_abc, m, ..._args) {
-        throw this.unsupported(`callstatic ${m}`);
+    /**
+     * The first method each factory made for a class's or a script's
+     * traits, as avmplus' AbcEnv keeps the first MethodEnv of each method
+     * a vtable makes (VTable::makeMethodEnv): what callstatic calls.
+     */
+    staticMethods = new WeakMap();
+    /** Keep `method`, made by `factory`, for callstatic, unless it made one before. */
+    keepStatic(factory, method) {
+        if (!this.staticMethods.has(factory)) {
+            this.staticMethods.set(factory, method);
+        }
+    }
+    /**
+     * callstatic: method `factory` made, called on `o` with its arguments,
+     * which the compiler coerced. avmplus verifies a method when it first
+     * runs and refuses one that calls a method no vtable has made yet
+     * (1107); that is found here only once the call is reached.
+     */
+    callStatic(factory, o, ...args) {
+        const method = this.staticMethods.get(factory);
+        if (method === undefined) {
+            throw this.error("VerifyError", 1107);
+        }
+        return method.apply(o, args);
     }
     // The super operations, as MethodEnv's: by the base class's traits
     // alone, a name they do not bind a ReferenceError, not a dynamic property.
@@ -1629,7 +1889,7 @@ export class Runtime {
             return r;
         }
         if (b === 0) {
-            throw this.error("ReferenceError", 1070, mn.name ?? "*", traits.name);
+            throw this.error("ReferenceError", 1070, mn.name ?? "*", traits.errorName);
         }
         r = this.callValue(this.getBound(o, traits, b, mn), o, args, mn);
         return r;
@@ -1638,7 +1898,7 @@ export class Runtime {
         const traits = sup.$it;
         const b = traits.find(mn);
         if (b === 0) {
-            throw this.error("ReferenceError", 1069, mn.name ?? "*", traits.name);
+            throw this.error("ReferenceError", 1069, mn.name ?? "*", traits.errorName);
         }
         return this.getBound(o, traits, b, mn);
     }
@@ -1655,11 +1915,11 @@ export class Runtime {
                 o[slotKey(id)] = this.coerce(v, traits.slotType(id));
                 return;
             case BIND_Method:
-                throw this.error("ReferenceError", 1037, mn.name ?? "*", traits.name);
+                throw this.error("ReferenceError", 1037, mn.name ?? "*", traits.errorName);
             case 0:
-                throw this.error("ReferenceError", 1056, mn.name ?? "*", traits.name);
+                throw this.error("ReferenceError", 1056, mn.name ?? "*", traits.errorName);
             default:
-                throw this.error("ReferenceError", 1074, mn.name ?? "*", traits.name);
+                throw this.error("ReferenceError", 1074, mn.name ?? "*", traits.errorName);
         }
     }
     constructSuper(sup, o, ...args) {
@@ -1809,6 +2069,19 @@ export class Runtime {
         this.functionObjects.set(method, f);
         return f;
     }
+    /**
+     * The module a function's code is from, as avmplus has a method's code
+     * context: a function's by the global object its scope begins with, a
+     * bound method's by its receiver's class; null for a native, a class's
+     * own method, or anything but a function.
+     */
+    moduleOf(f) {
+        const o = f;
+        if (o?.$of) {
+            return o.$of.abc;
+        }
+        return o?.$global ? this.traitsOf(o.$global).abc : null;
+    }
     /** A Function object calling `f`, with `global` as its receiver when it has none. */
     newFunctionObject(f, global) {
         const o = this.functionTraits.instance();
@@ -2044,7 +2317,7 @@ export class Runtime {
                 if (v.$traits === traits || this.isInstanceOf(v, traits)) {
                     return v;
                 }
-                throw this.error("TypeError", 1034, this.describe(v), traits.name);
+                throw this.error("TypeError", 1034, this.describe(v), traits.errorName);
             }
         }
     }
@@ -2065,7 +2338,7 @@ export class Runtime {
         if (v.$traits === traits || this.isInstanceOf(v, traits)) {
             return v;
         }
-        throw this.error("TypeError", 1034, this.describe(v), traits.name);
+        throw this.error("TypeError", 1034, this.describe(v), traits.errorName);
     }
     coerceString(v) {
         return v === null || v === undefined ? null : typeof v === "string" ? v : this.toString(v);
@@ -2264,7 +2537,7 @@ export class Runtime {
                 return v;
             }
         }
-        throw this.error("TypeError", 1050, o.$traits.name);
+        throw this.error("TypeError", 1050, o.$traits.errorName);
     }
     add(a, b) {
         if (typeof a === "number" && typeof b === "number") {
@@ -2543,12 +2816,21 @@ export class Runtime {
         catch {
             return new AsError(`${name}: ${message}`);
         }
-        return this.constructClass(cls, [message, id]);
+        const made = this.constructClass(cls, [message, id]);
+        // What the number stands for, kept beside the message for a host's report (detailOf).
+        if (!this.debugger) {
+            Object.defineProperty(made, "$detail", { value: errorMessage(true, id, args) });
+        }
+        return made;
     }
     /** See stackOf in errors.ts. */
     stackOf(error) {
         return stackOf(error);
     }
+    /** See detailOf in errors.ts. */
+    detailOf(error) {
+        return detailOf(error);
+    }
     /** See errorMessage in errors.ts. */
     errorMessage(id, args = []) {
         return errorMessage(this.debugger, id, args);
@@ -2573,11 +2855,35 @@ export class Runtime {
         if (isViewRangeError(e)) {
             return this.error("RangeError", 1506);
         }
+        if (e instanceof UnsupportedError) {
+            return this.unsupportedCaught(e);
+        }
         if (e instanceof Error && !(e instanceof AsError)) {
             throw e;
         }
         return e;
     }
+    /** What a catch was told of already (unsupportedCaught). */
+    unsupportedTold = new Set();
+    /**
+     * What is not supported as the AS3 error a catch gets: an
+     * IllegalOperationError with its message, or an Error where the player's
+     * classes are not loaded; said once to the host, as the code may say nothing.
+     */
+    unsupportedCaught(e) {
+        if (!this.unsupportedTold.has(e.message)) {
+            this.unsupportedTold.add(e.message);
+            this.onUnsupported?.(e.message);
+        }
+        let cls;
+        try {
+            cls = this.resolve(this.cls(namespace(NS_Public, "flash.errors"), "IllegalOperationError"));
+        }
+        catch {
+            cls = this.builtinClass("Error");
+        }
+        return this.constructClass(cls, [e.message, 0]);
+    }
     catches(e, type) {
         return this.isInstanceOf(e, this.traitsOfType(type));
     }
@@ -2585,7 +2891,7 @@ export class Runtime {
         return new Error("swf2es: a dispatcher reached no block");
     }
     unsupported(what) {
-        return new Error(`swf2es: ${what} is not supported yet`);
+        return new UnsupportedError(`swf2es: ${what} is not supported yet`);
     }
     // Class aliases and the classes AMF makes (amf-classes.ts).
     registerClassAlias(name, cls) {