@swf2es/runtime 0.0.0-stage → 0.1.1

package/src/avm2/hooks.ts

@@ -0,0 +1,97 @@
+// What the natives and a player plug into the runtime for the builtin
+// classes that differ from others: how they allocate, index, resolve
+// names, and are called and constructed.
+
+import type { AsObject, Method, Value } from "./descriptors.js";
+import { type Multiname, NS_Public } from "./names.js";
+import type { Runtime } from "./runtime.js";
+import { BIND_Method, type Traits } from "./traits.js";
+
+/** How a class that holds its own elements indexes them. */
+export interface IndexHook {
+  getIndex: (o: AsObject, i: number, rt: Runtime) => Value;
+  setIndex: (o: AsObject, i: number, v: Value, rt: Runtime) => void;
+  hasIndex: (o: AsObject, i: number) => boolean;
+  /** A name's element index, -1 if it names none; the class's own rule, else an array index's. */
+  index?: (o: AsObject, name: string, rt: Runtime) => number;
+}
+
+/**
+ * How a class's instances resolve the names their traits do not bind, in
+ * place of dynamic properties, as XML and XMLList do (E4X's [[Get]] and so
+ * on): each operation, their enumeration, and their equality and +.
+ */
+export interface PropertyHook {
+  /**
+   * Whether a public method's name resolves through the hook too, as a
+   * child or attribute of XML hides the methods of its names, or is the
+   * method the traits bind, as a Proxy's is.
+   */
+  hidesMethods: boolean;
+  get(rt: Runtime, o: AsObject, mn: Multiname): Value;
+  set(rt: Runtime, o: AsObject, mn: Multiname, v: Value): void;
+  delete(rt: Runtime, o: AsObject, mn: Multiname): boolean;
+  has(rt: Runtime, o: AsObject, mn: Multiname): boolean;
+  /** callproperty: what a name calls, looked for as the class does. */
+  callee(rt: Runtime, o: AsObject, mn: Multiname): Value;
+  descendants(rt: Runtime, o: AsObject, mn: Multiname): Value;
+  /** The index after `index` for a for-in, or 0; and the name and value at one. */
+  nextIndex(rt: Runtime, o: AsObject, index: number): number;
+  nextName(rt: Runtime, o: AsObject, index: number): Value;
+  nextValue(rt: Runtime, o: AsObject, index: number): Value;
+  /** ==, when either side is an instance, or undefined to leave it to the rest. */
+  equals(rt: Runtime, a: Value, b: Value): boolean | undefined;
+  /** +, when both sides are an instance or another hooked class's, or undefined. */
+  add(rt: Runtime, a: Value, b: Value): Value;
+  /** An instance's string, as its primitive value. */
+  toString(rt: Runtime, o: AsObject): string;
+  /** An instance as XML text, as esc_xelem writes it. */
+  toXMLString(rt: Runtime, o: AsObject): string;
+}
+
+/**
+ * Whether a hooked class's hook resolves `mn`, bound to `b`: a name its
+ * traits do not bind, an attribute's, or a public name of a method, as a
+ * child or attribute of XML hides the methods of its names (as avmplus'
+ * getproperty does for XML and XMLList).
+ */
+export function hookedBinding(b: number, mn: Multiname, hook: PropertyHook): boolean {
+  if (b === 0 || mn.attribute) {
+    return true;
+  }
+
+  return (
+    hook.hidesMethods &&
+    (b & 7) === BIND_Method &&
+    mn.namespaces.some((ns) => ns?.kind === NS_Public && ns.uri === "")
+  );
+}
+
+/** Natives by name, or a function that makes them for the runtime they will serve. */
+export type NativesProvider =
+  | Record<string, (rt: Runtime) => Method>
+  | ((rt: Runtime) => Record<string, (rt: Runtime) => Method>);
+
+/** How a builtin class differs from others: allocation, index access, calls and construction. */
+export interface ClassHook {
+  /** How its instances resolve names, as XML's (Traits.properties). */
+  properties?: PropertyHook;
+  /** A playerglobal set-only accessor whose bodyless setter stores in an instance slot. */
+  setOnlySlots?: Record<string, string>;
+  create?: (traits: Traits, rt: Runtime) => AsObject;
+  /** Its prototype object, when not an Object: an instance of the class, as Date's (its $it is ready). */
+  prototype?: (rt: Runtime, cls: AsObject) => AsObject;
+  /** Whether its instances refuse any name but their own and an index, as a Vector's (Traits.refusesNames). */
+  refusesNames?: boolean;
+  getIndex?: IndexHook["getIndex"];
+  setIndex?: IndexHook["setIndex"];
+  hasIndex?: IndexHook["hasIndex"];
+  index?: IndexHook["index"];
+  construct?: (rt: Runtime, cls: AsObject, args: Value[]) => Value;
+  call?: (rt: Runtime, cls: AsObject, args: Value[]) => Value;
+  apply?: (rt: Runtime, factory: AsObject, params: Value[]) => AsObject;
+  /** What the VM sets up on the class once its static initializer has run, as avmshell's Worker.current. */
+  created?: (rt: Runtime, cls: AsObject) => void;
+  /** As construct="restricted": a subclass from another ABC cannot be constructed, nor what extends it. */
+  restricted?: boolean;
+}

package/src/avm2/index.ts

@@ -0,0 +1,84 @@
+// The AVM2 runtime: what generated modules call as `rt`.
+import { builtinHooks, builtinNatives } from "./natives/index.js";
+import type { RuntimeOptions } from "./options.js";
+import { Runtime } from "./runtime.js";
+
+export { Reader as Amf3Reader, Writer as Amf3Writer } from "./amf.js";
+/** avmplus' builtin.abc (MPL-2.0), which every runtime loads first. */
+export { builtinLibrary } from "./builtin-library.js";
+export type { Abc, AsObject, CompileUnit, FoundDefinition, Method, Value } from "./descriptors.js";
+export { type Domain, frameScripts, frameSites, siteScript, stackFrames } from "./domain.js";
+export { FloatValue, hasFloatLibrary } from "./float.js";
+export { floatLibrary } from "./float-library.js";
+export type { ClassHook, NativesProvider } from "./hooks.js";
+export { messages } from "./messages.js";
+export { publicNs, qname } from "./names.js";
+export {
+  Bytes,
+  byteArrayHook,
+  bytesOf,
+  canShareMemory,
+  GLOBAL_MEMORY_MIN_SIZE,
+  notIsolated,
+  type SharedBytesMemory,
+  setDomainMemory,
+  shareBytes,
+  sharedByteArray,
+} from "./natives/bytearray.js";
+export {
+  type SyncRef,
+  syncError,
+  syncObject,
+  syncOf,
+  syncRef,
+} from "./natives/concurrent.js";
+export type { Natives } from "./natives/define.js";
+export { type NativeClass, plain, registerNativeClass } from "./natives/define.js";
+// The builtins' natives and hooks, for a player that adds playerglobal's to them.
+export { builtinHooks, builtinNatives } from "./natives/index.js";
+export {
+  endShellWorker,
+  shellWorkerTerminated,
+  startShellWorker,
+} from "./natives/shell-workers.js";
+export {
+  newSyncMemory,
+  SCRIPT_TIMEOUT,
+  Sync,
+  SyncFull,
+  type SyncInit,
+  type SyncMemory,
+  SyncTerminated,
+  SyncTimeout,
+} from "./natives/sync.js";
+// avmplus' XML tokenizer, which playerglobal's flash.xml.XMLDocument parses with too.
+export { XMLParser, XMLTag } from "./natives/xml/parser.js";
+export type {
+  RuntimeOptions,
+  ShellFiles,
+  ShellThread,
+  ShellWorkerHost,
+  ShellWorkerInit,
+  ShellWorkersMemory,
+} from "./options.js";
+export { errorMessages } from "./player-messages.js";
+// A destroyed host must not remain reachable through shared inline-cache entries.
+export { invalidate as clearPropertyCaches } from "./property-cache.js";
+export { Runtime } from "./runtime.js";
+// methodKey: where a method sits on its traits, for a player that makes a closure of its own.
+export { instanceVarField, methodKey, setStaticVar } from "./traits.js";
+
+/** A runtime with the builtins' natives, for modules compiled from builtin.abc and after. */
+export function createRuntime(options: RuntimeOptions = {}): Runtime {
+  return new Runtime(builtinNatives, builtinHooks(), options);
+}
+
+/** AS3 `int(value)`: ToInt32(ToNumber(value)). */
+export function toInt(value: unknown): number {
+  return Number(value) | 0;
+}
+
+/** AS3 `uint(value)`: ToUint32(ToNumber(value)). */
+export function toUint(value: unknown): number {
+  return Number(value) >>> 0;
+}

package/src/avm2/messages.ts

@@ -0,0 +1,178 @@
+// Error messages of avmplus, in English, by error number.
+//
+// Generated from oracle/avmplus/core/ErrorConstants.cpp; not to be edited.
+// Derived from avmplus, this file is subject to the Mozilla Public License,
+// v. 2.0: http://mozilla.org/MPL/2.0/.
+
+export const messages: Record<number, string> = {
+  1000: "The system is out of memory.",
+  1001: "The method %1 is not implemented.",
+  1002: "Number.toPrecision has a range of 1 to 21. Number.toFixed and Number.toExponential have a range of 0 to 20. Specified value is not within expected range.",
+  1003: "The radix argument must be between 2 and 36; got %1.",
+  1004: "Method %1 was invoked on an incompatible object.",
+  1005: "Array index is not a positive integer (%1).",
+  1006: "%1 is not a function.",
+  1007: "Instantiation attempted on a non-constructor.",
+  1008: "%1 is ambiguous; Found more than one matching binding.",
+  1009: "Cannot access a property or method of a null object reference.",
+  1010: "A term is undefined and has no properties.",
+  1011: "Method %1 contained illegal opcode %2 at offset %3.",
+  1012: "The last instruction exceeded code size.",
+  1013: "Cannot call OP_findproperty when scopeDepth is 0.",
+  1014: "Class %1 could not be found.",
+  1015: "Method %1 cannot set default xml namespace",
+  1016: "Descendants operator (..) not supported on type %1.",
+  1017: "Scope stack overflow occurred.",
+  1018: "Scope stack underflow occurred.",
+  1019: "Getscopeobject %1 is out of bounds.",
+  1020: "Code cannot fall off the end of a method.",
+  1021: "At least one branch target was not on a valid instruction in the method.",
+  1022: "Type void may only be used as a function return type.",
+  1023: "Stack overflow occurred.",
+  1024: "Stack underflow occurred.",
+  1025: "An invalid register %1 was accessed.",
+  1026: "Slot %1 exceeds slotCount=%2 of %3.",
+  1027: "Method_info %1 exceeds method_count=%2.",
+  1028: "Disp_id %1 exceeds max_disp_id=%2 of %3.",
+  1029: "Disp_id %1 is undefined on %2.",
+  1030: "Stack depth is unbalanced. %1 != %2.",
+  1031: "Scope depth is unbalanced. %1 != %2.",
+  1032: "Cpool index %1 is out of range %2.",
+  1033: "Cpool entry %1 is wrong type.",
+  1034: "Type Coercion failed: cannot convert %1 to %2.",
+  1035: "Illegal super expression found in method %1.",
+  1037: "Cannot assign to a method %1 on %2.",
+  1038: "%1 is already defined.",
+  1039: "Cannot verify method until it is referenced.",
+  1040: "The right-hand side of instanceof must be a class or function.",
+  1041: "The right-hand side of operator must be a class.",
+  1042: "Not an ABC file.  major_version=%1 minor_version=%2.",
+  1043: "Invalid code_length=%1.",
+  1044: "MethodInfo-%1 unsupported flags=%2.",
+  1045: "Unsupported traits kind=%1.",
+  1046: "MethodInfo-%1 referenced before definition.",
+  1047: "No entry point was found.",
+  1049: "Prototype objects must be vanilla Objects.",
+  1050: "Cannot convert %1 to primitive.",
+  1051: "Illegal early binding access to %1.",
+  1052: "Invalid URI passed to %1 function.",
+  1053: "Illegal override of %1 in %2.",
+  1054: "Illegal range or target offsets in exception handler.",
+  1056: "Cannot create property %1 on %2.",
+  1057: "%1 can only contain methods.",
+  1058: "Illegal operand type: %1 must be %2.",
+  1059: "ClassInfo-%1 is referenced before definition.",
+  1060: "ClassInfo %1 exceeds class_count=%2.",
+  1061: "The value %1 cannot be converted to %2 without losing precision.",
+  1063: "Argument count mismatch on %1. Expected %2, got %3.",
+  1064: "Cannot call method %1 as constructor.",
+  1065: "Variable %1 is not defined.",
+  1066: "The form function('function body') is not supported.",
+  1067: "Native method %1 has illegal method body.",
+  1068: "%1 and %2 cannot be reconciled.",
+  1069: "Property %1 not found on %2 and there is no default value.",
+  1070: "Method %1 not found on %2",
+  1071: "Function %1 has already been bound to %2.",
+  1072: "Disp_id 0 is illegal.",
+  1073: "Non-override method %1 replaced because of duplicate disp_id %2.",
+  1074: "Illegal write to read-only property %1 on %2.",
+  1075: "Math is not a function.",
+  1076: "Math is not a constructor.",
+  1077: "Illegal read of write-only property %1 on %2.",
+  1078: "Illegal opcode/multiname combination: %1<%2>.",
+  1079: "Native methods are not allowed in loaded code.",
+  1080: "Illegal value for namespace.",
+  1081: "Property %1 not found on %2 and there is no default value.",
+  1082: "No default namespace has been set.",
+  1083: 'The prefix "%1" for element "%2" is not bound.',
+  1084: "Element or attribute (\"%1\") does not match QName production: QName::=(NCName':')?NCName.",
+  1085: 'The element type "%1" must be terminated by the matching end-tag "</%2>".',
+  1086: "The %1 method only works on lists containing one item.",
+  1087: "Assignment to indexed XML is not allowed.",
+  1088: "The markup in the document following the root element must be well-formed.",
+  1089: "Assignment to lists with more than one item is not supported.",
+  1090: "XML parser failure: element is malformed.",
+  1091: "XML parser failure: Unterminated CDATA section.",
+  1092: "XML parser failure: Unterminated XML declaration.",
+  1093: "XML parser failure: Unterminated DOCTYPE declaration.",
+  1094: "XML parser failure: Unterminated comment.",
+  1095: "XML parser failure: Unterminated attribute.",
+  1096: "XML parser failure: Unterminated element.",
+  1097: "XML parser failure: Unterminated processing instruction.",
+  1098: "Illegal prefix %1 for no namespace.",
+  1100: "Cannot supply flags when constructing one RegExp from another.",
+  1101: "Cannot verify method %1 with unknown scope.",
+  1102: "Illegal default value for type %1.",
+  1103: "Class %1 cannot extend final base class.",
+  1104: 'Attribute "%1" was already specified for element "%2".',
+  1107: "The ABC data is corrupt, attempt to read out of bounds.",
+  1108: "The OP_newclass opcode was used with the incorrect base class.",
+  1109: "Attempt to directly call unbound function %1 from method %2.",
+  1110: "%1 cannot extend %2.",
+  1111: "%1 cannot implement %2.",
+  1112: "Argument count mismatch on class coercion.  Expected 1, got %1.",
+  1113: "OP_newactivation used in method without NEED_ACTIVATION flag.",
+  1114: "OP_getglobalslot or OP_setglobalslot used with no global scope.",
+  1115: "%1 is not a constructor.",
+  1116: "second argument to Function.prototype.apply must be an array.",
+  1117: "Invalid XML name: %1.",
+  1118: "Illegal cyclical loop between nodes.",
+  1119: "Delete operator is not supported with operand of type %1.",
+  1120: "Cannot delete property %1 on %2.",
+  1121: "Method %1 has a duplicate method body.",
+  1122: "Interface method %1 has illegal method body.",
+  1123: "Filter operator not supported on type %1.",
+  1124: "OP_hasnext2 requires object and index to be distinct registers.",
+  1125: "The index %1 is out of range %2.",
+  1126: "Cannot change the length of a fixed Vector.",
+  1127: "Type application attempted on a non-parameterized type.",
+  1128: "Incorrect number of type parameters for %1. Expected %2, got %3.",
+  1129: "Cyclic structure cannot be converted to JSON string.",
+  1131: "Replacer argument to JSON stringifier must be an array or a two parameter function.",
+  1132: "Invalid JSON parse input.",
+  1500: "Error occurred opening file %1.",
+  1501: "Error occurred writing to file %1.",
+  1502: "A script has executed for longer than the default timeout period of 15 seconds.",
+  1503: "A script failed to exit after 30 seconds and was terminated.",
+  1504: "End of file.",
+  1505: "The string index %1 is out of bounds; must be in range %2 to %3.",
+  1506: "The specified range is invalid.",
+  1507: "Argument %1 cannot be null.",
+  1508: "The value specified for argument %1 is invalid.",
+  1510: "When the callback argument is a method of a class, the optional this argument must be null.",
+  1511: "Worker is already started.",
+  1512: "Starting a worker that already failed is not supported.",
+  1513: 'Worker has terminated."',
+  1514: "unlock() with no preceding matching lock().",
+  1515: "Invalid condition timeout value: %1.",
+  1516: "Condition cannot notify if associated mutex is not owned.",
+  1517: "Condition cannot notifyAll if associated mutex is not owned.",
+  1518: "Condition cannot wait if associated mutex is not owned.",
+  1519: "Condition cannot be initialized.",
+  1520: "Mutex cannot be initialized.",
+  1521: "Only the worker's parent may call start.",
+  2004: "One of the parameters is invalid.",
+  2006: "The supplied index is out of bounds.",
+  2007: "Parameter %1 must be non-null.",
+  2008: "Parameter %1 must be one of the accepted values.",
+  2012: "%1 class cannot be instantiated.",
+  2030: "End of file was encountered.",
+  2035: "URL Not Found.",
+  2058: "There was an error decompressing the data.",
+  2078: "The name property of a Timeline-placed object cannot be modified.",
+  2099: "The loading object is not sufficiently loaded to provide this information.",
+  2085: "Parameter %1 must be non-empty string.",
+  2088: "The Proxy class does not implement getProperty. It must be overridden by a subclass.",
+  2089: "The Proxy class does not implement setProperty. It must be overridden by a subclass.",
+  2090: "The Proxy class does not implement callProperty. It must be overridden by a subclass.",
+  2091: "The Proxy class does not implement hasProperty. It must be overridden by a subclass.",
+  2092: "The Proxy class does not implement deleteProperty. It must be overridden by a subclass.",
+  2093: "The Proxy class does not implement getDescendants. It must be overridden by a subclass.",
+  2105: "The Proxy class does not implement nextNameIndex. It must be overridden by a subclass.",
+  2106: "The Proxy class does not implement nextName. It must be overridden by a subclass.",
+  2107: "The Proxy class does not implement nextValue. It must be overridden by a subclass.",
+  2108: "The value %1 is not a valid Array length.",
+  2124: "Loaded file is an unknown type.",
+  2173: "Unable to read object in stream.  The class %1 does not implement flash.utils.IExternalizable but is aliased to an externalizable class.",
+  3735: "This API cannot accept shared ByteArrays.",
+};

package/src/avm2/method-factories.ts

@@ -0,0 +1,130 @@
+// The factories of methods whose bodies are not generated, as a module binds
+// them through Runtime.native, noBody, unverified and verifyError: once,
+// when it loads, never on a call.
+
+import type { AsObject, Factory, Method, TypeRef, Value } from "./descriptors.js";
+import type { Runtime } from "./runtime.js";
+import { boundKey, methodKey, untypedSetKey } from "./traits.js";
+
+/**
+ * A native with argument counts to check, when it has any, its declared
+ * parameter count (see nativeFactory), and, when it declares a parameter
+ * of a primitive type, those types to coerce a call's arguments to where
+ * the compiler did not (see coercedNative).
+ */
+export type CountedMethod = Method & {
+  $min?: number;
+  $max?: number;
+  $length?: number;
+  $coerce?: TypeRef[];
+};
+
+/**
+ * The parameter types avmplus' coerceEnter converts to without a class to
+ * test against: the primitives, and Object, which takes undefined as null.
+ * A native checks a class-typed parameter itself.
+ */
+const COERCED = new Set<TypeRef>(["String", "Number", "int", "uint", "Boolean", "float", "Object"]);
+
+/** Factories nativeFactory made, whose methods coercedNative coerces. */
+const natives = new WeakSet<Factory>();
+
+/** A native method, bound by its name; one the runtime lacks throws when called. */
+export function nativeFactory(rt: Runtime, name: string, required: number, max: number): Factory {
+  const make = rt.natives[name];
+  if (!make) {
+    return () => () => {
+      throw rt.unsupported(`native ${name}`);
+    };
+  }
+
+  let f: Method | null = null;
+  const factory: Factory = () => {
+    if (!f) {
+      f = make(rt);
+      // Checked where a call was not bound (callBound, methodClosure): the
+      // verifier binds only a call its argument count fits.
+      if (required > 0 || max >= 0) {
+        (f as CountedMethod).$min = required;
+        (f as CountedMethod).$max = max;
+      }
+
+      // Its Function.length is the ABC's parameter count, as avmplus'
+      // (FunctionClass.cpp), not what the JavaScript declares: a native
+      // with optional parameters gives them defaults, which length skips.
+      if (max >= 0) {
+        (f as CountedMethod).$length = max;
+      }
+    }
+
+    return f;
+  };
+  natives.add(factory);
+  return factory;
+}
+
+/**
+ * `f`, a method `factory` made, installed in `proto` at dispatch id `d`,
+ * with what a call the compiler did not bind needs to coerce its arguments
+ * by its declared `params`, if it is a native that declares a primitive or
+ * Object one. avmplus coerces a native's arguments on entry, however it was
+ * called; a compiled call bound to it has coerced them already, and calls
+ * it as it is, so only the runtime's untyped paths pay: callBound, by the
+ * types kept on `f`, the same for every runtime, which may share it; and
+ * an untyped set, through a wrapper this runtime's `proto` keeps at
+ * untypedSetKey(d), which a method that needs none hides from its base's.
+ */
+export function installMethod(
+  rt: Runtime,
+  proto: AsObject,
+  d: number,
+  f: Method,
+  factory: Factory,
+  params: TypeRef[],
+): void {
+  proto[methodKey(d)] = f;
+  proto[boundKey(d)] = (f as Method & { $bound?: Method }).$bound ?? f;
+  const key = untypedSetKey(d);
+  if (!natives.has(factory) || !params.some((t) => COERCED.has(t))) {
+    if (key in proto) {
+      proto[key] = undefined;
+    }
+
+    return;
+  }
+
+  const m = f as CountedMethod;
+  const types = params.map((t) => (COERCED.has(t) ? t : null));
+  m.$coerce = types;
+  // callBound coerces only a method with counts.
+  m.$min ??= 0;
+  m.$max ??= -1;
+  const type = types[0];
+  proto[key] =
+    type === null || type === undefined
+      ? undefined
+      : function (this: Value, v: Value): Value {
+          return f.call(this, rt.coerce(v, type));
+        };
+}
+
+/** A method with no body, as an interface's: VerifyError 1001 when called. */
+export function noBodyFactory(rt: Runtime): Factory {
+  return () => () => {
+    throw rt.error("VerifyError", 1001, "method");
+  };
+}
+
+/** A method the compiler did not verify. */
+export function unverifiedFactory(rt: Runtime): Factory {
+  return () => () => {
+    throw rt.unsupported("a method the compiler did not verify");
+  };
+}
+
+/** A method the verifier rejected with VerifyError `id`, thrown when it is called. */
+export function verifyErrorFactory(rt: Runtime, id: number): Factory {
+  return () => () => {
+    throw rt.error("VerifyError", id);
+  };
+}

package/src/avm2/modules.ts

@@ -0,0 +1,120 @@
+// The modules a runtime loads into its application domains, and which of
+// them the code on a stack is from: a Runtime's (Runtime.modules), apart
+// from its object model, as nothing compiled code calls goes through it.
+
+import type { Abc, AbcDesc } from "./descriptors.js";
+import { add, Domain, definedInChain, frameScripts, stackFrames } from "./domain.js";
+import { TypeName } from "./names.js";
+
+export class Modules {
+  private domainCount = 1;
+  private loads = 0;
+  /**
+   * The domain of each loaded module's code, by the script a stack's frame
+   * names it with (see Runtime.codeDomain); found from the stacks its loads
+   * took, which wait in `unlocated` until a domain other than the root
+   * exists. Weakly: a module's code keeps its domain, through its Abc, for
+   * as long as it can run, and a domain no code is left of is let go, an
+   * entry dropped with it.
+   */
+  private readonly moduleDomains = new Map<string, WeakRef<Domain>>();
+  private readonly moduleDomainGone = new FinalizationRegistry<string>((at) => {
+    if (!this.moduleDomains.get(at)?.deref()) {
+      this.moduleDomains.delete(at);
+    }
+  });
+  private readonly unlocated: [Error, Domain][] = [];
+
+  /** A domain whose definitions are looked up after `parent`'s. */
+  newDomain(parent: Domain): Domain {
+    return new Domain(parent, this.domainCount++);
+  }
+
+  /**
+   * Load a module into `domain`: its scripts' names become visible there.
+   * `at` is the stack its load took, made in Runtime.abc, whose frame is
+   * its first and the module's factory its second (see locate); null for a
+   * player's own, whose code is not a domain's to Runtime.codeDomain.
+   */
+  load(desc: AbcDesc, domain: Domain, at: Error | null): Abc {
+    // Its layouts are those of its ABC after exactly these ABCs; the
+    // root's, which a player loads thousands into, are not copied.
+    const loaded = domain.parent ? domain.chain() : domain.own;
+    const linked = desc.linked;
+    if (linked.length !== loaded.length || linked.some((h, i) => h !== loaded[i])) {
+      throw new Error(
+        `swf2es: a module compiled after [${linked.join(", ")}] cannot load after [${loaded.join(", ")}]`,
+      );
+    }
+
+    const abc = desc as Abc;
+    abc.domain = domain;
+    abc.index = domain.own.length;
+    domain.own.push(desc.hash);
+    domain.ownOrder.push(this.loads++);
+    if (at !== null) {
+      this.unlocated.push([at, domain]);
+    }
+    for (const name of abc.names) {
+      if (name instanceof TypeName) {
+        name.names = abc.names;
+      }
+    }
+
+    for (const cls of abc.classes) {
+      cls.abc = abc;
+    }
+
+    abc.scriptStates = abc.scripts.map((s) => ({ desc: s, abc, global: null, state: 0 }));
+    // As DomainMgr::addNamedScript: a name the domain's chain defines
+    // already, cached or loaded, is unreachable, and not added.
+    for (const script of abc.scriptStates) {
+      for (const [ns, version, name] of script.desc.traits.bindings) {
+        if (!definedInChain(domain, name, ns)) {
+          add(domain.globals, { ns, version, script }, name);
+        }
+      }
+    }
+
+    return abc;
+  }
+
+  /**
+   * The domain of the innermost code in `stack` that a module defines, or
+   * null. A frame is a module's by its script, so a host gives each module
+   * a script of its own: its URL, or a sourceURL comment for code it
+   * evaluates.
+   */
+  domainOf(stack: string | undefined): Domain | null {
+    this.locate();
+    for (const at of frameScripts(stack)) {
+      const domain = this.moduleDomains.get(at)?.deref();
+      if (domain) {
+        return domain;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * The scripts of the modules loaded since last asked, by the stacks their
+   * loads took. Their stacks reach the modules' code, so they are not kept
+   * past the load once there are domains to tell apart.
+   */
+  locate(): void {
+    for (const [error, domain] of this.unlocated) {
+      // Its first frame is abc's own, its second the module's factory. An
+      // engine may name no script for the factory's frame (JavaScriptCore,
+      // for code a Function made), and the next frame that names one is
+      // the host's, which must not stand for the module.
+      const at = stackFrames(error.stack)[1];
+      if (at) {
+        this.moduleDomains.set(at, new WeakRef(domain));
+        this.moduleDomainGone.register(domain, at);
+      }
+    }
+
+    this.unlocated.length = 0;
+  }
+}