@raydiant/playlist-window-manager 0.29.1 → 0.30.0

package/build/PlaylistWindowManager.test.js

@@ -0,0 +1,1763 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var RE = __importStar(require("@raydiant/playlist-rule-engine"));
+var mockdate_1 = __importDefault(require("mockdate"));
+var PlaylistWindowManager_1 = __importDefault(require("./PlaylistWindowManager"));
+var testUtils_1 = require("./testUtils");
+var CLOSE_WINDOW_DELAY_MS = 50;
+var wait = function (ms) { return new Promise(function (resolve) { return setTimeout(resolve, ms); }); };
+// Long enough for every scripted app reply and any surface show deadline.
+var settle = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, testUtils_1.flush)(20)];
+            case 1:
+                _a.sent();
+                return [4 /*yield*/, wait(CLOSE_WINDOW_DELAY_MS * 2)];
+            case 2:
+                _a.sent();
+                return [4 /*yield*/, (0, testUtils_1.flush)(20)];
+            case 3:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+var now = Date.parse('2026-10-28T12:00:00Z');
+// The manager throttles completes that arrive within three seconds of each
+// other; moving the clock past that keeps every test on the unthrottled path.
+var passTime = function () {
+    now += 5000;
+    mockdate_1.default.set(now);
+};
+beforeEach(function () {
+    mockdate_1.default.set(now);
+});
+afterEach(function () {
+    mockdate_1.default.reset();
+});
+function createManager(_a) {
+    var presentationIds = _a.presentationIds, _b = _a.options, options = _b === void 0 ? {} : _b;
+    var presentations = {};
+    var rePresentations = {};
+    presentationIds.forEach(function (id) {
+        presentations[id] = (0, testUtils_1.createPresentation)({
+            id: id,
+            applicationDeploymentId: 'app',
+            applicationVariables: {
+                content: { url: "https://cdn.test/".concat(id, ".mp4") },
+                muted: false,
+            },
+        });
+        rePresentations[id] = { id: id, applicationName: 'videos' };
+    });
+    var state = (0, testUtils_1.createPlaylistWindowManagerState)({
+        presentations: presentations,
+        applicationVersions: { app: (0, testUtils_1.createApplicationVersion)({ id: 'app' }) },
+    });
+    var reState = new RE.State({
+        main: {
+            id: 'main',
+            mode: RE.PlaylistMode.Sequential,
+            items: presentationIds.map(function (presentationId) { return ({ presentationId: presentationId }); }),
+        },
+    }, rePresentations, {});
+    var recording = (0, testUtils_1.createRecordingRenderer)();
+    var manager = new PlaylistWindowManager_1.default(__assign({ ruleEngine: new RE.RuleEngine('main', reState), state: state, logger: (0, testUtils_1.createLogger)(), closeWindowDelayMs: CLOSE_WINDOW_DELAY_MS }, options));
+    manager.setRenderer(recording.renderer);
+    return { manager: manager, recording: recording };
+}
+// Plays the app and app renderer the way a still-image app does: ready on
+// render, and a first paint shortly after each play.
+function scriptImageApp(recording) {
+    recording.hooks.onLoad = function (windowId) { return recording.receive(windowId, 'loaded'); };
+    recording.hooks.onMessage = function (windowId, type) {
+        if (type === 'render')
+            recording.receive(windowId, 'presentation_ready');
+        if (type === 'play') {
+            setTimeout(function () { return recording.receive(windowId, 'first_painted'); }, 0);
+        }
+    };
+}
+// The window most recently shown, which is the one playing.
+function lastShown(recording) {
+    var shows = recording.calls.filter(function (c) { return c.method === 'showWindow'; });
+    return shows[shows.length - 1].windowId;
+}
+// Names windows w1, w2, … in creation order so a sequence reads the same on
+// every run.
+function describeCalls(recording) {
+    var aliases = {};
+    return recording.calls.map(function (_a) {
+        var method = _a.method, windowId = _a.windowId, args = _a.args;
+        if (!aliases[windowId]) {
+            aliases[windowId] = "w".concat(Object.keys(aliases).length + 1);
+        }
+        var detail = method === 'sendMessageString' || method === 'sendMessageObject'
+            ? " ".concat(args[0])
+            : '';
+        return "".concat(method, " ").concat(aliases[windowId]).concat(detail);
+    });
+}
+describe('no surface host', function () {
+    test('a two-presentation swap keeps the renderer call sequence', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, recording, current;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createManager({
+                        presentationIds: ['a', 'b'],
+                    }), manager = _a.manager, recording = _a.recording;
+                    scriptImageApp(recording);
+                    return [4 /*yield*/, manager.load()];
+                case 1:
+                    _b.sent();
+                    return [4 /*yield*/, (0, testUtils_1.flush)()];
+                case 2:
+                    _b.sent();
+                    manager.show();
+                    manager.play();
+                    return [4 /*yield*/, (0, testUtils_1.flush)()];
+                case 3:
+                    _b.sent();
+                    current = lastShown(recording);
+                    passTime();
+                    recording.receive(current, 'presentation_complete');
+                    return [4 /*yield*/, (0, testUtils_1.flush)()];
+                case 4:
+                    _b.sent();
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, CLOSE_WINDOW_DELAY_MS); })];
+                case 5:
+                    _b.sent();
+                    return [4 /*yield*/, (0, testUtils_1.flush)()];
+                case 6:
+                    _b.sent();
+                    expect(describeCalls(recording)).toMatchSnapshot();
+                    return [4 /*yield*/, manager.destroy()];
+                case 7:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+// Plays the Videos app and app renderer the way the Videos plan describes,
+// replying a task later as postMessage does: ask for a surface on render when
+// offered one, size the hole and become ready on the first frame, open the
+// hole on video_shown, complete on ended, fall back to <video> on a refusal.
+function scriptApps(recording, host, script) {
+    var images = script.images || [];
+    var holdFirstFrame = new Set(script.holdFirstFrame || []);
+    var holdHole = new Set(script.holdHole || []);
+    var preopenHole = new Set(script.preopenHole || []);
+    var presentationOf = {};
+    var isReady = {};
+    var reply = function (windowId, type, payload) {
+        setTimeout(function () { return recording.receive(windowId, type, payload); }, 0);
+    };
+    var ready = function (windowId) {
+        if (isReady[windowId])
+            return;
+        isReady[windowId] = true;
+        reply(windowId, 'presentation_ready');
+    };
+    var surfaceOf = function (presentationId) {
+        var opens = host.calls.filter(function (c) {
+            return c.method === 'openVideo' &&
+                c.args[0].label === presentationId &&
+                c.id !== undefined;
+        });
+        return opens[opens.length - 1].id;
+    };
+    var emitFirstFrame = function (presentationId) {
+        host.emit(surfaceOf(presentationId), {
+            type: 'first_frame',
+            width: 1920,
+            height: 1080,
+            durationS: 10,
+        });
+    };
+    recording.hooks.onLoad = function (windowId) { return reply(windowId, 'loaded'); };
+    recording.hooks.onMessage = function (windowId, type, payload) {
+        var presentationId = presentationOf[windowId];
+        switch (type) {
+            case 'render': {
+                var id = payload.presentation.id;
+                presentationOf[windowId] = id;
+                if (payload.nativeVideo && images.indexOf(id) === -1) {
+                    reply(windowId, 'open_video', {
+                        url: "https://cdn.test/".concat(id, ".mp4"),
+                        bounds: { x: 0, y: 0, width: 1920, height: 1080 },
+                        muted: false,
+                    });
+                }
+                else {
+                    ready(windowId);
+                }
+                break;
+            }
+            case 'video_refused':
+                ready(windowId);
+                break;
+            case 'video_opened':
+                if (!holdFirstFrame.has(presentationId)) {
+                    setTimeout(function () { return emitFirstFrame(presentationId); }, 0);
+                }
+                break;
+            case 'video_event':
+                if (payload.type === 'first_frame') {
+                    reply(windowId, 'video_bounds', {
+                        bounds: { x: 0, y: 0, width: 1920, height: 1080 },
+                    });
+                    ready(windowId);
+                    if (preopenHole.has(presentationId)) {
+                        reply(windowId, 'video_hole_open');
+                    }
+                }
+                if (payload.type === 'ended') {
+                    reply(windowId, 'presentation_complete');
+                }
+                break;
+            case 'video_shown':
+                if (holdHole.has(presentationId)) {
+                    holdHole.delete(presentationId);
+                }
+                else {
+                    reply(windowId, 'video_hole_open');
+                }
+                break;
+            case 'play':
+                reply(windowId, 'first_painted');
+                break;
+        }
+    };
+    var windowOf = function (presentationId) {
+        var ids = Object.keys(presentationOf).filter(function (w) { return presentationOf[w] === presentationId; });
+        return ids[ids.length - 1];
+    };
+    return { presentationOf: presentationOf, surfaceOf: surfaceOf, emitFirstFrame: emitFirstFrame, windowOf: windowOf };
+}
+function createSurfaceManager(presentationIds, script, hostOpts, managerOptions, showAfterRevealMs) {
+    var _this = this;
+    if (script === void 0) { script = {}; }
+    if (managerOptions === void 0) { managerOptions = {}; }
+    var host = (0, testUtils_1.createFakeSurfaceHost)(hostOpts);
+    var warn = jest.fn();
+    var _a = createManager({
+        presentationIds: presentationIds,
+        options: __assign({ surfaces: __assign(__assign({}, host.surfaces), { showAfterRevealMs: showAfterRevealMs }), logger: (0, testUtils_1.createLogger)({ warn: warn }) }, managerOptions),
+    }), manager = _a.manager, recording = _a.recording;
+    var apps = scriptApps(recording, host, script);
+    // Every call and app message in order. A window and its surface are named
+    // by their presentation, and a later window of the same presentation gets
+    // a number: a, then a2.
+    var entries = function () {
+        var nameWith = function (counts, label) {
+            counts[label] = (counts[label] || 0) + 1;
+            return counts[label] === 1 ? label : "".concat(label).concat(counts[label]);
+        };
+        var windowCounts = {};
+        var windowName = {};
+        Object.keys(apps.presentationOf).forEach(function (windowId) {
+            windowName[windowId] = nameWith(windowCounts, apps.presentationOf[windowId]);
+        });
+        var surfaceCounts = {};
+        var labelOf = {};
+        host.calls.forEach(function (c) {
+            if (c.method === 'openVideo' && c.id !== undefined) {
+                labelOf[c.id] = nameWith(surfaceCounts, c.args[0].label);
+            }
+        });
+        var rendererEntries = recording.calls.map(function (c) {
+            var name = windowName[c.windowId] || '?';
+            var detail = c.method === 'sendMessageString' || c.method === 'setWindowBackground'
+                ? " ".concat(c.args[0])
+                : '';
+            return { seq: c.seq, text: "".concat(c.method, " ").concat(name).concat(detail) };
+        });
+        var appEntries = recording.received.map(function (c) { return ({
+            seq: c.seq,
+            text: "app ".concat(windowName[c.windowId] || '?', " ").concat(c.method),
+        }); });
+        var hostEntries = host.calls.map(function (c) {
+            var name = c.id !== undefined ? labelOf[c.id] : '';
+            var detail = c.method === 'setMuted' ? " ".concat(c.args[0]) : '';
+            var onHole = c.method === 'onHole' ? " ".concat(c.args[0]) : '';
+            return {
+                seq: c.seq,
+                text: "host ".concat(c.method).concat(name ? " ".concat(name) : '').concat(detail).concat(onHole),
+            };
+        });
+        return rendererEntries
+            .concat(appEntries, hostEntries)
+            .sort(function (x, y) { return x.seq - y.seq; });
+    };
+    var timeline = function () { return entries().map(function (e) { return e.text; }); };
+    var sent = function (presentationId, type) {
+        return recording.calls.filter(function (c) {
+            return c.method === 'sendMessageString' &&
+                c.args[0] === type &&
+                apps.presentationOf[c.windowId] === presentationId;
+        });
+    };
+    var hostCalls = function (method, presentationId) {
+        var ids = presentationId === undefined
+            ? null
+            : host.calls
+                .filter(function (c) {
+                return c.method === 'openVideo' &&
+                    c.args[0].label === presentationId;
+            })
+                .map(function (c) { return c.id; });
+        return host.calls.filter(function (c) { return c.method === method && (ids === null || ids.indexOf(c.id) !== -1); });
+    };
+    var complete = function (presentationId) { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    passTime();
+                    recording.receive(apps.windowOf(presentationId), 'presentation_complete');
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    var start = function () { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, manager.load()];
+                case 1:
+                    _a.sent();
+                    manager.show();
+                    manager.play();
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    return {
+        manager: manager,
+        recording: recording,
+        host: host,
+        warn: warn,
+        apps: apps,
+        entries: entries,
+        timeline: timeline,
+        sent: sent,
+        hostCalls: hostCalls,
+        complete: complete,
+        start: start,
+    };
+}
+// The calls and messages a swap's order is read from.
+var swapSteps = [
+    'host setMuted',
+    'muteWindow',
+    'host show',
+    'sendMessageString',
+    'app',
+    'setWindowBackground',
+    'showWindow',
+    'hideWindow',
+    'host close',
+    'removeWindow',
+];
+// Leaves out the next window's preload, which runs alongside the swap, and
+// messages that are not part of the swap's order.
+var isSwapStep = function (line) {
+    return swapSteps.some(function (step) { return line.startsWith(step); }) &&
+        !/ (\?|[a-z]\d)( |$)/.test(line) &&
+        !/ (render|play|log_\w+|loaded|video_opened|video_event)$/.test(line) &&
+        !/app \S+ (presentation_ready|video_bounds|open_video)/.test(line);
+};
+describe('a manager given a surface host', function () {
+    test('an app asks through miraVideo and render carries nativeVideo', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, sent, hostCalls, start;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createSurfaceManager(['a']), manager = _a.manager, sent = _a.sent, hostCalls = _a.hostCalls, start = _a.start;
+                    return [4 /*yield*/, start()];
+                case 1:
+                    _b.sent();
+                    expect(sent('a', 'render')[0].args[1]).toMatchObject({
+                        nativeVideo: true,
+                    });
+                    expect(hostCalls('openVideo')).toHaveLength(1);
+                    expect(hostCalls('openVideo')[0].args[0]).toEqual({
+                        url: 'https://cdn.test/a.mp4',
+                        bounds: { x: 0, y: 0, width: 1920, height: 1080 },
+                        muted: true,
+                        label: 'a',
+                    });
+                    return [4 /*yield*/, manager.destroy()];
+                case 2:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('the first presentation shows its surface before its frame, and plays after the hole opens', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, host, timeline, start, steps;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createSurfaceManager(['a']), manager = _a.manager, host = _a.host, timeline = _a.timeline, start = _a.start;
+                    return [4 /*yield*/, start()];
+                case 1:
+                    _b.sent();
+                    steps = timeline().filter(function (line) {
+                        return line.startsWith('host show') ||
+                            line.startsWith('host play') ||
+                            line.startsWith('host onHole') ||
+                            line.startsWith('showWindow') ||
+                            line === 'sendMessageString a video_shown' ||
+                            line === 'sendMessageString a play' ||
+                            line === 'app a video_hole_open';
+                    });
+                    expect(steps).toEqual([
+                        'host show a',
+                        'sendMessageString a video_shown',
+                        'app a video_hole_open',
+                        'host onHole true',
+                        'showWindow a',
+                        'sendMessageString a play',
+                        'host play a',
+                    ]);
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 2:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('the next presentation preloads hidden and is ready on its first frame, then its bounds', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, recording, host, apps, hostCalls, start, next;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createSurfaceManager(['a', 'b'], { holdFirstFrame: ['b'] }), manager = _a.manager, recording = _a.recording, host = _a.host, apps = _a.apps, hostCalls = _a.hostCalls, start = _a.start;
+                    return [4 /*yield*/, start()];
+                case 1:
+                    _b.sent();
+                    next = manager.nextWindow;
+                    expect(hostCalls('openVideo', 'b')).toHaveLength(1);
+                    expect(next.isReady()).toBe(false);
+                    // The first frame alone does not make it ready; the bounds that follow do.
+                    recording.hooks.onMessage = (function (original) { return function (w, type, payload) {
+                        if (type === 'video_event' && payload.type === 'first_frame')
+                            return;
+                        if (original)
+                            original(w, type, payload);
+                    }; })(recording.hooks.onMessage);
+                    apps.emitFirstFrame('b');
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    expect(next.isReady()).toBe(false);
+                    recording.receive(apps.windowOf('b'), 'video_bounds', {
+                        bounds: { x: 0, y: 0.4, width: 1920.4, height: 1080 },
+                    });
+                    recording.receive(apps.windowOf('b'), 'presentation_ready');
+                    expect(next.isReady()).toBe(true);
+                    expect(hostCalls('show', 'b')).toHaveLength(0);
+                    expect(hostCalls('setBounds', 'b')[0].args[0]).toEqual({
+                        x: 0,
+                        y: 0,
+                        width: 1920,
+                        height: 1080,
+                    });
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 3:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a video to video swap shows the new before it hides the old', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, recording, host, apps, timeline, complete, start, a, b, hiddenInRevealTask, showWindow, before, swap;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createSurfaceManager(['a', 'b']), manager = _a.manager, recording = _a.recording, host = _a.host, apps = _a.apps, timeline = _a.timeline, complete = _a.complete, start = _a.start;
+                    return [4 /*yield*/, start()];
+                case 1:
+                    _b.sent();
+                    a = apps.windowOf('a');
+                    b = apps.windowOf('b');
+                    hiddenInRevealTask = null;
+                    showWindow = recording.renderer.showWindow;
+                    recording.renderer.showWindow = function (windowId, isFocused) {
+                        showWindow(windowId, isFocused);
+                        if (windowId === b) {
+                            Promise.resolve().then(function () {
+                                hiddenInRevealTask = recording.calls.some(function (c) { return c.method === 'hideWindow' && c.windowId === a; });
+                            });
+                        }
+                    };
+                    before = timeline().length;
+                    return [4 /*yield*/, complete('a')];
+                case 2:
+                    _b.sent();
+                    swap = timeline().slice(before).filter(isSwapStep);
+                    expect(swap).toEqual([
+                        'app a presentation_complete',
+                        'host setMuted a true',
+                        'host show b',
+                        'host setMuted b false',
+                        'sendMessageString b video_shown',
+                        'app b video_hole_open',
+                        'setWindowBackground b transparent',
+                        'showWindow b',
+                        'hideWindow a',
+                        'app b first_painted',
+                        'sendMessageString a video_closing',
+                        'host close a',
+                        'removeWindow a',
+                    ]);
+                    expect(hiddenInRevealTask).toBe(true);
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 3:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a video to image swap reveals the image at once and closes the surface after its paint', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, host, timeline, complete, start, before, swap;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createSurfaceManager(['a', 'b'], { images: ['b'] }), manager = _a.manager, host = _a.host, timeline = _a.timeline, complete = _a.complete, start = _a.start;
+                    return [4 /*yield*/, start()];
+                case 1:
+                    _b.sent();
+                    before = timeline().length;
+                    return [4 /*yield*/, complete('a')];
+                case 2:
+                    _b.sent();
+                    swap = timeline().slice(before).filter(isSwapStep);
+                    expect(swap).toEqual([
+                        'app a presentation_complete',
+                        'host setMuted a true',
+                        'showWindow b',
+                        'app b first_painted',
+                        'hideWindow a',
+                        'sendMessageString a video_closing',
+                        'host close a',
+                        'removeWindow a',
+                    ]);
+                    expect(timeline()).toContain('host onHole false');
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 3:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('an image to video swap holds the image up until the surface is on screen', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, host, timeline, complete, start, before, swap;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createSurfaceManager(['a', 'b'], { images: ['a'] }), manager = _a.manager, host = _a.host, timeline = _a.timeline, complete = _a.complete, start = _a.start;
+                    return [4 /*yield*/, start()];
+                case 1:
+                    _b.sent();
+                    before = timeline().length;
+                    return [4 /*yield*/, complete('a')];
+                case 2:
+                    _b.sent();
+                    swap = timeline().slice(before).filter(isSwapStep);
+                    expect(swap).toEqual([
+                        'app a presentation_complete',
+                        'muteWindow a',
+                        'host show b',
+                        'host setMuted b false',
+                        'sendMessageString b video_shown',
+                        'app b video_hole_open',
+                        'setWindowBackground b transparent',
+                        'showWindow b',
+                        'hideWindow a',
+                        'app b first_painted',
+                        'removeWindow a',
+                    ]);
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 3:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test.each([
+        ['a hung show', { hangShow: true }, {}],
+        ['a missing hole acknowledgement', {}, { holdHole: ['a'] }],
+    ])('the first presentation with %s falls back to <video> and plays', function (_, hostOpts, script) { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, host, warn, sent, hostCalls, timeline, start;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createSurfaceManager(['a'], script, hostOpts), manager = _a.manager, host = _a.host, warn = _a.warn, sent = _a.sent, hostCalls = _a.hostCalls, timeline = _a.timeline, start = _a.start;
+                    return [4 /*yield*/, start()];
+                case 1:
+                    _b.sent();
+                    expect(sent('a', 'video_refused').map(function (c) { return c.args[1]; })).toEqual([
+                        { reason: 'deadline' },
+                    ]);
+                    expect(hostCalls('close', 'a')).toHaveLength(1);
+                    expect(timeline()).toContain('showWindow a');
+                    expect(sent('a', 'play')).toHaveLength(1);
+                    expect(timeline()).not.toContain('host onHole true');
+                    expect(warn.mock.calls.filter(function (_a) {
+                        var message = _a[0];
+                        return /video_refused.*deadline/.test(message);
+                    })).toHaveLength(1);
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 2:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test.each([
+        ['a hung show', 'hangShow'],
+        ['a missing hole acknowledgement', 'holdHole'],
+    ])('a swap with %s falls back to <video> and the playlist advances', function (_, fault) { return __awaiter(void 0, void 0, void 0, function () {
+        var script, _a, manager, host, sent, hostCalls, timeline, complete, start;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    script = fault === 'holdHole' ? { holdHole: ['b'] } : {};
+                    _a = createSurfaceManager(['a', 'b'], script), manager = _a.manager, host = _a.host, sent = _a.sent, hostCalls = _a.hostCalls, timeline = _a.timeline, complete = _a.complete, start = _a.start;
+                    return [4 /*yield*/, start()];
+                case 1:
+                    _b.sent();
+                    if (fault === 'hangShow')
+                        host.hangNextShow();
+                    return [4 /*yield*/, complete('a')];
+                case 2:
+                    _b.sent();
+                    expect(sent('b', 'video_refused').map(function (c) { return c.args[1]; })).toEqual([
+                        { reason: 'deadline' },
+                    ]);
+                    expect(hostCalls('close', 'b')).toHaveLength(1);
+                    expect(timeline()).toContain('showWindow b');
+                    expect(sent('b', 'play')).toHaveLength(1);
+                    expect(timeline().filter(function (line) { return line === 'host onHole true'; })).toHaveLength(1);
+                    expect(timeline()).toContain('removeWindow a');
+                    // The playlist advances to a again.
+                    return [4 /*yield*/, complete('b')];
+                case 3:
+                    // The playlist advances to a again.
+                    _b.sent();
+                    expect(sent('a', 'play').length).toBeGreaterThanOrEqual(2);
+                    return [4 /*yield*/, manager.destroy()];
+                case 4:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a window shown before open_video keeps <video>', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, recording, host, apps, sent, hostCalls, timeline, script;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createSurfaceManager(['a']), manager = _a.manager, recording = _a.recording, host = _a.host, apps = _a.apps, sent = _a.sent, hostCalls = _a.hostCalls, timeline = _a.timeline;
+                    script = recording.hooks.onMessage;
+                    recording.hooks.onMessage = function (w, type, payload) {
+                        if (type === 'render') {
+                            apps.presentationOf[w] = payload.presentation.id;
+                            setTimeout(function () { return recording.receive(w, 'presentation_ready'); }, 0);
+                            return;
+                        }
+                        if (script)
+                            script(w, type, payload);
+                    };
+                    return [4 /*yield*/, manager.load()];
+                case 1:
+                    _b.sent();
+                    manager.show();
+                    manager.play();
+                    recording.receive(apps.windowOf('a'), 'open_video', {
+                        url: 'https://cdn.test/a.mp4',
+                        bounds: { x: 0, y: 0, width: 1920, height: 1080 },
+                        muted: false,
+                    });
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    expect(timeline()).toContain('showWindow a');
+                    expect(hostCalls('openVideo')).toHaveLength(0);
+                    expect(sent('a', 'video_refused').map(function (c) { return c.args[1]; })).toEqual([
+                        { reason: 'not_offered' },
+                    ]);
+                    expect(sent('a', 'play')).toHaveLength(1);
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 3:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a window shown between video_opened and first_frame keeps <video>', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, recording, host, apps, sent, hostCalls, timeline, script, loaded;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createSurfaceManager(['a'], { holdFirstFrame: ['a'] }), manager = _a.manager, recording = _a.recording, host = _a.host, apps = _a.apps, sent = _a.sent, hostCalls = _a.hostCalls, timeline = _a.timeline;
+                    script = recording.hooks.onMessage;
+                    recording.hooks.onMessage = function (w, type, payload) {
+                        if (script)
+                            script(w, type, payload);
+                        if (type === 'video_opened') {
+                            setTimeout(function () { return recording.receive(w, 'presentation_ready'); }, 0);
+                        }
+                    };
+                    loaded = manager.load();
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _b.sent();
+                    expect(sent('a', 'video_opened')).toHaveLength(1);
+                    manager.show();
+                    return [4 /*yield*/, loaded];
+                case 2:
+                    _b.sent();
+                    manager.play();
+                    return [4 /*yield*/, settle()];
+                case 3:
+                    _b.sent();
+                    expect(timeline()).toContain('showWindow a');
+                    expect(hostCalls('show')).toHaveLength(0);
+                    expect(sent('a', 'video_refused').map(function (c) { return c.args[1]; })).toEqual([
+                        { reason: 'not_offered' },
+                    ]);
+                    expect(hostCalls('close', 'a')).toHaveLength(1);
+                    expect(sent('a', 'play')).toHaveLength(1);
+                    expect(hostCalls('onHole')).toHaveLength(0);
+                    expect(host.violations).toEqual([]);
+                    // A later first frame and ask change nothing.
+                    recording.receive(apps.windowOf('a'), 'open_video', {
+                        url: 'https://cdn.test/a.mp4',
+                        bounds: { x: 0, y: 0, width: 1920, height: 1080 },
+                        muted: false,
+                    });
+                    return [4 /*yield*/, settle()];
+                case 4:
+                    _b.sent();
+                    expect(hostCalls('openVideo')).toHaveLength(1);
+                    return [4 /*yield*/, manager.destroy()];
+                case 5:
+                    _b.sent();
+                    expect(host.liveIds()).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a second show() before the hole opens does nothing', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, recording, apps, sent, hostCalls, timeline;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createSurfaceManager(['a'], { holdHole: ['a'] }), manager = _a.manager, recording = _a.recording, apps = _a.apps, sent = _a.sent, hostCalls = _a.hostCalls, timeline = _a.timeline;
+                    return [4 /*yield*/, manager.load()];
+                case 1:
+                    _b.sent();
+                    manager.show();
+                    manager.show();
+                    manager.play();
+                    return [4 /*yield*/, (0, testUtils_1.flush)(20)];
+                case 2:
+                    _b.sent();
+                    recording.receive(apps.windowOf('a'), 'video_hole_open');
+                    return [4 /*yield*/, settle()];
+                case 3:
+                    _b.sent();
+                    expect(hostCalls('show')).toHaveLength(1);
+                    expect(sent('a', 'video_shown')).toHaveLength(1);
+                    expect(timeline().filter(function (line) { return line === 'host onHole true'; })).toHaveLength(1);
+                    return [4 /*yield*/, manager.destroy()];
+                case 4:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a one-video playlist replays by seeking, and destroy closes every surface', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, host, hostCalls, complete, start, plays;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createSurfaceManager([
+                        'a',
+                    ]), manager = _a.manager, host = _a.host, hostCalls = _a.hostCalls, complete = _a.complete, start = _a.start;
+                    return [4 /*yield*/, start()];
+                case 1:
+                    _b.sent();
+                    return [4 /*yield*/, complete('a')];
+                case 2:
+                    _b.sent();
+                    expect(hostCalls('seek', 'a').map(function (c) { return c.args[0]; })).toEqual([0]);
+                    plays = host.calls.filter(function (c) { return c.method === 'seek' || c.method === 'play'; });
+                    expect(plays.map(function (c) { return c.method; })).toEqual(['play', 'seek', 'play']);
+                    expect(hostCalls('close')).toHaveLength(0);
+                    return [4 /*yield*/, manager.destroy()];
+                case 3:
+                    _b.sent();
+                    expect(host.liveIds()).toEqual([]);
+                    expect(host.calls.filter(function (c) { return c.method === 'onHole'; }).map(function (c) { return c.args[0]; })).toEqual([true, false]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a short clip replays once, then advances when the next is ready', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, host, apps, sent, hostCalls, complete, start;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createSurfaceManager(['a', 'b'], { holdFirstFrame: ['b'] }), manager = _a.manager, host = _a.host, apps = _a.apps, sent = _a.sent, hostCalls = _a.hostCalls, complete = _a.complete, start = _a.start;
+                    return [4 /*yield*/, start()];
+                case 1:
+                    _b.sent();
+                    return [4 /*yield*/, complete('a')];
+                case 2:
+                    _b.sent();
+                    expect(hostCalls('seek', 'a')
+                        .map(function (c) { return c.method; })
+                        .concat(hostCalls('play', 'a').map(function (c) { return c.method; }))).toEqual(['seek', 'play', 'play']);
+                    expect(hostCalls('close', 'a')).toHaveLength(0);
+                    expect(hostCalls('show', 'b')).toHaveLength(0);
+                    apps.emitFirstFrame('b');
+                    return [4 /*yield*/, settle()];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, complete('a')];
+                case 4:
+                    _b.sent();
+                    expect(hostCalls('show', 'b')).toHaveLength(1);
+                    expect(sent('b', 'play')).toHaveLength(1);
+                    expect(hostCalls('close', 'a')).toHaveLength(1);
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 5:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a window whose surface closed before its turn swaps as today', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, recording, host, apps, hostCalls, timeline, complete, start;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createSurfaceManager(['a', 'b']), manager = _a.manager, recording = _a.recording, host = _a.host, apps = _a.apps, hostCalls = _a.hostCalls, timeline = _a.timeline, complete = _a.complete, start = _a.start;
+                    return [4 /*yield*/, start()];
+                case 1:
+                    _b.sent();
+                    recording.receive(apps.windowOf('b'), 'close_video');
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    expect(hostCalls('close', 'b')).toHaveLength(1);
+                    return [4 /*yield*/, complete('a')];
+                case 3:
+                    _b.sent();
+                    expect(hostCalls('show', 'b')).toHaveLength(0);
+                    expect(timeline()).toContain('showWindow b');
+                    expect(timeline()).toContain('removeWindow a');
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 4:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('an error event is forwarded, then the surface closes and the frame background returns', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, host, apps, sent, hostCalls, timeline, start;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createSurfaceManager(['a']), manager = _a.manager, host = _a.host, apps = _a.apps, sent = _a.sent, hostCalls = _a.hostCalls, timeline = _a.timeline, start = _a.start;
+                    return [4 /*yield*/, start()];
+                case 1:
+                    _b.sent();
+                    host.emit(apps.surfaceOf('a'), { type: 'error', reason: 'decode' });
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    expect(sent('a', 'video_event').map(function (c) { return c.args[1]; })).toContainEqual({
+                        type: 'error',
+                        reason: 'decode',
+                    });
+                    expect(hostCalls('close', 'a')).toHaveLength(1);
+                    expect(host.calls.filter(function (c) { return c.method === 'onHole'; }).map(function (c) { return c.args[0]; })).toEqual([true, false]);
+                    expect(timeline().filter(function (line) { return line.startsWith('setWindowBackground'); })).toEqual([
+                        'setWindowBackground a transparent',
+                        'setWindowBackground a #000000',
+                    ]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 3:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('stalled is forwarded and leaves the surface open', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, host, apps, sent, hostCalls, start;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createSurfaceManager(['a']), manager = _a.manager, host = _a.host, apps = _a.apps, sent = _a.sent, hostCalls = _a.hostCalls, start = _a.start;
+                    return [4 /*yield*/, start()];
+                case 1:
+                    _b.sent();
+                    host.emit(apps.surfaceOf('a'), { type: 'stalled' });
+                    host.emit(apps.surfaceOf('a'), { type: 'playing' });
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    expect(sent('a', 'video_event').map(function (c) { return c.args[1].type; })).toEqual(['first_frame', 'stalled', 'playing']);
+                    expect(hostCalls('close', 'a')).toHaveLength(0);
+                    return [4 /*yield*/, manager.destroy()];
+                case 3:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+describe('a swap survives what runs during its wait', function () {
+    // A three-video playlist whose second app holds its hole closed, so the
+    // swap from a to b waits; its deadline outlasts the test's steps.
+    function startWaitingSwap(images) {
+        if (images === void 0) { images = []; }
+        return __awaiter(this, void 0, void 0, function () {
+            var setup, a, b, shown, played, removed;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        setup = createSurfaceManager(['a', 'b', 'c'], { holdHole: ['b'], images: images }, undefined, { closeWindowDelayMs: 5000 });
+                        return [4 /*yield*/, setup.manager.load()];
+                    case 1:
+                        _a.sent();
+                        setup.manager.show();
+                        setup.manager.play();
+                        return [4 /*yield*/, settle()];
+                    case 2:
+                        _a.sent();
+                        a = setup.apps.windowOf('a');
+                        passTime();
+                        setup.recording.receive(a, 'presentation_complete');
+                        return [4 /*yield*/, settle()];
+                    case 3:
+                        _a.sent();
+                        b = setup.apps.windowOf('b');
+                        expect(setup.sent('b', 'video_shown')).toHaveLength(1);
+                        shown = function (windowId) {
+                            return setup.recording.calls.some(function (c) { return c.method === 'showWindow' && c.windowId === windowId; });
+                        };
+                        played = function (windowId) {
+                            return setup.recording.calls.filter(function (c) {
+                                return c.method === 'sendMessageString' &&
+                                    c.args[0] === 'play' &&
+                                    c.windowId === windowId;
+                            }).length;
+                        };
+                        removed = function (windowId) {
+                            return setup.recording.calls.some(function (c) { return c.method === 'removeWindow' && c.windowId === windowId; });
+                        };
+                        return [2 /*return*/, __assign(__assign({}, setup), { a: a, b: b, shown: shown, played: played, removed: removed })];
+                }
+            });
+        });
+    }
+    test('a late complete from the outgoing window starts no second swap', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, recording, a, b, hostCalls, shown, played;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, startWaitingSwap()];
+                case 1:
+                    _a = _b.sent(), manager = _a.manager, recording = _a.recording, a = _a.a, b = _a.b, hostCalls = _a.hostCalls, shown = _a.shown, played = _a.played;
+                    passTime();
+                    recording.receive(a, 'presentation_complete');
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    expect(hostCalls('show')).toHaveLength(2);
+                    expect(manager.currentWindow).not.toBeNull();
+                    expect(shown(b)).toBe(false);
+                    recording.receive(b, 'video_hole_open');
+                    return [4 /*yield*/, settle()];
+                case 3:
+                    _b.sent();
+                    expect(shown(b)).toBe(true);
+                    expect(played(b)).toBe(1);
+                    return [4 /*yield*/, manager.destroy()];
+                case 4:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('the next window is preloaded only once the swap has finished', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, recording, apps, b, shown, removed, c;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, startWaitingSwap()];
+                case 1:
+                    _a = _b.sent(), manager = _a.manager, recording = _a.recording, apps = _a.apps, b = _a.b, shown = _a.shown, removed = _a.removed;
+                    expect(apps.windowOf('c')).toBeUndefined();
+                    expect(manager.nextWindow).toBeNull();
+                    recording.receive(b, 'video_hole_open');
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    expect(shown(b)).toBe(true);
+                    expect(removed(apps.windowOf('a'))).toBe(true);
+                    c = apps.windowOf('c');
+                    expect(c).toBeDefined();
+                    expect(manager.nextWindow.isReady()).toBe(true);
+                    return [4 /*yield*/, manager.destroy()];
+                case 3:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('the incoming window failing while its show waits preloads the next at once, and the playlist moves on', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, recording, host, apps, a, b, shown, played, removed, c;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, startWaitingSwap(['a'])];
+                case 1:
+                    _a = _b.sent(), manager = _a.manager, recording = _a.recording, host = _a.host, apps = _a.apps, a = _a.a, b = _a.b, shown = _a.shown, played = _a.played, removed = _a.removed;
+                    // b fails mid-swap: c preloads now and b restarts while it loads.
+                    passTime();
+                    recording.fail(b, new Error('crashed'));
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    c = apps.windowOf('c');
+                    expect(c).toBeDefined();
+                    expect(manager.nextWindow.isReady()).toBe(true);
+                    // At b's next complete the manager moves on to c; b is never revealed.
+                    passTime();
+                    recording.receive(b, 'presentation_complete');
+                    return [4 /*yield*/, settle()];
+                case 3:
+                    _b.sent();
+                    expect(removed(b)).toBe(true);
+                    expect(shown(b)).toBe(false);
+                    expect(played(b)).toBe(0);
+                    expect(shown(c)).toBe(true);
+                    expect(played(c)).toBe(1);
+                    expect(removed(a)).toBe(true);
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 4:
+                    _b.sent();
+                    return [4 /*yield*/, settle()];
+                case 5:
+                    _b.sent();
+                    expect(host.liveIds()).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a publish during the wait preloads its next window at once, and the swap preloads none', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, recording, host, apps, b, shown, played, removed, created, createdBefore, ruleEngine, published;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, startWaitingSwap()];
+                case 1:
+                    _a = _b.sent(), manager = _a.manager, recording = _a.recording, host = _a.host, apps = _a.apps, b = _a.b, shown = _a.shown, played = _a.played, removed = _a.removed;
+                    created = function () {
+                        return recording.calls.filter(function (call) { return call.method === 'createWindow'; }).length;
+                    };
+                    createdBefore = created();
+                    ruleEngine = manager.getRuleEngine();
+                    published = manager.setRuleEngine(new RE.RuleEngine('main', new RE.State({
+                        main: {
+                            id: 'main',
+                            mode: RE.PlaylistMode.Sequential,
+                            items: [{ presentationId: 'b' }, { presentationId: 'a' }],
+                        },
+                    }, ruleEngine.state.presentations, {})));
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    expect(created()).toBe(createdBefore + 1);
+                    expect(removed(b)).toBe(false);
+                    recording.receive(b, 'video_hole_open');
+                    return [4 /*yield*/, settle()];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, published];
+                case 4:
+                    _b.sent();
+                    expect(shown(b)).toBe(true);
+                    expect(played(b)).toBe(1);
+                    expect(created()).toBe(createdBefore + 1);
+                    expect(apps.windowOf('c')).toBeUndefined();
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 5:
+                    _b.sent();
+                    return [4 /*yield*/, settle()];
+                case 6:
+                    _b.sent();
+                    expect(host.liveIds()).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a preview change during the wait preloads its next window at once, and the swap preloads none', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, recording, apps, b, shown, played, created, createdBefore, ruleEngine, checked;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, startWaitingSwap()];
+                case 1:
+                    _a = _b.sent(), manager = _a.manager, recording = _a.recording, apps = _a.apps, b = _a.b, shown = _a.shown, played = _a.played;
+                    created = function () {
+                        return recording.calls.filter(function (call) { return call.method === 'createWindow'; }).length;
+                    };
+                    createdBefore = created();
+                    ruleEngine = manager.getRuleEngine();
+                    jest.spyOn(ruleEngine, 'previewNext').mockReturnValue({
+                        presentationId: 'a',
+                        shouldInterrupt: false,
+                        playlistId: 'main',
+                        rule: null,
+                    });
+                    checked = manager.checkPreviewAction();
+                    return [4 /*yield*/, settle()];
+                case 2:
+                    _b.sent();
+                    expect(created()).toBe(createdBefore + 1);
+                    recording.receive(b, 'video_hole_open');
+                    return [4 /*yield*/, settle()];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, checked];
+                case 4:
+                    _b.sent();
+                    expect(shown(b)).toBe(true);
+                    expect(played(b)).toBe(1);
+                    expect(created()).toBe(createdBefore + 1);
+                    expect(apps.windowOf('c')).toBeUndefined();
+                    return [4 /*yield*/, manager.destroy()];
+                case 5:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('destroy during the wait leaves no window and no surface', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, recording, host, callsAtDestroy;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, startWaitingSwap()];
+                case 1:
+                    _a = _b.sent(), manager = _a.manager, recording = _a.recording, host = _a.host;
+                    return [4 /*yield*/, manager.destroy()];
+                case 2:
+                    _b.sent();
+                    callsAtDestroy = recording.calls.length;
+                    return [4 /*yield*/, settle()];
+                case 3:
+                    _b.sent();
+                    expect(recording.calls
+                        .slice(callsAtDestroy)
+                        .filter(function (c) { return c.method === 'createWindow'; })).toHaveLength(0);
+                    expect(host.liveIds()).toEqual([]);
+                    expect(recording.liveWindowIds()).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+describe('swap timing, on fake timers', function () {
+    beforeEach(function () {
+        jest.useFakeTimers();
+    });
+    afterEach(function () {
+        jest.useRealTimers();
+    });
+    // Lets promise callbacks run between fake timers.
+    var microtasks = function () { return __awaiter(void 0, void 0, void 0, function () {
+        var i;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < 50)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, Promise.resolve()];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    i += 1;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); };
+    // A surface manager driven a millisecond at a time, whose host reports
+    // playing 25 ms after each play. Every call and app message is stamped
+    // with the millisecond it happened in.
+    function startTimed(presentationIds, script, hostOpts, showAfterRevealMs) {
+        if (hostOpts === void 0) { hostOpts = {
+            playingAfterMs: 25,
+        }; }
+        return __awaiter(this, void 0, void 0, function () {
+            var setup, clock, mostLive, stamps, stamp, tick, loading, completeAt, since, settleNow;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        setup = createSurfaceManager(presentationIds, script, hostOpts, {}, showAfterRevealMs);
+                        clock = 0;
+                        mostLive = 0;
+                        stamps = {};
+                        stamp = function () {
+                            setup.entries().forEach(function (e) {
+                                if (stamps[e.seq] === undefined)
+                                    stamps[e.seq] = clock;
+                            });
+                            mostLive = Math.max(mostLive, setup.host.liveIds().length);
+                        };
+                        tick = function (ms) { return __awaiter(_this, void 0, void 0, function () {
+                            var i;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        i = 0;
+                                        _a.label = 1;
+                                    case 1:
+                                        if (!(i < ms)) return [3 /*break*/, 4];
+                                        jest.advanceTimersByTime(1);
+                                        clock += 1;
+                                        return [4 /*yield*/, microtasks()];
+                                    case 2:
+                                        _a.sent();
+                                        stamp();
+                                        _a.label = 3;
+                                    case 3:
+                                        i += 1;
+                                        return [3 /*break*/, 1];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        loading = setup.manager.load();
+                        return [4 /*yield*/, tick(10)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, loading];
+                    case 2:
+                        _a.sent();
+                        setup.manager.show();
+                        setup.manager.play();
+                        return [4 /*yield*/, tick(200)];
+                    case 3:
+                        _a.sent();
+                        completeAt = function (presentationId) { return __awaiter(_this, void 0, void 0, function () {
+                            var entries, mark;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        passTime();
+                                        entries = setup.entries();
+                                        mark = {
+                                            t0: clock,
+                                            fromSeq: entries.length ? entries[entries.length - 1].seq : 0,
+                                        };
+                                        setup.recording.receive(setup.apps.windowOf(presentationId), 'presentation_complete');
+                                        return [4 /*yield*/, microtasks()];
+                                    case 1:
+                                        _a.sent();
+                                        stamp();
+                                        return [2 /*return*/, mark];
+                                }
+                            });
+                        }); };
+                        since = function (mark) {
+                            stamp();
+                            return setup
+                                .entries()
+                                .filter(function (e) { return e.seq > mark.fromSeq; })
+                                .map(function (e) { return "".concat(stamps[e.seq] - mark.t0, " ").concat(e.text); });
+                        };
+                        settleNow = function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, microtasks()];
+                                    case 1:
+                                        _a.sent();
+                                        stamp();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        return [2 /*return*/, __assign(__assign({}, setup), { tick: tick, settleNow: settleNow, completeAt: completeAt, since: since, mostLive: function () { return mostLive; } })];
+                }
+            });
+        });
+    }
+    // The swap's steps: surface calls, the frames shown, hidden, created and
+    // removed, and the messages that start, show and close a surface.
+    var isTimedStep = function (line) {
+        return / (host (?!setBounds)|showWindow|hideWindow|removeWindow|createWindow|setWindowBackground)/.test(line) ||
+            / sendMessageString \S+ (play|video_shown|video_closing|video_refused)$/.test(line) ||
+            / app \S+ video_hole_open$/.test(line);
+    };
+    test('an app that opened its hole while hidden plays, is revealed on playing with the outgoing hidden, then is shown and unmuted', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, recording, host, apps, tick, completeAt, since, mostLive, a, b, hiddenInRevealTask, showWindow, mark;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, startTimed(['a', 'b'], { preopenHole: ['a', 'b'] })];
+                case 1:
+                    _a = _b.sent(), manager = _a.manager, recording = _a.recording, host = _a.host, apps = _a.apps, tick = _a.tick, completeAt = _a.completeAt, since = _a.since, mostLive = _a.mostLive;
+                    a = apps.windowOf('a');
+                    b = apps.windowOf('b');
+                    hiddenInRevealTask = null;
+                    showWindow = recording.renderer.showWindow;
+                    recording.renderer.showWindow = function (windowId, isFocused) {
+                        showWindow(windowId, isFocused);
+                        if (windowId === b) {
+                            Promise.resolve().then(function () {
+                                hiddenInRevealTask = recording.calls.some(function (c) { return c.method === 'hideWindow' && c.windowId === a; });
+                            });
+                        }
+                    };
+                    return [4 /*yield*/, completeAt('a')];
+                case 2:
+                    mark = _b.sent();
+                    return [4 /*yield*/, tick(300)];
+                case 3:
+                    _b.sent();
+                    expect(since(mark).filter(isTimedStep)).toEqual([
+                        '0 host setMuted a true',
+                        '0 host play b',
+                        '25 host onHole true',
+                        '25 setWindowBackground b transparent',
+                        '25 showWindow b',
+                        '25 hideWindow a',
+                        '25 sendMessageString b play',
+                        '105 host show b',
+                        '105 host setMuted b false',
+                        '105 sendMessageString b video_shown',
+                        '105 sendMessageString a video_closing',
+                        '105 host close a',
+                        '105 host onHole false',
+                        '105 removeWindow a',
+                        '105 createWindow a2',
+                        '106 app b video_hole_open',
+                        '106 host openVideo a2',
+                        '107 app a2 video_hole_open',
+                    ]);
+                    expect(hiddenInRevealTask).toBe(true);
+                    expect(mostLive()).toBeLessThanOrEqual(2);
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 4:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('an app that has not opened its hole keeps the show, hole, reveal, play order', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, host, tick, completeAt, since, mostLive, mark;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, startTimed(['a', 'b'], {})];
+                case 1:
+                    _a = _b.sent(), manager = _a.manager, host = _a.host, tick = _a.tick, completeAt = _a.completeAt, since = _a.since, mostLive = _a.mostLive;
+                    return [4 /*yield*/, completeAt('a')];
+                case 2:
+                    mark = _b.sent();
+                    return [4 /*yield*/, tick(300)];
+                case 3:
+                    _b.sent();
+                    expect(since(mark).filter(isTimedStep)).toEqual([
+                        '0 host setMuted a true',
+                        '0 host show b',
+                        '0 host setMuted b false',
+                        '0 sendMessageString b video_shown',
+                        '1 app b video_hole_open',
+                        '1 host onHole true',
+                        '1 setWindowBackground b transparent',
+                        '1 showWindow b',
+                        '1 hideWindow a',
+                        '1 sendMessageString b play',
+                        '1 host play b',
+                        '2 sendMessageString a video_closing',
+                        '2 host close a',
+                        '2 host onHole false',
+                        '2 removeWindow a',
+                        '2 createWindow a2',
+                        '3 host openVideo a2',
+                    ]);
+                    expect(mostLive()).toBeLessThanOrEqual(2);
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 4:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a surface that never reports playing is revealed at the show deadline', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, host, warn, tick, completeAt, since, mark, steps;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, startTimed(['a', 'b'], { preopenHole: ['b'] }, {})];
+                case 1:
+                    _a = _b.sent(), manager = _a.manager, host = _a.host, warn = _a.warn, tick = _a.tick, completeAt = _a.completeAt, since = _a.since;
+                    return [4 /*yield*/, completeAt('a')];
+                case 2:
+                    mark = _b.sent();
+                    return [4 /*yield*/, tick(300)];
+                case 3:
+                    _b.sent();
+                    steps = since(mark).filter(isTimedStep);
+                    expect(steps).toContain('0 host play b');
+                    expect(steps).toContain("".concat(CLOSE_WINDOW_DELAY_MS, " showWindow b"));
+                    expect(steps).toContain("".concat(CLOSE_WINDOW_DELAY_MS + 80, " host show b"));
+                    expect(warn.mock.calls.filter(function (_a) {
+                        var message = _a[0];
+                        return /No 'playing'/.test(message);
+                    })).toHaveLength(1);
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 4:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('surfaces.showAfterRevealMs sets the show after the reveal', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, tick, completeAt, since, mark, steps;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, startTimed(['a', 'b'], { preopenHole: ['b'] }, undefined, 30)];
+                case 1:
+                    _a = _b.sent(), manager = _a.manager, tick = _a.tick, completeAt = _a.completeAt, since = _a.since;
+                    return [4 /*yield*/, completeAt('a')];
+                case 2:
+                    mark = _b.sent();
+                    return [4 /*yield*/, tick(300)];
+                case 3:
+                    _b.sent();
+                    steps = since(mark).filter(isTimedStep);
+                    expect(steps).toContain('25 showWindow b');
+                    expect(steps).toContain('55 host show b');
+                    expect(steps).toContain('55 host setMuted b false');
+                    return [4 /*yield*/, manager.destroy()];
+                case 4:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('over a playlist of swaps, two surfaces never sound at once and never more than two are live', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, host, tick, completeAt, hostCalls, mostLive, _i, _b, id;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, startTimed(['a', 'b', 'c'], { preopenHole: ['a', 'b', 'c'] })];
+                case 1:
+                    _a = _c.sent(), manager = _a.manager, host = _a.host, tick = _a.tick, completeAt = _a.completeAt, hostCalls = _a.hostCalls, mostLive = _a.mostLive;
+                    _i = 0, _b = ['a', 'b', 'c', 'a'];
+                    _c.label = 2;
+                case 2:
+                    if (!(_i < _b.length)) return [3 /*break*/, 6];
+                    id = _b[_i];
+                    return [4 /*yield*/, completeAt(id)];
+                case 3:
+                    _c.sent();
+                    return [4 /*yield*/, tick(1000)];
+                case 4:
+                    _c.sent();
+                    _c.label = 5;
+                case 5:
+                    _i++;
+                    return [3 /*break*/, 2];
+                case 6:
+                    expect(hostCalls('show')).toHaveLength(5);
+                    expect(mostLive()).toBe(2);
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 7:
+                    _c.sent();
+                    expect(host.liveIds()).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a publish while the next preload waits for the swap preloads at once, and once', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, apps, tick, settleNow, completeAt, since, host, sent, mark, ruleEngine, steps;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, startTimed(['a', 'b', 'c'], { preopenHole: ['a', 'b', 'c'] })];
+                case 1:
+                    _a = _b.sent(), manager = _a.manager, apps = _a.apps, tick = _a.tick, settleNow = _a.settleNow, completeAt = _a.completeAt, since = _a.since, host = _a.host, sent = _a.sent;
+                    return [4 /*yield*/, completeAt('a')];
+                case 2:
+                    mark = _b.sent();
+                    return [4 /*yield*/, tick(10)];
+                case 3:
+                    _b.sent();
+                    ruleEngine = manager.getRuleEngine();
+                    manager.setRuleEngine(new RE.RuleEngine('main', new RE.State({
+                        main: {
+                            id: 'main',
+                            mode: RE.PlaylistMode.Sequential,
+                            items: [{ presentationId: 'a' }, { presentationId: 'c' }],
+                        },
+                    }, ruleEngine.state.presentations, {})));
+                    return [4 /*yield*/, settleNow()];
+                case 4:
+                    _b.sent();
+                    return [4 /*yield*/, tick(300)];
+                case 5:
+                    _b.sent();
+                    steps = since(mark).filter(isTimedStep);
+                    expect(steps.filter(function (line) { return / createWindow /.test(line); })).toEqual([
+                        '10 createWindow a2',
+                    ]);
+                    expect(steps).toContain('105 host close a');
+                    expect(steps).toContain('105 host openVideo a2');
+                    expect(sent('b', 'video_shown')).toHaveLength(1);
+                    expect(apps.windowOf('a')).not.toBe(undefined);
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 6:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a show that hangs after the reveal falls back to <video> in the revealed frame', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, host, tick, completeAt, since, sent, hostCalls, mark, deadlineAt, steps;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, startTimed(['a', 'b'], { preopenHole: ['b'] })];
+                case 1:
+                    _a = _b.sent(), manager = _a.manager, host = _a.host, tick = _a.tick, completeAt = _a.completeAt, since = _a.since, sent = _a.sent, hostCalls = _a.hostCalls;
+                    host.hangNextShow();
+                    return [4 /*yield*/, completeAt('a')];
+                case 2:
+                    mark = _b.sent();
+                    return [4 /*yield*/, tick(300)];
+                case 3:
+                    _b.sent();
+                    expect(sent('b', 'video_refused').map(function (c) { return c.args[1]; })).toEqual([
+                        { reason: 'deadline' },
+                    ]);
+                    deadlineAt = 105 + CLOSE_WINDOW_DELAY_MS;
+                    steps = since(mark).filter(isTimedStep);
+                    expect(steps).toContain('105 host show b');
+                    expect(steps).toContain("".concat(deadlineAt, " host close b"));
+                    expect(steps).toContain("".concat(deadlineAt, " setWindowBackground b #000000"));
+                    expect(steps.filter(function (line) { return / showWindow b$/.test(line); })).toEqual([
+                        '25 showWindow b',
+                    ]);
+                    expect(sent('b', 'play')).toHaveLength(1);
+                    expect(sent('b', 'video_shown')).toHaveLength(0);
+                    expect(hostCalls('setMuted', 'b')).toHaveLength(0);
+                    expect(steps).toContain("".concat(deadlineAt, " removeWindow a"));
+                    expect(host.violations).toEqual([]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 4:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a swap of two still images in a surface manager preloads in the swap and removes the outgoing at its paint', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, tick, completeAt, since, mark;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, startTimed(['a', 'b'], {
+                        images: ['a', 'b'],
+                    })];
+                case 1:
+                    _a = _b.sent(), manager = _a.manager, tick = _a.tick, completeAt = _a.completeAt, since = _a.since;
+                    return [4 /*yield*/, completeAt('a')];
+                case 2:
+                    mark = _b.sent();
+                    return [4 /*yield*/, tick(100)];
+                case 3:
+                    _b.sent();
+                    expect(since(mark).filter(isTimedStep)).toEqual([
+                        '0 showWindow b',
+                        '0 sendMessageString b play',
+                        '0 createWindow a2',
+                        '1 removeWindow a',
+                    ]);
+                    return [4 /*yield*/, manager.destroy()];
+                case 4:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('a manager with no surface host preloads in the swap and removes the outgoing at its paint', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, manager, recording, tick, loading, before, inSwapTask;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = createManager({
+                        presentationIds: ['a', 'b'],
+                    }), manager = _a.manager, recording = _a.recording;
+                    scriptImageApp(recording);
+                    tick = function (ms) { return __awaiter(void 0, void 0, void 0, function () {
+                        var i;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    i = 0;
+                                    _a.label = 1;
+                                case 1:
+                                    if (!(i < ms)) return [3 /*break*/, 4];
+                                    jest.advanceTimersByTime(1);
+                                    return [4 /*yield*/, microtasks()];
+                                case 2:
+                                    _a.sent();
+                                    _a.label = 3;
+                                case 3:
+                                    i += 1;
+                                    return [3 /*break*/, 1];
+                                case 4: return [2 /*return*/];
+                            }
+                        });
+                    }); };
+                    loading = manager.load();
+                    return [4 /*yield*/, tick(10)];
+                case 1:
+                    _b.sent();
+                    return [4 /*yield*/, loading];
+                case 2:
+                    _b.sent();
+                    manager.show();
+                    manager.play();
+                    return [4 /*yield*/, tick(10)];
+                case 3:
+                    _b.sent();
+                    before = recording.calls.length;
+                    passTime();
+                    recording.receive(lastShown(recording), 'presentation_complete');
+                    return [4 /*yield*/, microtasks()];
+                case 4:
+                    _b.sent();
+                    inSwapTask = describeCalls(recording).slice(before);
+                    return [4 /*yield*/, tick(5)];
+                case 5:
+                    _b.sent();
+                    // w1 is the incoming window, preloaded before w2 at load.
+                    expect(inSwapTask).toEqual([
+                        'showWindow w1',
+                        'unMuteWindow w1',
+                        'muteWindow w2',
+                        'sendMessageString w1 play',
+                        'createWindow w3',
+                        'muteWindow w3',
+                        'loadWindow w3',
+                        'sendMessageString w3 render',
+                    ]);
+                    expect(describeCalls(recording).slice(before)).toContain('removeWindow w2');
+                    return [4 /*yield*/, manager.destroy()];
+                case 6:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});