@swf2es/player-hosts 0.1.5 → 0.1.7

package/dist/thread/player/display/bounds.js

@@ -25,6 +25,7 @@ export function ownBounds(d, lines) {
             : null;
     }
     if (d instanceof TextObject) {
+        d.settle();
         return { xMin: d.left, yMin: d.top, xMax: d.left + d.width, yMax: d.top + d.height };
     }
     if (d instanceof VideoObject) {
@@ -95,12 +96,116 @@ export function placedRect(d, r, drawn = false) {
     const box = transformRect(r, own);
     return back ? boxThrough(box, back) : box;
 }
+// Scratch matrices for boundsIn's flat case: getRect and getBounds are asked of every moved
+// sprite, every frame, by some movies, and these leave nothing behind for the collector.
+const scratchUp = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
+const scratchDown = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
+const scratchBoth = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
+/** `m` set to `p`'s six numbers. */
+function copyInto(m, p) {
+    m.a = p.a;
+    m.b = p.b;
+    m.c = p.c;
+    m.d = p.d;
+    m.tx = p.tx;
+    m.ty = p.ty;
+}
+/** `m` then `p` into `out`, as concat multiplies two flat matrices; `out` may be `m`. */
+function concatInto(out, m, p) {
+    const a = m.a * p.a + m.b * p.c;
+    const b = m.a * p.b + m.b * p.d;
+    const c = m.c * p.a + m.d * p.c;
+    const d = m.c * p.b + m.d * p.d;
+    const tx = m.tx * p.a + m.ty * p.c + p.tx;
+    const ty = m.tx * p.b + m.ty * p.d + p.ty;
+    out.a = a;
+    out.b = b;
+    out.c = c;
+    out.d = d;
+    out.tx = tx;
+    out.ty = ty;
+}
+// `placed` of one with a scrollRect, shifted as geometry's shifted shifts it, without a new matrix.
+const scratchPlaced = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
+/** `d.placed` if flat, into scratchPlaced where a scroll shifts it; null for a projective one. */
+function flatPlaced(d) {
+    if (d.space) {
+        const m = d.placed;
+        return isProjective(m) ? null : m;
+    }
+    const m = d.matrix;
+    if (isProjective(m)) {
+        return null;
+    }
+    const r = d.scroll;
+    if (!r) {
+        return m;
+    }
+    copyInto(scratchPlaced, m);
+    scratchPlaced.tx = m.tx - m.a * r.xMin - m.c * r.yMin;
+    scratchPlaced.ty = m.ty - m.b * r.xMin - m.d * r.yMin;
+    return scratchPlaced;
+}
+/** toStage into `out`, if every matrix on the way is flat; false, `out` spoilt, otherwise. */
+function flatToStage(d, stage, out) {
+    const own = flatPlaced(d);
+    if (!own) {
+        return false;
+    }
+    copyInto(out, own);
+    for (let p = d.parent; p && p !== stage; p = p.parent) {
+        const m = flatPlaced(p);
+        if (!m) {
+            return false;
+        }
+        concatInto(out, out, m);
+    }
+    return true;
+}
+/** `m` inverted in place, as invert does; left as it is, as invert's null is, when flat. */
+function invertFlat(m) {
+    const det = m.a * m.d - m.b * m.c;
+    if (det === 0) {
+        return false;
+    }
+    const a = m.d / det;
+    const b = -m.b / det;
+    const c = -m.c / det;
+    const d = m.a / det;
+    const tx = (m.c * m.ty - m.d * m.tx) / det;
+    const ty = (m.b * m.tx - m.a * m.ty) / det;
+    m.a = a;
+    m.b = b;
+    m.c = c;
+    m.d = d;
+    m.tx = tx;
+    m.ty = ty;
+    return true;
+}
 /** `d`'s bounds in `target`'s space (its own for null), through the stage. */
 export function boundsIn(d, target, stage, lines) {
     const own = bounds(d, lines) ?? { xMin: 0, yMin: 0, xMax: 0, yMax: 0 };
     if (!target || target === d) {
         return own;
     }
+    // Flat all the way, the common case, the same arithmetic as below's in scratch matrices.
+    if (flatToStage(d, stage, scratchUp)) {
+        if (target === stage) {
+            copyInto(scratchDown, IDENTITY);
+        }
+        else if (!flatToStage(target, stage, scratchDown)) {
+            return boundsInThrough(d, target, stage, own);
+        }
+        else if (!invertFlat(scratchDown)) {
+            copyInto(scratchDown, IDENTITY);
+        }
+        concatInto(scratchBoth, scratchUp, scratchDown);
+        return transformRect(own, scratchBoth);
+    }
+    return boundsInThrough(d, target, stage, own);
+}
+/** boundsIn where a plane is on the way: up or down through a projective matrix. */
+function boundsInThrough(d, target, stage, own) {
     const up = toStage(d, stage);
     const down = target === stage ? IDENTITY : (invert(toStage(target, stage)) ?? IDENTITY);
     if (!isProjective(up)) {

package/dist/thread/player/display/drawing.js

@@ -20,6 +20,13 @@ function fillsOnly(layer) {
 const LINE_POINTS = [0, 0];
 const CURVE_POINTS = [0, 0, 0, 0];
 const CUBIC_POINTS = [0, 0, 0, 0, 0, 0];
+// Each quarter's start and end directions, (sx, sy) and (ex, ey), for arc.
+const QUARTERS = [
+    [1, 0, 0, 1],
+    [0, 1, -1, 0],
+    [-1, 0, 0, -1],
+    [0, -1, 1, 0],
+];
 /** `kind` and `points` onto the last of `paths`. */
 function append(paths, kind, points) {
     const path = paths[paths.length - 1];
@@ -40,8 +47,13 @@ export class Drawing {
     /** Where the open fill's entries begin in its layer, which fills before it may share. */
     fillStart = 0;
     stroke = null;
-    /** The line closing the open contour, or the one endFill closed, while a line drawn on may take it away. */
+    /**
+     * The stroke whose last closing line closes the open contour, or the one
+     * endFill closed, while a line drawn on may take it away.
+     */
     closing = null;
+    /** The closing line last taken away, for the next: a filled, lined pen makes one a segment. */
+    spareClose = null;
     /**
      * A point of the open contour off its start, for whether it leaves the
      * line through them: its offset from the start, while `heading`.
@@ -205,12 +217,11 @@ export class Drawing {
         if (rx === 0 && ry === 0) {
             return;
         }
-        const [sx, sy, ex, ey] = [
-            [1, 0, 0, 1],
-            [0, 1, -1, 0],
-            [-1, 0, 0, -1],
-            [0, -1, 1, 0],
-        ][quarter];
+        const turn = QUARTERS[quarter];
+        const sx = turn[0];
+        const sy = turn[1];
+        const ex = turn[2];
+        const ey = turn[3];
         this.curveTo(cx + (sx + ex * TAN_22_5) * rx, cy + (sy + ey * TAN_22_5) * ry, cx + (sx + ex) * COS_45 * rx, cy + (sy + ey) * COS_45 * ry);
         this.curveTo(cx + (ex + sx * TAN_22_5) * rx, cy + (ey + sy * TAN_22_5) * ry, cx + ex * rx, cy + ey * ry);
     }
@@ -591,7 +602,7 @@ export class Drawing {
     unclose() {
         if (this.closing) {
             this.version++;
-            this.closing.stroke.closes?.pop();
+            this.spareClose = this.closing.closes?.pop() ?? null;
             this.closing = null;
         }
     }
@@ -603,10 +614,14 @@ export class Drawing {
             return;
         }
         if (contour[1] !== this.x || contour[2] !== this.y) {
-            const close = { at: stroke.paths.length - 1, x: contour[1], y: contour[2] };
+            const close = this.spareClose ?? { at: 0, x: 0, y: 0 };
+            this.spareClose = null;
+            close.at = stroke.paths.length - 1;
+            close.x = contour[1];
+            close.y = contour[2];
             stroke.closes = stroke.closes ?? [];
             stroke.closes.push(close);
-            this.closing = { stroke, close };
+            this.closing = stroke;
             this.version++;
         }
     }

package/dist/thread/player/display/shapes.js

@@ -58,21 +58,60 @@ export function inside(points, px, py) {
     }
     return hit;
 }
+// The running box of extent: one for every call, as bounds are asked of every drawn shape.
+const box = new Float64Array(4);
+function take(x, y) {
+    box[0] = Math.min(box[0], x);
+    box[1] = Math.min(box[1], y);
+    box[2] = Math.max(box[2], x);
+    box[3] = Math.max(box[3], y);
+}
+/** The quadratic curve from (x, y) through (cx, cy) to (ax, ay), at `t`, into the box. */
+function takeCurveAt(t, x, y, cx, cy, ax, ay) {
+    const u = 1 - t;
+    take(u * u * x + 2 * u * t * cx + t * t * ax, u * u * y + 2 * u * t * cy + t * t * ay);
+}
+/** The cubic curve from (x, y) by (c1x, c1y) and (c2x, c2y) to (ax, ay), at `t`, into the box. */
+function takeCubicAt(t, x, y, c1x, c1y, c2x, c2y, ax, ay) {
+    if (!(t > 0 && t < 1)) {
+        return;
+    }
+    const u = 1 - t;
+    take(u * u * u * x + 3 * u * u * t * c1x + 3 * u * t * t * c2x + t * t * t * ax, u * u * u * y + 3 * u * u * t * c1y + 3 * u * t * t * c2y + t * t * t * ay);
+}
+/**
+ * Where the cubic's derivative on one axis, from p0 by c1 and c2 to p3, is
+ * zero within it: the roots of a t² + b t + c, each into the box.
+ */
+function takeCubicTurns(p0, c1, c2, p3, x, y, c1x, c1y, c2x, c2y, ax, ay) {
+    const a = -p0 + 3 * c1 - 3 * c2 + p3;
+    const b = 2 * (p0 - 2 * c1 + c2);
+    const c = c1 - p0;
+    if (a === 0) {
+        if (b !== 0) {
+            takeCubicAt(-c / b, x, y, c1x, c1y, c2x, c2y, ax, ay);
+        }
+        return;
+    }
+    const d = b * b - 4 * a * c;
+    if (d < 0) {
+        return;
+    }
+    const s = Math.sqrt(d);
+    takeCubicAt((-b + s) / (2 * a), x, y, c1x, c1y, c2x, c2y, ax, ay);
+    takeCubicAt((-b - s) / (2 * a), x, y, c1x, c1y, c2x, c2y, ax, ay);
+}
 /**
  * The path's extent, each curve at its true extremes, as [xMin, yMin,
- * xMax, yMax]; null for a path with no points.
+ * xMax, yMax]; null for a path with no points. It allocates only its
+ * answer: the bounds of every shape drawn, a pen's redrawn each frame
+ * among them, are asked again and again.
  */
 export function extent(path) {
-    let xMin = Number.POSITIVE_INFINITY;
-    let yMin = Number.POSITIVE_INFINITY;
-    let xMax = Number.NEGATIVE_INFINITY;
-    let yMax = Number.NEGATIVE_INFINITY;
-    const take = (x, y) => {
-        xMin = Math.min(xMin, x);
-        yMin = Math.min(yMin, y);
-        xMax = Math.max(xMax, x);
-        yMax = Math.max(yMax, y);
-    };
+    box[0] = Number.POSITIVE_INFINITY;
+    box[1] = Number.POSITIVE_INFINITY;
+    box[2] = Number.NEGATIVE_INFINITY;
+    box[3] = Number.NEGATIVE_INFINITY;
     let x = 0;
     let y = 0;
     for (let i = 0; i < path.length;) {
@@ -86,49 +125,36 @@ export function extent(path) {
         }
         take(x, y);
         if (command === CURVE) {
-            const [cx, cy, ax, ay] = path.slice(i + 1, i + 5);
+            const cx = path[i + 1];
+            const cy = path[i + 2];
+            const ax = path[i + 3];
+            const ay = path[i + 4];
             take(ax, ay);
             // Where the derivative is zero on either axis, if within the curve.
-            const at = (t) => {
-                const u = 1 - t;
-                take(u * u * x + 2 * u * t * cx + t * t * ax, u * u * y + 2 * u * t * cy + t * t * ay);
-            };
-            for (const [p0, c, p2] of [
-                [x, cx, ax],
-                [y, cy, ay],
-            ]) {
-                const denominator = p0 - 2 * c + p2;
-                const t = denominator === 0 ? -1 : (p0 - c) / denominator;
-                if (t > 0 && t < 1) {
-                    at(t);
-                }
+            const dx = x - 2 * cx + ax;
+            const tx = dx === 0 ? -1 : (x - cx) / dx;
+            if (tx > 0 && tx < 1) {
+                takeCurveAt(tx, x, y, cx, cy, ax, ay);
+            }
+            const dy = y - 2 * cy + ay;
+            const ty = dy === 0 ? -1 : (y - cy) / dy;
+            if (ty > 0 && ty < 1) {
+                takeCurveAt(ty, x, y, cx, cy, ax, ay);
             }
             x = ax;
             y = ay;
             i += 5;
         }
         else if (command === CUBIC) {
-            const [c1x, c1y, c2x, c2y, ax, ay] = path.slice(i + 1, i + 7);
+            const c1x = path[i + 1];
+            const c1y = path[i + 2];
+            const c2x = path[i + 3];
+            const c2y = path[i + 4];
+            const ax = path[i + 5];
+            const ay = path[i + 6];
             take(ax, ay);
-            const at = (t) => {
-                const u = 1 - t;
-                take(u * u * u * x + 3 * u * u * t * c1x + 3 * u * t * t * c2x + t * t * t * ax, u * u * u * y + 3 * u * u * t * c1y + 3 * u * t * t * c2y + t * t * t * ay);
-            };
-            for (const [p0, c1, c2, p3] of [
-                [x, c1x, c2x, ax],
-                [y, c1y, c2y, ay],
-            ]) {
-                // The derivative's roots: a t² + b t + c = 0.
-                const a = -p0 + 3 * c1 - 3 * c2 + p3;
-                const b = 2 * (p0 - 2 * c1 + c2);
-                const c = c1 - p0;
-                const roots = a === 0 ? (b === 0 ? [] : [-c / b]) : quadraticRoots(a, b, c);
-                for (const t of roots) {
-                    if (t > 0 && t < 1) {
-                        at(t);
-                    }
-                }
-            }
+            takeCubicTurns(x, c1x, c2x, ax, x, y, c1x, c1y, c2x, c2y, ax, ay);
+            takeCubicTurns(y, c1y, c2y, ay, x, y, c1x, c1y, c2x, c2y, ax, ay);
             x = ax;
             y = ay;
             i += 7;
@@ -140,15 +166,7 @@ export function extent(path) {
             i += 3;
         }
     }
-    return xMin <= xMax ? [xMin, yMin, xMax, yMax] : null;
-}
-function quadraticRoots(a, b, c) {
-    const d = b * b - 4 * a * c;
-    if (d < 0) {
-        return [];
-    }
-    const s = Math.sqrt(d);
-    return [(-b + s) / (2 * a), (-b - s) / (2 * a)];
+    return box[0] <= box[2] ? [box[0], box[1], box[2], box[3]] : null;
 }
 /** Layers as they draw mirrored, as of a version: the renderer and the hit tests ask on each redraw. */
 const mirroredLayers = new WeakMap();

package/dist/thread/player/display/textobjects.js

@@ -30,6 +30,15 @@ export class StaticTextObject extends DisplayObject {
         return this.laidGlyphs;
     }
 }
+/** The fields whose fit a set size left pending, for the frame to settle before it is drawn. */
+const pendingFits = new Set();
+/** Every pending fit applied, as Flash applies them before it draws. */
+export function settleFits() {
+    for (const field of pendingFits) {
+        field.settle();
+    }
+    pendingFits.clear();
+}
 /**
  * A TextField: placed by DefineEditText, or made by a script. Its text and
  * formats are a TextModel; a timeline's starts with its tag's text, read
@@ -55,6 +64,12 @@ export class TextObject extends DisplayObject {
     type = "dynamic";
     embedFonts = false;
     autoSize = "none";
+    /**
+     * A script set the size of a field that fits itself: as in Flash, the fit
+     * waits for its size to be asked, its transform to change or the frame to
+     * be drawn, and a wordWrap set meanwhile wraps at the size set (adl).
+     */
+    fitPending = false;
     selectable = true;
     maxChars = 0;
     displayAsPassword = false;
@@ -165,7 +180,7 @@ export class TextObject extends DisplayObject {
      * centre or right edge where it was.
      */
     fit() {
-        if (this.autoSize === "none") {
+        if (this.autoSize === "none" || this.fitPending) {
             return;
         }
         const layout = this.layout;
@@ -186,6 +201,24 @@ export class TextObject extends DisplayObject {
         this.height = height;
         this.invalidate(CONTENT);
     }
+    /** A script set its size: under autoSize, the fit waits (fitPending). */
+    sizeSet() {
+        if (this.autoSize !== "none") {
+            this.fitPending = true;
+            pendingFits.add(this);
+        }
+    }
+    /** The fit a set size left pending, applied: its size asked, its transform changed, the frame drawn. */
+    settle() {
+        if (this.fitPending) {
+            this.fitPending = false;
+            this.fit();
+        }
+    }
+    touch() {
+        super.touch();
+        this.settle();
+    }
     /** The text, \r between its lines. */
     get text() {
         return this.model.text;

package/dist/thread/player/player.js

@@ -10,6 +10,7 @@ import { decodeImages, decodeInBrowser } from "./bitmap/images.js";
 import { drawKernelFrame, drawKernelLetGo, drawKernelUsed } from "./bitmap/kernel.js";
 import { BUTTON, CLIP, Container, MovieClip, OTHER, unloads, walkList, } from "./display/display.js";
 import { setStageSize } from "./display/perspective.js";
+import { settleFits } from "./display/textobjects.js";
 import { readLibrary } from "./display/timeline.js";
 import { customContextMenu } from "./input/context-menu.js";
 import { KeyboardInput } from "./input/keyboard.js";
@@ -607,9 +608,7 @@ export class Player {
             }
         };
         collect(this.stage);
-        for (const orphan of this.scripting?.lifecycle.orphanRoots() ?? []) {
-            collect(orphan);
-        }
+        this.scripting?.lifecycle.eachOrphanRoot(collect);
         // Let go of once advanced, so that the kept list holds none past the tick.
         try {
             for (let i = 0; i < count; i++) {
@@ -624,5 +623,7 @@ export class Player {
             this.scripting.frame(this.stage, true, render);
             this.frameRate = this.scripting.frameRate;
         }
+        // The fits a set size left pending happen before the frame is drawn, as in Flash.
+        settleFits();
     }
 }

package/dist/thread/player/playerglobal/flash/display/DisplayObject.js

@@ -340,7 +340,7 @@ export function displayObjectNatives(s) {
             if (d instanceof TextObject) {
                 d.width = value / (Math.abs(d.scaleX) || 1);
                 d.invalidate(CONTENT);
-                d.fit();
+                d.sizeSet();
                 return;
             }
             const r = bounds(d, true);
@@ -375,7 +375,7 @@ export function displayObjectNatives(s) {
             if (d instanceof TextObject) {
                 d.height = value / (Math.abs(d.scaleY) || 1);
                 d.invalidate(CONTENT);
-                d.fit();
+                d.sizeSet();
                 return;
             }
             const r = bounds(d, true);

package/dist/thread/player/playerglobal/flash/net/NetConnection.js

@@ -1,9 +1,13 @@
 // flash.net.NetConnection in its local mode, connect(null), which Flash
 // keeps for progressive video, with its properties and status events as
-// Flash gives them; an HTTP URI is kept, as Flash Remoting would use it,
-// and a call over it is not supported yet. Responder holds its callbacks.
+// Flash gives them; and Flash Remoting over an HTTP URI: each call queued,
+// and a frame's calls POSTed together at its end as one packet
+// (remoting.ts), the connection's headers with them, each answer, /n/
+// onResult or /n/onStatus, going to its Responder, as adl does.
+// Responder holds its callbacks.
 import { avm2 } from "../../../../runtime/index.js";
 import { dispatchEvent } from "../../../scripting/events.js";
+import { remoteArguments, remoteMessages, remotePacket, remoteValue, } from "./remoting.js";
 /** NetConnection's private invoke codes, as playerglobal's constants have them. */
 const CLOSE = 1;
 const CALL = 2;
@@ -32,8 +36,10 @@ export function netConnectionNatives(s) {
         /** Null is the local connection, at once and connected; an HTTP URI is only kept. A connection made goes first. */
         connect(command) {
             const self = this;
-            if (this.$connected) {
+            // A gateway connected before is closed as a local one is (the corpus's netconnection_send_remote).
+            if (this.$connected || this.$remote) {
                 this.$connected = false;
+                this.$remote = null;
                 status(self, ["code", "NetConnection.Connect.Closed", "level", "status"]);
             }
             if (command === null || command === undefined || s.rt.toString(command) === "null") {
@@ -43,6 +49,16 @@ export function netConnectionNatives(s) {
                 return;
             }
             this.$uri = s.rt.toString(command);
+            if (/^https?:\/\//i.test(this.$uri)) {
+                this.$remote = {
+                    url: this.$uri,
+                    headers: [],
+                    queue: [],
+                    next: 1,
+                    responders: new Map(),
+                    scheduled: false,
+                };
+            }
         }
         "flash.net:NetConnection::invoke"(code) {
             if (s.rt.toUint(code) === CLOSE) {
@@ -51,13 +67,16 @@ export function netConnectionNatives(s) {
             }
             throw s.rt.unsupported(`NetConnection invoke ${s.rt.toUint(code)}`);
         }
-        "flash.net:NetConnection::invokeWithArgsArray"(code, _args) {
+        "flash.net:NetConnection::invokeWithArgsArray"(code, args) {
             const which = s.rt.toUint(code);
+            const values = (args?.$a ?? []);
             if (which === ADD_HEADER) {
+                addHeader(this, values);
                 return undefined;
             }
             if (which === CALL) {
-                throw s.rt.unsupported("NetConnection.call, Flash Remoting");
+                call(this, values);
+                return undefined;
             }
             throw s.rt.unsupported(`NetConnection invoke ${which}`);
         }
@@ -135,6 +154,7 @@ export function netConnectionNatives(s) {
         const wasConnected = o.$connected ?? false;
         o.$connected = false;
         o.$uri = null;
+        o.$remote = null;
         if (wasConnected) {
             status(o, ["code", "NetConnection.Connect.Closed", "level", "status"]);
         }
@@ -143,6 +163,131 @@ export function netConnectionNatives(s) {
             status(o, ["code", "", "description", "", "details", "", "level", "status"]);
         }
     };
+    /**
+     * A call queued for the frame's end, numbered on its connection; nothing
+     * on a local connection or none, which send nothing, as in adl.
+     */
+    const call = (o, values) => {
+        const remote = o.$remote;
+        if (!remote) {
+            return;
+        }
+        const method = s.rt.toString(values[0]);
+        const responder = (values[1] ?? null);
+        const id = remote.next++;
+        const encoding = o.$objectEncoding ?? defaultEncoding;
+        remote.queue.push({ method, id, body: remoteArguments(s.rt, values.slice(2), encoding) });
+        remote.responders.set(id, responder);
+        if (!remote.scheduled) {
+            remote.scheduled = true;
+            s.afterExitFrame.push(() => send(o, remote, encoding));
+        }
+    };
+    /** One header of a name, its case aside: the last set, a value of null its value (corpus). */
+    const addHeader = (o, values) => {
+        const remote = o.$remote;
+        if (!remote) {
+            return;
+        }
+        const name = s.rt.toString(values[0]);
+        const encoding = o.$objectEncoding ?? defaultEncoding;
+        const value = remoteValue(s.rt, values[2] ?? null, encoding);
+        remote.headers = remote.headers.filter((h) => h.name.toLowerCase() !== name.toLowerCase());
+        remote.headers.push({ name, mustUnderstand: s.rt.toBoolean(values[1]), value });
+    };
+    /** The frame's calls, POSTed as one packet; their answers come in a later frame. */
+    const send = (o, remote, encoding) => {
+        remote.scheduled = false;
+        const calls = remote.queue;
+        remote.queue = [];
+        const fetch = s.fetch;
+        // A connection closed or replaced since sends nothing.
+        if (o.$remote !== remote || calls.length === 0 || !fetch) {
+            return;
+        }
+        const body = remotePacket(encoding, remote.headers, calls);
+        const request = fetch({
+            url: remote.url,
+            method: "POST",
+            headers: [["Content-Type", "application/x-amf"]],
+            body,
+            purpose: "data",
+        }, new AbortController().signal).then((result) => result, () => ({ bytes: null, status: 0, headers: [] }));
+        s.loads.trackRequest(request.then((result) => {
+            s.loads.deferHostEvent(() => {
+                try {
+                    answered(o, remote, result.bytes, result.status);
+                }
+                finally {
+                    // Its calls are done with, answered or not: their responders go.
+                    for (const call of calls) {
+                        remote.responders.delete(call.id);
+                    }
+                }
+            });
+        }));
+    };
+    /**
+     * An answer: each message to the responder of the call it names; an
+     * HTTP error or no answer as Call.Failed, one that is no packet as
+     * Call.BadVersion, an empty one as nothing, as adl reports them.
+     */
+    const answered = (o, remote, bytes, httpStatus) => {
+        if (o.$remote !== remote) {
+            return;
+        }
+        if (bytes === null) {
+            const description = httpStatus >= 300 ? `HTTP: Status ${httpStatus}` : "HTTP: Failed";
+            status(o, [
+                "code",
+                "NetConnection.Call.Failed",
+                "description",
+                description,
+                "details",
+                remote.url,
+                "level",
+                "error",
+            ]);
+            return;
+        }
+        if (bytes.length === 0) {
+            return;
+        }
+        const messages = remoteMessages(s.rt, bytes);
+        if (messages === "version") {
+            status(o, [
+                "code",
+                "NetConnection.Call.BadVersion",
+                "description",
+                "",
+                "details",
+                "",
+                "level",
+                "error",
+            ]);
+            return;
+        }
+        for (const [target, value] of messages) {
+            const m = /^\/(\d+)\/(onResult|onStatus)$/.exec(target);
+            if (!m) {
+                continue;
+            }
+            const id = Number(m[1]);
+            const responder = remote.responders.get(id);
+            remote.responders.delete(id);
+            const handler = responder
+                ? responder[m[2] === "onResult" ? "$result" : "$status"]
+                : null;
+            if (typeof handler === "function" || (handler && typeof handler === "object")) {
+                try {
+                    s.rt.call(handler, null, value);
+                }
+                catch (error) {
+                    s.reportUncaught(error);
+                }
+            }
+        }
+    };
     class ResponderNatives {
         "flash.net:Responder::ctor"(result, status) {
             this.$result = result;

package/dist/thread/player/playerglobal/flash/net/local-values.js

@@ -6,12 +6,29 @@ import * as A from "../../../avm1/amf.js";
 import { LOCAL_MESSAGE_LIMIT } from "../../../localconnection.js";
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
-export function writeLocalValues(rt, args) {
-    // The original AMF3 payload is already bounded; AMF0 can expand small integers.
-    const out = new A.Writer(() => null, 8, null, null);
-    const references = new Map();
-    let next = 1;
-    const write = (value, depth) => {
+/**
+ * AS3 values as AMF0, through the AS2 codec's writer: LocalConnection's
+ * arguments, and Flash Remoting's in AMF0. `limit` bounds strings and
+ * arrays (LocalConnection's message size); `next` is the reference the
+ * first object takes: 1 where the strict array of arguments is itself the
+ * first, as LocalConnection numbers them, 0 for remoting's (adl).
+ */
+export class Amf0Writer {
+    rt;
+    limit;
+    next;
+    what;
+    out = new A.Writer(() => null, 8, null, null);
+    references = new Map();
+    constructor(rt, limit = LOCAL_MESSAGE_LIMIT, next = 1, what = "LocalConnection") {
+        this.rt = rt;
+        this.limit = limit;
+        this.next = next;
+        this.what = what;
+    }
+    value(value, depth = 0) {
+        const out = this.out;
+        const rt = this.rt;
         if (depth >= A.MAX_DEPTH - 2) {
             out.bytes(A.UNDEFINED);
             return;
@@ -37,8 +54,8 @@ export function writeLocalValues(rt, args) {
         }
         if (traits.name === "XML" || traits.name === "flash.xml::XMLDocument") {
             const text = rt.toString(rt.callProperty(value, rt.publicName(traits.name === "XML" ? "toXMLString" : "toString")));
-            if (text.length > LOCAL_MESSAGE_LIMIT) {
-                throw new RangeError("LocalConnection message too large");
+            if (text.length > this.limit) {
+                throw new RangeError(`${this.what} message too large`);
             }
             const bytes = encoder.encode(text);
             out.bytes(A.XML);
@@ -46,13 +63,13 @@ export function writeLocalValues(rt, args) {
             out.push(bytes);
             return;
         }
-        const seen = references.get(value);
+        const seen = this.references.get(value);
         if (seen !== undefined) {
             out.bytes(A.REFERENCE);
             out.u16(seen);
             return;
         }
-        references.set(value, next++);
+        this.references.set(value, this.next++);
         if (value.$a) {
             const array = value.$a;
             const properties = value.$d;
@@ -61,22 +78,22 @@ export function writeLocalValues(rt, args) {
                 out.u32(array.length);
                 for (const key of Object.keys(array)) {
                     out.name(key);
-                    write(array[Number(key)], depth + 1);
+                    this.value(array[Number(key)], depth + 1);
                 }
                 for (const [key, field] of properties) {
                     out.name(key);
-                    write(field, depth + 1);
+                    this.value(field, depth + 1);
                 }
                 out.bytes(0, 0, A.OBJECT_END);
                 return;
             }
-            if (array.length > LOCAL_MESSAGE_LIMIT) {
-                throw new RangeError("LocalConnection message too large");
+            if (array.length > this.limit) {
+                throw new RangeError(`${this.what} message too large`);
             }
             out.bytes(A.STRICT_ARRAY);
             out.u32(array.length);
             for (let i = 0; i < array.length; i++) {
-                write(array[i], depth + 1);
+                this.value(array[i], depth + 1);
             }
             return;
         }
@@ -106,80 +123,122 @@ export function writeLocalValues(rt, args) {
                 continue;
             }
             out.name(name);
-            write(field, depth + 1);
+            this.value(field, depth + 1);
         }
         out.bytes(0, 0, A.OBJECT_END);
-    };
-    out.bytes(A.STRICT_ARRAY);
-    out.u32(args.length);
+    }
+}
+export function writeLocalValues(rt, args) {
+    // The original AMF3 payload is already bounded; AMF0 can expand small integers.
+    const w = new Amf0Writer(rt);
+    w.out.bytes(A.STRICT_ARRAY);
+    w.out.u32(args.length);
     for (const value of args) {
-        write(value, 0);
+        w.value(value);
     }
-    return out.finish();
+    return w.out.finish();
 }
-export function readLocalValues(rt, bytes) {
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    const references = [];
-    let at = 0;
-    const u16 = () => {
-        const n = view.getUint16(at);
-        at += 2;
+/** AMF0's marker for an AMF3 value after it, which Flash Remoting writes and reads. */
+export const AVMPLUS = 0x11;
+/**
+ * AMF0 read as AS3 values from `at`: LocalConnection's arguments, and
+ * Flash Remoting's answers, whose AMF3 values after 0x11 (with `amf3`)
+ * share one AMF3 reader's tables.
+ */
+export class Amf0Reader {
+    rt;
+    bytes;
+    amf3;
+    what;
+    at;
+    view;
+    references = [];
+    amf3Reader = null;
+    amf3Bytes = null;
+    constructor(rt, bytes, at = 0, amf3 = false, what = "LocalConnection") {
+        this.rt = rt;
+        this.bytes = bytes;
+        this.amf3 = amf3;
+        this.what = what;
+        this.at = at;
+        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    }
+    u16() {
+        const n = this.view.getUint16(this.at);
+        this.at += 2;
         return n;
-    };
-    const u32 = () => {
-        const n = view.getUint32(at);
-        at += 4;
+    }
+    u32() {
+        const n = this.view.getUint32(this.at);
+        this.at += 4;
         return n;
-    };
-    const utf = (length) => {
-        if (length > bytes.length - at) {
-            throw new RangeError("LocalConnection message ended early");
+    }
+    utf(length) {
+        if (length > this.bytes.length - this.at) {
+            throw new RangeError(`${this.what} message ended early`);
         }
-        const text = decoder.decode(bytes.subarray(at, at + length));
-        at += length;
+        const text = decoder.decode(this.bytes.subarray(this.at, this.at + length));
+        this.at += length;
         return text;
-    };
-    const name = () => utf(u16());
-    const read = (depth) => {
+    }
+    name() {
+        return this.utf(this.u16());
+    }
+    /** An AMF3 value at the reader's place, its tables those of the values before it. */
+    amf3Value() {
+        if (this.amf3Bytes === null) {
+            this.amf3Bytes = new avm2.Bytes(this.rt, {});
+            this.amf3Bytes.write(this.bytes);
+            this.amf3Reader = new avm2.Amf3Reader(this.rt, this.amf3Bytes);
+        }
+        this.amf3Bytes.position = this.at;
+        const value = this.amf3Reader.value();
+        this.at = this.amf3Bytes.position;
+        return value;
+    }
+    value(depth = 0) {
+        const rt = this.rt;
+        const bytes = this.bytes;
+        const view = this.view;
         if (depth >= A.MAX_DEPTH) {
-            throw new RangeError("LocalConnection arguments nested too deeply");
+            throw new RangeError(`${this.what} arguments nested too deeply`);
         }
-        const marker = bytes[at++];
+        const marker = bytes[this.at++];
         switch (marker) {
             case A.NUMBER: {
-                const n = view.getFloat64(at);
-                at += 8;
+                const n = view.getFloat64(this.at);
+                this.at += 8;
                 return n;
             }
             case A.BOOLEAN:
-                return bytes[at++] !== 0;
+                return bytes[this.at++] !== 0;
             case A.STRING:
-                return name();
+                return this.name();
             case A.LONG_STRING:
-                return utf(u32());
+                return this.utf(this.u32());
             case A.NULL:
                 return null;
             case A.UNDEFINED:
             case A.UNSUPPORTED:
                 return undefined;
             case A.REFERENCE:
-                return references[u16()];
+                return this.references[this.u16()];
             case A.DATE: {
-                const time = view.getFloat64(at);
-                at += 10;
+                const time = view.getFloat64(this.at);
+                this.at += 10;
                 return rt.construct(rt.classNamed("Date"), time);
             }
             case A.XML:
-                return rt.construct(rt.classNamed("flash.xml::XMLDocument"), utf(u32()));
+                return rt.construct(rt.classNamed("flash.xml::XMLDocument"), this.utf(this.u32()));
             case A.STRICT_ARRAY: {
-                const count = u32();
-                if (count > bytes.length - at) {
-                    throw new RangeError("LocalConnection message ended early");
+                const count = this.u32();
+                if (count > bytes.length - this.at) {
+                    throw new RangeError(`${this.what} message ended early`);
                 }
                 const result = rt.newArray([]);
-                references.push(result);
+                this.references.push(result);
                 for (let i = 0; i < count; i++) {
-                    result.$a.push(read(depth + 1));
+                    result.$a.push(this.value(depth + 1));
                 }
                 return result;
             }
@@ -188,30 +247,37 @@ export function readLocalValues(rt, bytes) {
             case A.ECMA_ARRAY: {
                 let result;
                 if (marker === A.TYPED_OBJECT) {
-                    result = rt.allocate(rt.classByAlias(name(), true)) ?? rt.newObject([]);
+                    result = rt.allocate(rt.classByAlias(this.name(), true)) ?? rt.newObject([]);
                 }
                 else {
                     result = marker === A.ECMA_ARRAY ? rt.newArray([]) : rt.newObject([]);
                 }
-                const length = marker === A.ECMA_ARRAY ? u32() : 0;
-                references.push(result);
+                const length = marker === A.ECMA_ARRAY ? this.u32() : 0;
+                this.references.push(result);
                 for (;;) {
-                    const key = name();
-                    if (key === "" && bytes[at] === A.OBJECT_END) {
-                        at++;
+                    const key = this.name();
+                    if (key === "" && bytes[this.at] === A.OBJECT_END) {
+                        this.at++;
                         break;
                     }
-                    rt.setProperty(result, rt.publicName(key), read(depth + 1));
+                    rt.setProperty(result, rt.publicName(key), this.value(depth + 1));
                 }
                 if (marker === A.ECMA_ARRAY && length > result.$a.length) {
                     result.$a.length = length;
                 }
                 return result;
             }
+            case AVMPLUS:
+                if (this.amf3) {
+                    return this.amf3Value();
+                }
+                throw new RangeError(`Invalid ${this.what} AMF0 marker`);
             default:
-                throw new RangeError("Invalid LocalConnection AMF0 marker");
+                throw new RangeError(`Invalid ${this.what} AMF0 marker`);
         }
-    };
-    const result = read(0);
+    }
+}
+export function readLocalValues(rt, bytes) {
+    const result = new Amf0Reader(rt, bytes).value();
     return result.$a;
 }

package/dist/thread/player/playerglobal/flash/net/remoting.js

@@ -0,0 +1,162 @@
+// Flash Remoting's packets for AS3's NetConnection.call, as adl sends and
+// reads them. A packet is its version (0, or 3 where the connection's
+// objectEncoding is AMF3), its headers and its calls, each call's
+// arguments a strict array. In AMF0 every value is AMF0, the arguments
+// sharing one table of references whose first object is 0. In AMF3 the
+// strings, numbers, booleans, null and undefined are still AMF0, and every
+// other value is AMF0's 0x11 followed by AMF3, the arguments of a call
+// sharing one AMF3 writer's tables; a header's value is one of its own.
+import { avm2 } from "../../../../runtime/index.js";
+import * as A from "../../../avm1/amf.js";
+import { Amf0Reader, Amf0Writer, AVMPLUS } from "./local-values.js";
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+/** Whether AMF3 writes `v` as AMF0 all the same: what has no AMF3 reference to share. */
+function primitive(v) {
+    return (v === null || (typeof v !== "object" && typeof v !== "function") || v instanceof avm2.FloatValue);
+}
+/** `v`, a primitive, in AMF0 at the end of `out`. */
+function writeAmf0Primitive(out, v) {
+    const w = new A.Writer(() => null, 8, null, null);
+    w.value(v instanceof avm2.FloatValue ? v.value : v);
+    out.write(w.finish());
+}
+/** AMF3 values, each after 0x11, into one buffer, sharing one AMF3 writer's tables. */
+class Amf3Values {
+    bytes;
+    writer;
+    constructor(rt) {
+        this.bytes = new avm2.Bytes(rt, {});
+        this.writer = new avm2.Amf3Writer(rt, this.bytes);
+    }
+    value(v) {
+        if (primitive(v)) {
+            writeAmf0Primitive(this.bytes, v);
+            return;
+        }
+        this.bytes.write(Uint8Array.of(AVMPLUS));
+        this.writer.value(v);
+    }
+    finish() {
+        return this.bytes.buffer.slice(0, this.bytes.length);
+    }
+}
+/** A header's value: AMF0, itself its table's first object; or in AMF3, with tables of its own. */
+export function remoteValue(rt, v, encoding) {
+    if (encoding === 3) {
+        const w = new Amf3Values(rt);
+        w.value(v);
+        return w.finish();
+    }
+    const w = new Amf0Writer(rt, Number.POSITIVE_INFINITY, 0, "Remoting");
+    w.value(v);
+    return w.out.finish();
+}
+/** A call's arguments: a strict array of them, in the connection's encoding. */
+export function remoteArguments(rt, args, encoding) {
+    if (encoding === 3) {
+        const w = new Amf3Values(rt);
+        const head = new Uint8Array(5);
+        head[0] = A.STRICT_ARRAY;
+        new DataView(head.buffer).setUint32(1, args.length);
+        w.bytes.write(head);
+        for (const v of args) {
+            w.value(v);
+        }
+        return w.finish();
+    }
+    const w = new Amf0Writer(rt, Number.POSITIVE_INFINITY, 0, "Remoting");
+    w.out.bytes(A.STRICT_ARRAY);
+    w.out.u32(args.length);
+    for (const v of args) {
+        w.value(v);
+    }
+    return w.out.finish();
+}
+/** Bytes, joined once. */
+function join(chunks) {
+    let length = 0;
+    for (const chunk of chunks) {
+        length += chunk.length;
+    }
+    const out = new Uint8Array(length);
+    let at = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, at);
+        at += chunk.length;
+    }
+    return out;
+}
+/** A u16-long UTF-8 string, no marker. */
+function utf(text) {
+    const b = encoder.encode(text).subarray(0, 0xffff);
+    return join([Uint8Array.of(b.length >> 8, b.length & 0xff), b]);
+}
+const u16 = (n) => Uint8Array.of((n >> 8) & 0xff, n & 0xff);
+const u32 = (n) => Uint8Array.of((n >>> 24) & 0xff, (n >>> 16) & 0xff, (n >>> 8) & 0xff, n & 0xff);
+/** A packet of the calls, each answered at /n, its number on the connection. */
+export function remotePacket(encoding, headers, calls) {
+    const out = [u16(encoding === 3 ? 3 : 0), u16(headers.length)];
+    for (const h of headers) {
+        out.push(utf(h.name), Uint8Array.of(h.mustUnderstand ? 1 : 0), u32(h.value.length), h.value);
+    }
+    out.push(u16(calls.length));
+    for (const call of calls) {
+        out.push(utf(call.method), utf(`/${call.id}`), u32(call.body.length), call.body);
+    }
+    return join(out);
+}
+/**
+ * An answer's messages, their targets and values; "version" for one that
+ * is no packet of version 0 or 3, which Flash reports as BadVersion.
+ * Each value is read on its own, AMF3 after 0x11 included; a message's
+ * length, where it gives one, says where the next begins.
+ */
+export function remoteMessages(rt, bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    try {
+        const version = view.getUint16(0);
+        if (version !== 0 && version !== 3) {
+            return "version";
+        }
+        let at = 2;
+        const text = () => {
+            const n = view.getUint16(at);
+            at += 2;
+            if (at + n > bytes.length) {
+                throw new RangeError("past the end");
+            }
+            const s = decoder.decode(bytes.subarray(at, at + n));
+            at += n;
+            return s;
+        };
+        const value = () => {
+            const length = view.getUint32(at);
+            at += 4;
+            const start = at;
+            const reader = new Amf0Reader(rt, bytes, at, true, "Remoting");
+            const v = reader.value();
+            at = length !== 0xffffffff && start + length <= bytes.length ? start + length : reader.at;
+            return v;
+        };
+        const headers = view.getUint16(at);
+        at += 2;
+        for (let i = 0; i < headers; i++) {
+            text();
+            at += 1;
+            value();
+        }
+        const count = view.getUint16(at);
+        at += 2;
+        const messages = [];
+        for (let i = 0; i < count; i++) {
+            const target = text();
+            text();
+            messages.push([target, value()]);
+        }
+        return messages;
+    }
+    catch {
+        return "version";
+    }
+}

package/dist/thread/player/scripting/lifecycle.js

@@ -45,7 +45,7 @@ export class Lifecycle {
      * order, as Flash dispatches them.
      */
     added(display) {
-        this.orphans.delete(display.serial);
+        this.dropOrphan(display.serial);
         this.dispatch(display.object, "added", true);
         if (this.onStage(display)) {
             this.eachObject(display, (o) => this.dispatch(o, "addedToStage", false));
@@ -136,6 +136,7 @@ export class Lifecycle {
     orphan(display, keep = true) {
         if (display.object && !this.orphans.has(display.serial)) {
             this.orphans.set(display.serial, { ref: display.ref, keep, since: this.s.frames });
+            this.sortedOrphans = null;
             scriptWork.changes++;
         }
     }
@@ -152,24 +153,42 @@ export class Lifecycle {
             display.fresh = true;
         }
     }
-    /** The orphans still there, newest first, as Flash runs their frames. */
-    orphanRoots() {
-        const roots = [];
-        for (const [serial, orphan] of this.orphans) {
-            const display = orphan.ref.deref();
+    /**
+     * The orphans, newest first, as Flash runs their frames: kept sorted
+     * until one comes or goes, as the player walks them twice a frame.
+     */
+    sortedOrphans = null;
+    dropOrphan(serial) {
+        if (this.orphans.delete(serial)) {
+            this.sortedOrphans = null;
+        }
+    }
+    /** Each orphan still there, newest first, to `f`, which must leave the orphans as they are. */
+    eachOrphanRoot(f) {
+        let sorted = this.sortedOrphans;
+        if (!sorted) {
+            sorted = [];
+            for (const [serial, orphan] of this.orphans) {
+                sorted.push({ serial, ref: orphan.ref });
+            }
+            sorted.sort((a, b) => b.serial - a.serial);
+            this.sortedOrphans = sorted;
+        }
+        for (let i = 0; i < sorted.length; i++) {
+            const display = sorted[i].ref.deref();
             if (!display) {
-                this.orphans.delete(serial);
+                this.dropOrphan(sorted[i].serial);
                 continue;
             }
-            roots.push(display);
+            f(display);
         }
-        return roots.sort((a, b) => b.serial - a.serial);
     }
     /** Whether `display` or anything under it listens for a frame's broadcast events. */
     hearsFrames(display) {
         if (display.object) {
-            for (const targets of this.s.broadcasts.values()) {
-                if (targets.has(display.object)) {
+            const sets = this.s.broadcastSets;
+            for (let i = 0; i < sets.length; i++) {
+                if (sets[i].has(display.object)) {
                     return true;
                 }
             }
@@ -187,7 +206,7 @@ export class Lifecycle {
      * does: timelines stopped, frame broadcasts no longer heard, no orphan.
      */
     stopAll(display) {
-        this.orphans.delete(display.serial);
+        this.dropOrphan(display.serial);
         stopTimelineSoundsUnder(this.s, display);
         const stop = (o) => {
             if (o instanceof MovieClip) {
@@ -230,24 +249,25 @@ export class Lifecycle {
         // What the timeline took off this frame has had its frame; it stops here. So
         // does one that has played ORPHAN_FRAMES off the list, but for one that
         // listens for a frame's events, which hold it in Flash too.
-        for (const [serial, orphan] of this.orphans) {
+        // forEach, as for-of makes an entry for each of what may be thousands, every frame.
+        this.orphans.forEach((orphan, serial) => {
             if (!orphan.keep) {
-                this.orphans.delete(serial);
-                continue;
+                this.dropOrphan(serial);
+                return;
             }
             if (this.s.frames - orphan.since < ORPHAN_FRAMES) {
-                continue;
+                return;
             }
             const display = orphan.ref.deref();
             if (display && this.hearsFrames(display)) {
                 orphan.since = this.s.frames;
-                continue;
+                return;
             }
-            this.orphans.delete(serial);
+            this.dropOrphan(serial);
             if (display) {
                 stopTimelineSoundsUnder(this.s, display);
             }
-        }
+        });
         // What scripts made this frame and left off the display list plays on as an orphan.
         const made = this.madeThisFrame.splice(0);
         if (made.length > 0) {

package/dist/thread/player/scripting.js

@@ -203,6 +203,8 @@ export class Scripting {
     inFrameScript = null;
     /** The display objects listening for each frame event, in the order they first listened; a broadcast reaches these. */
     broadcasts = new Map();
+    /** The same sets, for a walk by index that makes no iterator; the map never lets one go. */
+    broadcastSets = [];
     /** The dispatchers listening for ACTIVATE or DEACTIVATE, held weakly. */
     activation = new Map();
     /** What flash.display.Stage reports and sets; the player copies the frame rate back each frame. */
@@ -579,6 +581,7 @@ export class Scripting {
         if (!targets) {
             targets = new Set();
             this.broadcasts.set(type, targets);
+            this.broadcastSets.push(targets);
         }
         return targets;
     }
@@ -792,9 +795,7 @@ export class Scripting {
                 }
             }
         };
-        for (const orphan of this.lifecycle.orphanRoots()) {
-            visit(orphan);
-        }
+        this.lifecycle.eachOrphanRoot(visit);
         visit(root);
         for (const display of this.lifecycle.fresh) {
             visit(display);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swf2es/player-hosts",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Optional Node and WebSocket transports, worker threads, an IndexedDB module cache and precompiled modules for the swf2es player",
   "keywords": [
     "swf",
@@ -60,6 +60,6 @@
     "LICENSE.third-party"
   ],
   "dependencies": {
-    "@swf2es/player": "0.1.5"
+    "@swf2es/player": "0.1.7"
   }
 }