@swf2es/desktop 0.1.20 → 0.1.22

package/dist/main/main.js

@@ -9,30 +9,33 @@
 // --proxy=socks5://[user:pass@]host:port (or http://...) sends the SWF's network through a proxy.
 //
 // The second runs an AIR application by its descriptor, as adl does.
-import { statSync } from "node:fs";
-import { open as openFile, readFile, realpath } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+//
+// Its parts: state.ts, what they share; switches.ts, the command line's;
+// open.ts, what plays and opening it; permissions.ts, sockets and
+// WebSockets; dialogs.ts and menu.ts; air-bridge.ts, an AIR application's
+// reach. Here: start-up, the window and its page's messages.
+import { isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
-import { fileAttributes } from "@swf2es/format";
-import { app, BrowserWindow, dialog, ipcMain, Menu, safeStorage, screen, session, shell, } from "electron";
-import { airCommand, airLaunch, createDirectoryOf, EncryptedItems, listOf, moveOf, readOf, removeOf, statOf, writeOf, } from "./air.js";
-import { resolveCase } from "./case-paths.js";
+import { app, BrowserWindow, dialog, ipcMain, session, shell } from "electron";
+import { airCommand } from "./air.js";
+import { listenForAir } from "./air-bridge.js";
+import { chooseLibrary, fromPrompt, prompt, showOpenDialog, showUrlDialog } from "./dialogs.js";
 import { bridgeFiles } from "./files.js";
+import { buildMenu } from "./menu.js";
 import { failureLine, requestLine } from "./netlog.js";
-import { Network, Refused, unverifiedHosts } from "./network.js";
+import { Refused } from "./network-types.js";
+import { current, movieFromArguments, networkMovie, openAir, openChosen, openEntry, openUrl, remoteUrl, } from "./open.js";
+import { permitSocket, permitWebSocket } from "./permissions.js";
 import { APP_ORIGIN, registerScheme, serve } from "./protocol.js";
-import { describeProxy, proxyArgument, sameProxy } from "./proxy.js";
-import { Sandbox } from "./sandbox.js";
+import { proxyArgument, sameProxy } from "./proxy.js";
 import { SettingsFile } from "./settings.js";
 import { bridgeSockets } from "./sockets.js";
-import { dispatchedOpener, hasWebSocket, proxiedDispatcher, unverifiedDispatcher, webSocketOpener, } from "./websocket-connections.js";
+import { sandbox, setListening, setSettings, settings, setWindow, TITLE, trusted, window, } from "./state.js";
+import { logSockets, netLog, network, proxied, proxy, trace, via, warn, webSocketOpen, } from "./switches.js";
 import { bridgeWebSockets } from "./websockets.js";
 const preload = fileURLToPath(new URL("../preload/preload.cjs", import.meta.url));
-const promptPreload = fileURLToPath(new URL("../preload/prompt.cjs", import.meta.url));
 // The window's and the taskbar's icon, the project's, where the platform takes one from the window.
 const icon = fileURLToPath(new URL("../../static/icon.png", import.meta.url));
-const PROMPT_URL = `${APP_ORIGIN}/open-url.html`;
-const TITLE = "swf2es";
 // The tests keep their settings apart from the user's.
 const userData = process.env.SWF2ES_DESKTOP_USER_DATA;
 if (userData) {
@@ -44,140 +47,8 @@ const build = /^[\w.+-]{1,40}$/.test(process.env.SWF2ES_DESKTOP_BUILD ?? "")
     : null;
 registerScheme();
 app.enableSandbox();
-/** --trace: what the page logs, a SWF's trace() among it, goes to the terminal. */
-const trace = process.argv.includes("--trace");
-// Each request and socket of the SWF's said on stderr: the page's DevTools show none of them.
-// --log-sockets says what each socket sends and receives as well, and so the rest too.
-const logSockets = process.argv.includes("--log-sockets");
-const logNetwork = logSockets || process.argv.includes("--log-network");
-const netLog = logNetwork ? (line) => process.stderr.write(`${line}\n`) : null;
-const sandbox = new Sandbox();
-/** The SWF's http and https requests, judged as Flash's sandboxes had them. */
-/**
- * --ignore-certificate-errors[=host,...]: HTTPS servers whose certificates go
- * unchecked, for one's own with a certificate it signed itself. For this
- * run alone, never kept, and said aloud: anyone on the way to such a host
- * can read and change what the SWF loads from it.
- */
-const unverified = unverifiedHosts(process.argv.slice(1));
-if (unverified) {
-    process.stderr.write(unverified.all
-        ? "swf2es: --ignore-certificate-errors: no HTTPS or WSS server's certificate is verified\n"
-        : `swf2es: --ignore-certificate-errors: certificates are not verified for ${unverified.hosts.join(", ") || "no host"}\n`);
-}
-const unverifiedHost = (host) => !!unverified && (unverified.all || unverified.hosts.includes(host.toLowerCase()));
-/**
- * --proxy=<url>: what the SWF's requests, sockets and WebSockets go
- * through. For this run alone, never kept, and said aloud, without its
- * credentials. One that does not parse stops the app rather than letting
- * it run without.
- */
-const proxied = proxyArgument(process.argv.slice(1));
-if (proxied && "error" in proxied) {
-    process.stderr.write(`swf2es: ${proxied.error}\n`);
-    process.exit(2);
-}
-const proxy = proxied?.proxy ?? null;
-if (proxy) {
-    process.stderr.write(`swf2es: --proxy: the SWF's requests, sockets and WebSockets go through ${describeProxy(proxy)}\n`);
-}
-/** What --log-network adds to a line of a connection that went through the proxy. */
-const via = proxy ? " via proxy" : "";
-const warn = (message) => process.stderr.write(`swf2es: ${message}\n`);
-const network = new Network({ unverified: unverifiedHost, proxy });
-// What opens an AIR application's WebSockets: the global's client, a wss: server's certificate
-// unchecked where the switch names its host; or every one through the proxy.
-const insecureWebSockets = unverified && !proxy ? unverifiedDispatcher() : null;
-if (unverified && !proxy && !insecureWebSockets) {
-    process.stderr.write("swf2es: --ignore-certificate-errors: a WebSocket's certificate is verified all the same\n");
-}
-const proxiedWebSockets = proxy ? proxiedDispatcher(proxy, unverifiedHost, warn) : null;
-// Never past the proxy: where none can be made, no WebSocket opens.
-const webSocketOpen = proxy
-    ? proxiedWebSockets
-        ? dispatchedOpener(proxiedWebSockets)
-        : () => {
-            throw new Error("no WebSocket through the proxy");
-        }
-    : insecureWebSockets
-        ? webSocketOpener(unverifiedHost, insecureWebSockets)
-        : undefined;
-if (proxy && !proxiedWebSockets) {
-    process.stderr.write("swf2es: --proxy: this Electron's WebSocket cannot go through a proxy\n");
-}
 /** What the page's requests under way abort with, by the preload's number. */
 const requests = new Map();
-let settings;
-/** What the network judges the movie playing as; null for none, or one without networking. */
-let networkMovie = null;
-let window = null;
-/** The dialog that asks for a URL, while it is open. */
-let prompt = null;
-let current = null;
-/** The servers the SWF playing was allowed, or denied, a socket to until it closes: "host:port". */
-let allowedOnce = new Set();
-let deniedOnce = new Set();
-/** The prompts on screen, by "host:port": a second connection there waits on the first's answer. */
-const asking = new Map();
-/**
- * The page has asked to start and listens for what opens: until then, start() hands it the movie.
- */
-let listening = false;
-/** The longest URL a SWF is opened by. */
-const MAX_URL = 8192;
-/** The AIR application playing, as its command line asked for it; null for none. */
-let air = null;
-/** The EncryptedLocalStore of the AIR application playing, if one is. */
-let encryptedItems = null;
-/**
- * `text` as the URL of a remote SWF: http or https, with a host and no
- * credentials, its fragment dropped; null if it is not one.
- */
-function remoteUrl(text) {
-    if (text.length > MAX_URL) {
-        return null;
-    }
-    let url;
-    try {
-        url = new URL(text.trim());
-    }
-    catch {
-        return null;
-    }
-    if ((url.protocol !== "http:" && url.protocol !== "https:") || !url.hostname) {
-        return null;
-    }
-    if (url.username || url.password) {
-        return null;
-    }
-    url.hash = "";
-    return url;
-}
-/**
- * The SWF named on a command line, from `cwd`: the last argument after the
- * app's own that is an http or https URL or names a .swf file there is.
- * Chromium's and Electron's switches may take values of their own
- * (`--switch value`), so the first argument that is not a switch could be one.
- */
-function movieFromArguments(argv, cwd = process.cwd()) {
-    const named = argv
-        .slice(process.defaultApp ? 2 : 1)
-        .filter((a) => !a.startsWith("-"))
-        .map((a) => remoteUrl(a)?.href ?? (/\.swf$/i.test(a) ? resolve(cwd, a) : null))
-        .filter((a) => a !== null);
-    return (named.reverse().find((a) => remoteUrl(a) || statSync(a, { throwIfNoEntry: false })?.isFile()) ??
-        null);
-}
-/** Whether a message comes from the window's own page, on swf2es://app/. */
-function trusted(event) {
-    const frame = event.senderFrame;
-    return (window !== null &&
-        event.sender === window.webContents &&
-        frame !== null &&
-        frame.parent === null &&
-        // Node's URL gives a scheme it does not know no origin: compare the text.
-        frame.url.startsWith(`${APP_ORIGIN}/`));
-}
 /** How long after a click or a key a SWF may open a page: Chromium's transient activation. */
 const GESTURE_MS = 5000;
 /** The least time between two pages opened, whatever the gestures. */
@@ -219,432 +90,6 @@ function openExternal(url) {
     openedAt = now;
     void shell.openExternal(url);
 }
-/**
- * How much of a SWF the main process reads to choose its sandbox: far more than FileAttributes
- * takes compressed.
- */
-const START = 64 * 1024;
-const USE_NETWORK = 0x01;
-/**
- * The first `length` bytes of the file at `path`, or as many as it has, at least `least`; null
- * otherwise.
- */
-async function readStart(path, length, least = 8) {
-    try {
-        const file = await openFile(path);
-        try {
-            const bytes = new Uint8Array(length);
-            const { bytesRead } = await file.read(bytes, 0, length, 0);
-            return bytesRead >= Math.min(least, length) ? bytes.subarray(0, bytesRead) : null;
-        }
-        finally {
-            await file.close();
-        }
-    }
-    catch {
-        return null;
-    }
-}
-function refuse(message, detail) {
-    if (window) {
-        void dialog.showMessageBox(window, { type: "error", message, detail });
-    }
-}
-/** Open what the recent list, the command line or a reload names: a URL, a SWF's path or a descriptor's. */
-function openEntry(entry) {
-    if (remoteUrl(entry)) {
-        return openUrl(entry);
-    }
-    // A descriptor reopened from the recent list or a reload, with the arguments it was run with.
-    if (/\.xml$/i.test(entry)) {
-        return openAir(air?.descriptor === entry ? air : { descriptor: entry, root: null, arguments: [] }, process.cwd());
-    }
-    return open(entry);
-}
-/**
- * Run the AIR application `command` names, as adl does: its content SWF in
- * the window, at the descriptor's size, in AIR's application sandbox, with
- * its launch (shared/api.ts AirLaunch), from `cwd`.
- */
-async function openAir(command, cwd) {
-    const name = basename(command.descriptor);
-    let opened;
-    try {
-        opened = airLaunch(command, cwd, app.getPath("userData"), {
-            documents: app.getPath("documents"),
-            desktop: app.getPath("desktop"),
-            cache: app.getPath("temp"),
-        });
-    }
-    catch (error) {
-        refuse(`${name} could not be opened.`, String(error));
-        return;
-    }
-    const head = await readStart(opened.content, START);
-    const signature = head ? String.fromCharCode(...head.subarray(0, 3)) : "";
-    if (!head || (signature !== "FWS" && signature !== "CWS" && signature !== "ZWS")) {
-        refuse(`${name}'s content is not a SWF.`, opened.content);
-        return;
-    }
-    const content = await realpath(opened.content);
-    sandbox.playApplication(content);
-    air = command;
-    // Beside its storage directory, by its id, as AIR keeps it; encrypted by the system's keychain where it has one.
-    encryptedItems = new EncryptedItems(join(dirname(opened.launch.directories.applicationStorage), "EncryptedLocalStore"), safeStorage.isEncryptionAvailable()
-        ? {
-            encrypt: (text) => new Uint8Array(safeStorage.encryptString(text)),
-            decrypt: (data) => safeStorage.decryptString(Buffer.from(data)),
-        }
-        : null);
-    if (window && opened.width && opened.height) {
-        window.setSize(opened.width, opened.height);
-    }
-    // Played from app:/, as AIR plays it: its relative URLs, and loaderInfo.url, are the application's.
-    const url = `app:/${opened.relative
-        .split("/")
-        .filter((s) => s !== "")
-        .map(encodeURIComponent)
-        .join("/")}`;
-    show(command.descriptor, { url, name: opened.title, sandbox: "application", air: opened.launch }, { kind: "application" });
-}
-/** Play `movie` in the window, in place of what plays: what the user opened, as `entry`. */
-function show(entry, movie, onNetwork) {
-    current = { path: entry, movie };
-    playOnNetwork(onNetwork);
-    allowedOnce = new Set();
-    deniedOnce = new Set();
-    settings.opened(entry);
-    buildMenu();
-    if (window) {
-        // An AIR application's window is its own: its title alone, as adl shows it.
-        window.setTitle(movie.air ? movie.name : `${movie.name} — ${TITLE}`);
-        if (listening) {
-            window.webContents.send("desktop:open", movie);
-        }
-    }
-}
-/**
- * Play the SWF at `text`, an http or https URL, in Flash's remote sandbox:
- * no local file, and the network as its origin's (network.ts). The page
- * fetches it through the main process like anything it loads.
- */
-async function openUrl(text) {
-    const url = remoteUrl(text);
-    if (!url) {
-        refuse("Only an http or https URL opens.", text.slice(0, 200));
-        return;
-    }
-    const last = url.pathname.split("/").pop() ?? "";
-    let name;
-    try {
-        name = decodeURIComponent(last) || url.host;
-    }
-    catch {
-        name = last;
-    }
-    air = null;
-    sandbox.playRemote(url.href);
-    show(url.href, { url: url.href, name, sandbox: "remote" }, { kind: "remote", url: url.href });
-}
-/**
- * Open the file the user chose in the dialog, dropped on the window or
- * opened with the app: an AIR application's descriptor (`.xml`) runs the
- * application, anything else is played as a SWF.
- */
-async function openChosen(path) {
-    if (!/\.xml$/i.test(path)) {
-        return open(path);
-    }
-    // An application has an installed program's reach, which a file chosen in
-    // passing should not get unasked: asked once, until it leaves the recent list.
-    if (window && !settings.settings.recent.includes(path)) {
-        const { response } = await dialog.showMessageBox(window, {
-            type: "question",
-            message: `Run ${basename(path)} as an AIR application?`,
-            detail: "An AIR application reads and writes your files and reaches the network unasked, as an installed program does. Run only one you trust.",
-            buttons: ["Run", "Cancel"],
-            defaultId: 1,
-            cancelId: 1,
-        });
-        if (response !== 0) {
-            return;
-        }
-    }
-    // Run from its own directory, with no arguments, as one started by its icon is.
-    return openAir({ descriptor: path, root: null, arguments: [] }, dirname(path));
-}
-/** Play the SWF at `path` in the window, in place of what plays, in its sandbox. */
-async function open(path) {
-    const name = basename(path);
-    // Its start alone: the main process never decompresses a SWF whole, whose
-    // header may name 4 GB. FileAttributes, the first tag, lies in it.
-    const head = await readStart(path, START);
-    const signature = head ? String.fromCharCode(...head.subarray(0, 3)) : "";
-    if (!head || (signature !== "FWS" && signature !== "CWS" && signature !== "ZWS")) {
-        refuse(`${name} is not a SWF.`, path);
-        return;
-    }
-    const useNetwork = (fileAttributes(head) & USE_NETWORK) !== 0;
-    let url;
-    try {
-        air = null;
-        url = sandbox.play(path, useNetwork);
-    }
-    catch (error) {
-        // Gone, or unreadable, since it was read.
-        refuse(`${name} could not be opened.`, String(error));
-        return;
-    }
-    app.addRecentDocument(path);
-    show(path, { url, name, sandbox: useNetwork ? "localWithNetwork" : "localWithFile" }, useNetwork ? { kind: "local" } : null);
-}
-/** Judge requests for `movie` from now on: the last one's are aborted. */
-function playOnNetwork(movie) {
-    networkMovie = movie;
-    network.play(movie);
-}
-function closeMovie() {
-    current = null;
-    air = null;
-    sandbox.stop();
-    playOnNetwork(null);
-    buildMenu();
-    window?.setTitle(TITLE);
-    if (listening) {
-        window?.webContents.send("desktop:close");
-    }
-}
-/**
- * Whether the SWF playing may connect a socket to `host`:`port`, and where
- * to: only with the network, and only as the user allows, once or always
- * for that SWF, when it first asks for that server; and for a remote SWF,
- * as that server's socket policy allows, at the address it came from.
- * Denied where no one can be asked.
- */
-async function permitSocket(host, port) {
-    // AIR's application sandbox connects where it likes, unasked, with no socket policy.
-    if (sandbox.application) {
-        return {};
-    }
-    const playing = current;
-    const swf = sandbox.swf;
-    const endpoint = `${host}:${port}`;
-    if (!playing || !swf || !sandbox.networkAllowed()) {
-        process.stderr.write(`swf2es: no socket to ${endpoint}: the SWF has no network\n`);
-        return null;
-    }
-    if (!(await allowedByUser(playing, swf, endpoint))) {
-        return null;
-    }
-    if (networkMovie?.kind !== "remote") {
-        return {};
-    }
-    try {
-        return { address: await network.socketAddress(host, port) };
-    }
-    catch (error) {
-        process.stderr.write(`swf2es: no socket to ${endpoint}: ${error.message}\n`);
-        return null;
-    }
-}
-/** Whether the user allows the SWF playing a socket to `endpoint`, asked once a server. */
-async function allowedByUser(playing, swf, endpoint) {
-    if (settings.socketAllowed(swf, endpoint) || allowedOnce.has(endpoint)) {
-        return true;
-    }
-    if (deniedOnce.has(endpoint)) {
-        return false;
-    }
-    let answer = asking.get(endpoint);
-    if (!answer) {
-        answer = askForSocket(playing.movie.name, swf, endpoint).finally(() => asking.delete(endpoint));
-        asking.set(endpoint, answer);
-    }
-    return (await answer) && current === playing;
-}
-async function askForSocket(name, swf, endpoint) {
-    if (!window) {
-        return false;
-    }
-    const playing = current;
-    let response;
-    try {
-        ({ response } = await dialog.showMessageBox(window, {
-            type: "question",
-            message: `${name} asks to connect to ${endpoint}.`,
-            detail: "A socket lets the SWF send that server whatever it has. " +
-                "Allow it only for a server you trust.",
-            buttons: ["Allow Once", "Always Allow for This SWF", "Deny"],
-            defaultId: 2,
-            cancelId: 2,
-            noLink: true,
-        }));
-    }
-    catch {
-        return false;
-    }
-    if (current !== playing) {
-        return false;
-    }
-    switch (response) {
-        case 0:
-            allowedOnce.add(endpoint);
-            return true;
-        case 1:
-            if (!settings.allowSocket(swf, endpoint)) {
-                allowedOnce.add(endpoint);
-            }
-            return true;
-        default:
-            deniedOnce.add(endpoint);
-            return false;
-    }
-}
-/**
- * Whether what plays may open a WebSocket to `url`: an AIR application,
- * unasked and anywhere, as AIR's application sandbox connects and as its
- * sockets do here. air.net.WebSocket is AIR's alone, so nothing else has one.
- */
-function permitWebSocket(url) {
-    if (sandbox.application && hasWebSocket() && (!proxy || proxiedWebSockets)) {
-        return true;
-    }
-    const why = !sandbox.application
-        ? "only an AIR application has one"
-        : !hasWebSocket()
-            ? "this Electron has no WebSocket client"
-            : "this Electron's WebSocket cannot go through the proxy";
-    process.stderr.write(`swf2es: no WebSocket to ${url.slice(0, 2048)}: ${why}\n`);
-    return false;
-}
-async function showOpenDialog() {
-    if (!window) {
-        return;
-    }
-    const result = await dialog.showOpenDialog(window, {
-        title: "Open a SWF or an AIR application",
-        properties: ["openFile"],
-        filters: [
-            { name: "SWF and AIR application descriptors", extensions: ["swf", "xml"] },
-            { name: "All files", extensions: ["*"] },
-        ],
-    });
-    if (!result.canceled && result.filePaths[0]) {
-        await openChosen(result.filePaths[0]);
-    }
-}
-/** Ask for a library, check that it is ABC, keep its path, and start the page again with it. */
-async function chooseLibrary(name) {
-    if (!window) {
-        return;
-    }
-    const result = await dialog.showOpenDialog(window, {
-        title: `Choose ${name}.abc`,
-        properties: ["openFile"],
-        filters: [
-            { name: "ActionScript bytecode", extensions: ["abc"] },
-            { name: "All files", extensions: ["*"] },
-        ],
-    });
-    const path = result.filePaths[0];
-    if (result.canceled || !path) {
-        return;
-    }
-    // An ABC starts with its minor version, then its major one, 46.
-    const head = await readStart(path, 4);
-    if (head?.[2] !== 46 || head[3] !== 0) {
-        refuse(`${basename(path)} is not an ABC file.`, `swf2es needs ${name}.abc itself.`);
-        return;
-    }
-    if (!settings.setLibrary(name, path)) {
-        refuse("The settings could not be saved.", `swf2es uses ${path} until it quits.`);
-    }
-    buildMenu();
-    // The page fetched the libraries once; a fresh page fetches the new one.
-    window.webContents.reload();
-}
-/** Play on the library the app ships again, in place of one the user chose. */
-function resetLibrary(name) {
-    if (!settings.clearLibrary(name)) {
-        refuse("The settings could not be saved.", `swf2es uses its own ${name} until it quits.`);
-    }
-    buildMenu();
-    window?.webContents.reload();
-}
-function buildMenu() {
-    const recent = settings.settings.recent;
-    const template = [
-        ...(process.platform === "darwin" ? [{ role: "appMenu" }] : []),
-        {
-            label: "&File",
-            submenu: [
-                { label: "&Open…", accelerator: "CmdOrCtrl+O", click: () => void showOpenDialog() },
-                { label: "Open &URL…", accelerator: "CmdOrCtrl+L", click: showUrlDialog },
-                {
-                    label: "Open &Recent",
-                    submenu: [
-                        ...recent.map((entry) => ({ label: entry, click: () => void openEntry(entry) })),
-                        ...(recent.length > 0 ? [{ type: "separator" }] : []),
-                        {
-                            label: "Clear Recent",
-                            enabled: recent.length > 0,
-                            click: () => {
-                                settings.clearRecent();
-                                app.clearRecentDocuments();
-                                buildMenu();
-                            },
-                        },
-                    ],
-                },
-                {
-                    id: "close-movie",
-                    label: "&Close Movie",
-                    accelerator: "CmdOrCtrl+W",
-                    enabled: !!current,
-                    click: closeMovie,
-                },
-                { type: "separator" },
-                { label: "Choose playerglobal.abc…", click: () => void chooseLibrary("playerglobal") },
-                {
-                    label: "Use the App's playerglobal",
-                    enabled: !!settings.settings.playerglobal,
-                    click: () => resetLibrary("playerglobal"),
-                },
-                { type: "separator" },
-                { role: "quit" },
-            ],
-        },
-        {
-            label: "&View",
-            submenu: [
-                {
-                    id: "reload-movie",
-                    label: "&Reload Movie",
-                    accelerator: "CmdOrCtrl+R",
-                    enabled: !!current,
-                    click: () => current && void openEntry(current.path),
-                },
-                { role: "togglefullscreen", accelerator: "F11" },
-                { type: "separator" },
-                {
-                    id: "stage3d",
-                    label: "Stage3D",
-                    type: "checkbox",
-                    checked: settings.stage3D,
-                    click: (item) => {
-                        if (!settings.setStage3D(item.checked)) {
-                            refuse("The settings could not be saved.", "The Stage3D choice holds until you quit.");
-                        }
-                        window?.webContents.reload();
-                    },
-                },
-                { type: "separator" },
-                { role: "toggleDevTools" },
-            ],
-        },
-    ];
-    Menu.setApplicationMenu(Menu.buildFromTemplate(template));
-}
 /**
  * The window's page may go nowhere but swf2es://app/, and open nothing but the system's browser.
  */
@@ -664,7 +109,7 @@ function guard(contents) {
     });
     contents.on("did-start-navigation", (details) => {
         if (details.isMainFrame && !details.isSameDocument) {
-            listening = false;
+            setListening(false);
             // The page's requests go with it; the next page asks for the movie again.
             network.play(networkMovie);
             requests.clear();
@@ -677,63 +122,8 @@ function guard(contents) {
         });
     }
 }
-/**
- * The dialog that asks for a SWF's URL: a window of its own, apart from the
- * page, so that only the user, and never a SWF, opens one by its URL.
- */
-function showUrlDialog() {
-    if (!window) {
-        return;
-    }
-    if (prompt) {
-        prompt.focus();
-        return;
-    }
-    const dialogWindow = new BrowserWindow({
-        parent: window,
-        modal: true,
-        width: 560,
-        height: 180,
-        resizable: false,
-        minimizable: false,
-        maximizable: false,
-        fullscreenable: false,
-        title: "Open URL",
-        show: false,
-        webPreferences: {
-            preload: promptPreload,
-            contextIsolation: true,
-            sandbox: true,
-            nodeIntegration: false,
-            webSecurity: true,
-            spellcheck: false,
-        },
-    });
-    prompt = dialogWindow;
-    dialogWindow.setMenu(null);
-    dialogWindow.on("page-title-updated", (event) => event.preventDefault());
-    dialogWindow.once("ready-to-show", () => dialogWindow.show());
-    dialogWindow.on("closed", () => {
-        if (prompt === dialogWindow) {
-            prompt = null;
-        }
-    });
-    const contents = dialogWindow.webContents;
-    contents.on("will-navigate", (event) => event.preventDefault());
-    contents.setWindowOpenHandler(() => ({ action: "deny" }));
-    void dialogWindow.loadURL(PROMPT_URL);
-}
-/** Whether a message comes from the URL dialog's own page. */
-function fromPrompt(event) {
-    const frame = event.senderFrame;
-    return (prompt !== null &&
-        event.sender === prompt.webContents &&
-        frame !== null &&
-        frame.parent === null &&
-        frame.url === PROMPT_URL);
-}
 function createWindow() {
-    window = new BrowserWindow({
+    const window = new BrowserWindow({
         width: 1024,
         height: 768,
         title: TITLE,
@@ -745,12 +135,18 @@ function createWindow() {
             nodeIntegration: false,
             webSecurity: true,
             spellcheck: false,
+            // A SWF plays on, as in Flash, while the window is minimized or covered: throttled, its
+            // timers would fire once a second at most, and a covered window on Windows would count
+            // as hidden. A game's server takes the silence for a lost client, and what the SWF then
+            // answers all at once for a flood (Playback's timer, in @swf2es/web).
+            backgroundThrottling: false,
         },
     });
+    setWindow(window);
     // The title is the movie's, set here, not the page's <title>.
     window.on("page-title-updated", (event) => event.preventDefault());
     window.on("closed", () => {
-        window = null;
+        setWindow(null);
     });
     // The page hears of full screen however it came, a SWF's Stage.displayState or the menu's F11.
     window.on("enter-full-screen", () => window?.webContents.send("desktop:full-screen", true));
@@ -770,7 +166,7 @@ function listen() {
         if (!trusted(event)) {
             throw new Error("not the app's page");
         }
-        listening = true;
+        setListening(true);
         return {
             stage3D: settings.stage3D,
             libraries: settings.libraries(),
@@ -850,162 +246,6 @@ function listen() {
     });
     listenForAir();
 }
-/** The window as an AIR application's NativeWindow reads it. */
-function windowState(w) {
-    const bounds = w.getBounds();
-    const content = w.getContentBounds();
-    return {
-        bounds,
-        contentOffset: { x: content.x - bounds.x, y: content.y - bounds.y },
-        title: w.getTitle(),
-        displayState: w.isMinimized() ? "minimized" : w.isMaximized() ? "maximized" : "normal",
-        active: w.isFocused(),
-        visible: w.isVisible(),
-    };
-}
-/** The displays as an AIR application's Screen reads them: the work area is past the system's bars. */
-function screenStates() {
-    const primary = screen.getPrimaryDisplay().id;
-    return screen.getAllDisplays().map((display) => ({
-        bounds: display.bounds,
-        visibleBounds: display.workArea,
-        colorDepth: display.colorDepth,
-        main: display.id === primary,
-    }));
-}
-/**
- * An AIR application's reach, shared/api.ts DesktopAir: the file system
- * and the window, only while one the user opened plays and only for its
- * page. The file system is read synchronously where File reads it so.
- */
-function listenForAir() {
-    const playing = (event) => trusted(event) && sandbox.application;
-    ipcMain.on("air:stat", (event, path) => {
-        event.returnValue = playing(event) && typeof path === "string" ? statOf(path) : null;
-    });
-    ipcMain.on("air:list", (event, path) => {
-        event.returnValue = playing(event) && typeof path === "string" ? listOf(path) : null;
-    });
-    // FileStream's open, which reads a file at once, as stat does: only once the application plays.
-    ipcMain.on("air:read-sync", (event, path) => {
-        event.returnValue = playing(event) && typeof path === "string" ? readOf(path) : null;
-    });
-    // EncryptedLocalStore, at once as its methods are: only the application playing's.
-    const items = (event) => (playing(event) ? encryptedItems : null);
-    ipcMain.on("air:item-get", (event, name) => {
-        event.returnValue = typeof name === "string" ? (items(event)?.get(name) ?? null) : null;
-    });
-    ipcMain.on("air:item-set", (event, name, bytes) => {
-        if (typeof name === "string" && bytes instanceof Uint8Array) {
-            items(event)?.set(name, bytes);
-        }
-        event.returnValue = null;
-    });
-    ipcMain.on("air:item-remove", (event, name) => {
-        if (typeof name === "string") {
-            items(event)?.remove(name);
-        }
-        event.returnValue = null;
-    });
-    ipcMain.on("air:items-reset", (event) => {
-        items(event)?.reset();
-        event.returnValue = null;
-    });
-    // FileStream's writes and File's changes, at once as adl's: only once the application plays.
-    ipcMain.on("air:write-sync", (event, path, bytes, offset, length) => {
-        event.returnValue =
-            playing(event) &&
-                typeof path === "string" &&
-                bytes instanceof Uint8Array &&
-                Number.isSafeInteger(offset) &&
-                Number.isSafeInteger(length) &&
-                offset >= 0 &&
-                length >= 0 &&
-                writeOf(path, bytes, offset, length);
-    });
-    ipcMain.on("air:create-directory", (event, path) => {
-        event.returnValue = playing(event) && typeof path === "string" && createDirectoryOf(path);
-    });
-    ipcMain.on("air:remove", (event, path) => {
-        event.returnValue = playing(event) && typeof path === "string" && removeOf(path);
-    });
-    ipcMain.on("air:move", (event, from, to) => {
-        event.returnValue =
-            playing(event) && typeof from === "string" && typeof to === "string" && moveOf(from, to);
-    });
-    // A read is what starts the application's grant: the page reads its content SWF first.
-    ipcMain.handle("air:read", async (event, path) => {
-        if (!trusted(event) || typeof path !== "string" || !air) {
-            return null;
-        }
-        try {
-            const real = await realpath(resolveCase(path));
-            return sandbox.startApplication(real) ? new Uint8Array(await readFile(real)) : null;
-        }
-        catch {
-            return null;
-        }
-    });
-    ipcMain.on("air:window", (event) => {
-        event.returnValue = playing(event) && window ? windowState(window) : null;
-    });
-    ipcMain.on("air:screens", (event) => {
-        event.returnValue = playing(event) ? screenStates() : [];
-    });
-    ipcMain.on("air:set-bounds", (event, bounds) => {
-        const b = bounds;
-        const n = (v) => (typeof v === "number" && Number.isFinite(v) ? Math.round(v) : null);
-        const [x, y, width, height] = [n(b?.x), n(b?.y), n(b?.width), n(b?.height)];
-        if (playing(event) &&
-            window &&
-            x !== null &&
-            y !== null &&
-            width &&
-            height &&
-            width > 0 &&
-            height > 0) {
-            window.setBounds({ x, y, width, height });
-        }
-    });
-    ipcMain.on("air:set-title", (event, title) => {
-        if (playing(event) && window && typeof title === "string") {
-            window.setTitle(title.slice(0, 1024));
-        }
-    });
-    ipcMain.on("air:window-do", (event, what) => {
-        if (!playing(event) || !window) {
-            return;
-        }
-        switch (what) {
-            case "minimize":
-                window.minimize();
-                break;
-            case "maximize":
-                window.maximize();
-                break;
-            case "restore":
-                window.restore();
-                break;
-            case "activate":
-                window.focus();
-                break;
-            case "show":
-                window.show();
-                break;
-            case "hide":
-                window.hide();
-                break;
-            case "close":
-                window.close();
-                break;
-        }
-    });
-    ipcMain.on("air:exit", (event, code) => {
-        if (playing(event)) {
-            app.exit(typeof code === "number" ? code | 0 : 0);
-        }
-    });
-}
 /**
  * A request of the page's: the SWF's own, as the movie opened by its URL,
  * or what the SWF playing loads, only with the network, as network.ts
@@ -1103,7 +343,7 @@ void app.whenReady().then(() => {
     if (!first) {
         return;
     }
-    settings = new SettingsFile(app.getPath("userData"));
+    setSettings(new SettingsFile(app.getPath("userData")));
     // A playerglobal chosen once is kept across versions of the app: said at each start, as a
     // library older or newer than the app's own makes SWFs fail in ways nothing else explains.
     const chosen = settings.libraries().playerglobal;